ટાઇપસ્ક્રીપ્ટ એબ્સ્ટ્રેક્ટ ક્લાસીસ: પાર્શિયલ ઇમ્પ્લીમેન્ટેશન પેટર્ન્સમાં નિપુણતા

એબ્સ્ટ્રેક્ટ ક્લાસીસ ઓબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ (OOP) માં એક મૂળભૂત ખ્યાલ છે, જે અન્ય ક્લાસીસ માટે બ્લુપ્રિન્ટ પૂરી પાડે છે. ટાઇપસ્ક્રીપ્ટમાં, એબ્સ્ટ્રેક્ટ ક્લાસીસ સામાન્ય કાર્યક્ષમતાને વ્યાખ્યાયિત કરવા માટે એક શક્તિશાળી પદ્ધતિ પ્રદાન કરે છે, જ્યારે ડિરાઇવ્ડ ક્લાસીસ પર ચોક્કસ અમલીકરણની જરૂરિયાતો લાગુ પાડે છે. આ લેખ ટાઇપસ્ક્રીપ્ટ એબ્સ્ટ્રેક્ટ ક્લાસીસની જટિલતાઓમાં ઊંડાણપૂર્વક ઉતરે છે, પાર્શિયલ ઇમ્પ્લીમેન્ટેશન માટેની વ્યવહારુ પેટર્ન્સ પર ધ્યાન કેન્દ્રિત કરે છે, અને તે તમારા પ્રોજેક્ટ્સમાં કોડની પુનઃઉપયોગીતા, જાળવણીક્ષમતા અને સુગમતાને કેવી રીતે નોંધપાત્ર રીતે વધારી શકે છે.

એબ્સ્ટ્રેક્ટ ક્લાસીસ શું છે?

ટાઇપસ્ક્રીપ્ટમાં એબ્સ્ટ્રેક્ટ ક્લાસ એ એક એવો ક્લાસ છે જેનો સીધો ઇન્સ્ટન્સ બનાવી શકાતો નથી. તે અન્ય ક્લાસીસ માટે બેઝ ક્લાસ તરીકે સેવા આપે છે, જેમાં પ્રોપર્ટીઝ અને મેથડ્સનો સમૂહ વ્યાખ્યાયિત કરવામાં આવે છે જે ડિરાઇવ્ડ ક્લાસીસે અમલમાં મૂકવા (અથવા ઓવરરાઇડ કરવા) જ જોઈએ. એબ્સ્ટ્રેક્ટ ક્લાસીસ abstract કીવર્ડનો ઉપયોગ કરીને જાહેર કરવામાં આવે છે.

મુખ્ય લાક્ષણિકતાઓ:

• સીધો ઇન્સ્ટન્સ બનાવી શકાતો નથી.
• એબ્સ્ટ્રેક્ટ મેથડ્સ (અમલીકરણ વિનાની મેથડ્સ) સમાવી શકે છે.
• કોંક્રિટ મેથડ્સ (અમલીકરણ સાથેની મેથડ્સ) સમાવી શકે છે.
• ડિરાઇવ્ડ ક્લાસીસે બધી એબ્સ્ટ્રેક્ટ મેથડ્સનું અમલીકરણ કરવું જ જોઇએ.

એબ્સ્ટ્રેક્ટ ક્લાસીસનો ઉપયોગ શા માટે કરવો?

એબ્સ્ટ્રેક્ટ ક્લાસીસ સોફ્ટવેર ડેવલપમેન્ટમાં ઘણા ફાયદાઓ પ્રદાન કરે છે:

• કોડ પુનઃઉપયોગીતા: સંબંધિત ક્લાસીસ માટે એક સામાન્ય આધાર પૂરો પાડે છે, જેનાથી કોડ ડુપ્લિકેશન ઘટે છે.
• લાગુ કરેલ માળખું: ખાતરી કરે છે કે ડિરાઇવ્ડ ક્લાસીસ ચોક્કસ ઇન્ટરફેસ અને વર્તનનું પાલન કરે છે.
• પોલિમોર્ફિઝમ: ડિરાઇવ્ડ ક્લાસીસને એબ્સ્ટ્રેક્ટ ક્લાસના ઇન્સ્ટન્સ તરીકે ગણવાની સુવિધા આપે છે.
• એબ્સ્ટ્રેક્શન: અમલીકરણની વિગતો છુપાવે છે અને માત્ર જરૂરી ઇન્ટરફેસને જ પ્રદર્શિત કરે છે.

એબ્સ્ટ્રેક્ટ ક્લાસનું મૂળભૂત ઉદાહરણ

ચાલો ટાઇપસ્ક્રીપ્ટમાં એબ્સ્ટ્રેક્ટ ક્લાસના મૂળભૂત સિન્ટેક્સને સમજાવવા માટે એક સરળ ઉદાહરણથી શરૂઆત કરીએ:

abstract class Animal {
 abstract makeSound(): string;

 move(): void {
 console.log("Moving...");
 }
}

class Dog extends Animal {
 makeSound(): string {
 return "Woof!";
 }
}

class Cat extends Animal {
 makeSound(): string {
 return "Meow!";
 }
}

//const animal = new Animal(); // Error: Cannot create an instance of an abstract class.

const dog = new Dog();
console.log(dog.makeSound()); // Output: Woof!
dog.move(); // Output: Moving...

const cat = new Cat();
console.log(cat.makeSound()); // Output: Meow!
cat.move(); // Output: Moving...

આ ઉદાહરણમાં, Animal એ એક એબ્સ્ટ્રેક્ટ ક્લાસ છે જેમાં એક એબ્સ્ટ્રેક્ટ મેથડ makeSound() અને એક કોંક્રિટ મેથડ move() છે. Dog અને Cat ક્લાસીસ Animal ને એક્સટેન્ડ કરે છે અને makeSound() મેથડ માટે કોંક્રિટ અમલીકરણ પ્રદાન કરે છે. નોંધ કરો કે સીધો `Animal` નો ઇન્સ્ટન્સ બનાવવાનો પ્રયાસ કરવાથી એરર આવે છે.

પાર્શિયલ ઇમ્પ્લીમેન્ટેશન પેટર્ન્સ

એબ્સ્ટ્રેક્ટ ક્લાસીસના શક્તિશાળી પાસાઓમાંનું એક છે પાર્શિયલ ઇમ્પ્લીમેન્ટેશન વ્યાખ્યાયિત કરવાની ક્ષમતા. આ તમને કેટલીક મેથડ્સ માટે ડિફોલ્ટ અમલીકરણ પ્રદાન કરવાની મંજૂરી આપે છે જ્યારે ડિરાઇવ્ડ ક્લાસીસને અન્યનું અમલીકરણ કરવાની જરૂર પડે છે. આ કોડની પુનઃઉપયોગીતા અને સુગમતા વચ્ચે સંતુલન જાળવે છે.

૧. ડિરાઇવ્ડ ક્લાસીસમાં ડિફોલ્ટ ઇમ્પ્લીમેન્ટેશન સાથેની એબ્સ્ટ્રેક્ટ મેથડ્સ

આ પેટર્નમાં, એબ્સ્ટ્રેક્ટ ક્લાસ એક એબ્સ્ટ્રેક્ટ મેથડ જાહેર કરે છે જે ડિરાઇવ્ડ ક્લાસીસ દ્વારા અમલમાં મુકવી *જ* જોઈએ, પરંતુ તે કોઈ બેઝ ઇમ્પ્લીમેન્ટેશન ઓફર કરતું નથી. આ ડિરાઇવ્ડ ક્લાસીસને તેમનો પોતાનો તર્ક પૂરો પાડવા માટે દબાણ કરે છે.

abstract class DataProcessor {
 abstract fetchData(): Promise;
 abstract processData(data: any): any;
 abstract saveData(processedData: any): Promise;

 async run(): Promise {
 const data = await this.fetchData();
 const processedData = this.processData(data);
 await this.saveData(processedData);
 }
}

class APIProcessor extends DataProcessor {
 async fetchData(): Promise {
 // Implementation to fetch data from an API
 console.log("Fetching data from API...");
 return { data: "API Data" }; // Mock data
 }

 processData(data: any): any {
 // Implementation to process data specific to API data
 console.log("Processing API data...");
 return { processed: data.data + " - Processed" }; // Mock processed data
 }

 async saveData(processedData: any): Promise {
 // Implementation to save processed data to a database via API
 console.log("Saving processed API data...");
 console.log(processedData);
 }
}

const apiProcessor = new APIProcessor();
apiProcessor.run();

આ ઉદાહરણમાં, DataProcessor એબ્સ્ટ્રેક્ટ ક્લાસ ત્રણ એબ્સ્ટ્રેક્ટ મેથડ્સ વ્યાખ્યાયિત કરે છે: fetchData(), processData(), અને saveData(). APIProcessor ક્લાસ DataProcessor ને એક્સટેન્ડ કરે છે અને આ દરેક મેથડ્સ માટે કોંક્રિટ અમલીકરણ પ્રદાન કરે છે. એબ્સ્ટ્રેક્ટ ક્લાસમાં વ્યાખ્યાયિત run() મેથડ સમગ્ર પ્રક્રિયાનું સંચાલન કરે છે, ખાતરી કરે છે કે દરેક પગલું સાચા ક્રમમાં ચલાવવામાં આવે છે.

૨. એબ્સ્ટ્રેક્ટ ડિપેન્ડન્સીઝ સાથેની કોંક્રિટ મેથડ્સ

આ પેટર્નમાં એબ્સ્ટ્રેક્ટ ક્લાસમાં કોંક્રિટ મેથડ્સનો સમાવેશ થાય છે જે ચોક્કસ કાર્યો કરવા માટે એબ્સ્ટ્રેક્ટ મેથડ્સ પર આધાર રાખે છે. આ તમને સામાન્ય અલ્ગોરિધમ વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે જ્યારે અમલીકરણની વિગતો ડિરાઇવ્ડ ક્લાસીસને સોંપવામાં આવે છે.

abstract class PaymentProcessor {
 abstract validatePaymentDetails(paymentDetails: any): boolean;
 abstract chargePayment(paymentDetails: any): Promise;
 abstract sendConfirmationEmail(paymentDetails: any): Promise;

 async processPayment(paymentDetails: any): Promise {
 if (!this.validatePaymentDetails(paymentDetails)) {
 console.error("Invalid payment details.");
 return false;
 }

 const chargeSuccessful = await this.chargePayment(paymentDetails);
 if (!chargeSuccessful) {
 console.error("Payment failed.");
 return false;
 }

 await this.sendConfirmationEmail(paymentDetails);
 console.log("Payment processed successfully.");
 return true;
 }
}

class CreditCardPaymentProcessor extends PaymentProcessor {
 validatePaymentDetails(paymentDetails: any): boolean {
 // Validate credit card details
 console.log("Validating credit card details...");
 return true; // Mock validation
 }

 async chargePayment(paymentDetails: any): Promise {
 // Charge credit card
 console.log("Charging credit card...");
 return true; // Mock charge
 }

 async sendConfirmationEmail(paymentDetails: any): Promise {
 // Send confirmation email for credit card payment
 console.log("Sending confirmation email for credit card payment...");
 }
}

const creditCardProcessor = new CreditCardPaymentProcessor();
creditCardProcessor.processPayment({ cardNumber: "1234-5678-9012-3456", expiryDate: "12/24", cvv: "123", amount: 100 });

આ ઉદાહરણમાં, PaymentProcessor એબ્સ્ટ્રેક્ટ ક્લાસ એક processPayment() મેથડ વ્યાખ્યાયિત કરે છે જે સમગ્ર ચુકવણી પ્રક્રિયાના તર્કને સંભાળે છે. જોકે, validatePaymentDetails(), chargePayment(), અને sendConfirmationEmail() મેથડ્સ એબ્સ્ટ્રેક્ટ છે, જે દરેક ચુકવણી પદ્ધતિ (દા.ત., ક્રેડિટ કાર્ડ, પેપાલ, વગેરે) માટે ચોક્કસ અમલીકરણ પ્રદાન કરવા માટે ડિરાઇવ્ડ ક્લાસીસને જરૂરી બનાવે છે.

૩. ટેમ્પલેટ મેથડ પેટર્ન

ટેમ્પલેટ મેથડ પેટર્ન એ એક બિહેવિયરલ ડિઝાઇન પેટર્ન છે જે એબ્સ્ટ્રેક્ટ ક્લાસમાં અલ્ગોરિધમનું માળખું વ્યાખ્યાયિત કરે છે, પરંતુ સબક્લાસીસને તેના માળખાને બદલ્યા વિના અલ્ગોરિધમના ચોક્કસ પગલાંને ઓવરરાઇડ કરવા દે છે. આ પેટર્ન ખાસ કરીને ત્યારે ઉપયોગી છે જ્યારે તમારી પાસે ઓપરેશન્સનો ક્રમ હોય જે ચોક્કસ ક્રમમાં થવો જોઈએ, પરંતુ કેટલાક ઓપરેશન્સનું અમલીકરણ સંદર્ભના આધારે બદલાઈ શકે છે.

abstract class ReportGenerator {
 abstract generateHeader(): string;
 abstract generateBody(): string;
 abstract generateFooter(): string;

 generateReport(): string {
 const header = this.generateHeader();
 const body = this.generateBody();
 const footer = this.generateFooter();

 return `${header}\n${body}\n${footer}`;
 }
}

class PDFReportGenerator extends ReportGenerator {
 generateHeader(): string {
 return "PDF Report Header";
 }

 generateBody(): string {
 return "PDF Report Body";
 }

 generateFooter(): string {
 return "PDF Report Footer";
 }
}

class CSVReportGenerator extends ReportGenerator {
 generateHeader(): string {
 return "CSV Report Header";
 }

 generateBody(): string {
 return "CSV Report Body";
 }

 generateFooter(): string {
 return "CSV Report Footer";
 }
}

const pdfReportGenerator = new PDFReportGenerator();
console.log(pdfReportGenerator.generateReport());

const csvReportGenerator = new CSVReportGenerator();
console.log(csvReportGenerator.generateReport());

અહીં, `ReportGenerator` એ `generateReport()` માં સમગ્ર રિપોર્ટ જનરેશન પ્રક્રિયાને વ્યાખ્યાયિત કરે છે, જ્યારે વ્યક્તિગત પગલાં (હેડર, બોડી, ફૂટર) કોંક્રિટ સબક્લાસીસ `PDFReportGenerator` અને `CSVReportGenerator` પર છોડી દેવામાં આવે છે.

૪. એબ્સ્ટ્રેક્ટ પ્રોપર્ટીઝ

એબ્સ્ટ્રેક્ટ ક્લાસીસ એબ્સ્ટ્રેક્ટ પ્રોપર્ટીઝ પણ વ્યાખ્યાયિત કરી શકે છે, જે એવી પ્રોપર્ટીઝ છે જે ડિરાઇવ્ડ ક્લાસીસમાં અમલમાં મુકવી જ જોઈએ. આ ડિરાઇવ્ડ ક્લાસીસમાં અમુક ડેટા તત્વોની હાજરીને લાગુ કરવા માટે ઉપયોગી છે.

abstract class Configuration {
 abstract apiKey: string;
 abstract apiUrl: string;

 getFullApiUrl(): string {
 return `${this.apiUrl}/${this.apiKey}`;
 }
}

class ProductionConfiguration extends Configuration {
 apiKey: string = "prod_api_key";
 apiUrl: string = "https://api.example.com/prod";
}

class DevelopmentConfiguration extends Configuration {
 apiKey: string = "dev_api_key";
 apiUrl: string = "http://localhost:3000/dev";
}

const prodConfig = new ProductionConfiguration();
console.log(prodConfig.getFullApiUrl()); // Output: https://api.example.com/prod/prod_api_key

const devConfig = new DevelopmentConfiguration();
console.log(devConfig.getFullApiUrl()); // Output: http://localhost:3000/dev/dev_api_key

આ ઉદાહરણમાં, Configuration એબ્સ્ટ્રેક્ટ ક્લાસ બે એબ્સ્ટ્રેક્ટ પ્રોપર્ટીઝ વ્યાખ્યાયિત કરે છે: apiKey અને apiUrl. ProductionConfiguration અને DevelopmentConfiguration ક્લાસીસ Configuration ને એક્સટેન્ડ કરે છે અને આ પ્રોપર્ટીઝ માટે કોંક્રિટ મૂલ્યો પ્રદાન કરે છે.

એડવાન્સ્ડ વિચારણાઓ

એબ્સ્ટ્રેક્ટ ક્લાસીસ સાથે મિક્સિન્સ

ટાઇપસ્ક્રીપ્ટ તમને વધુ જટિલ અને પુનઃઉપયોગી ઘટકો બનાવવા માટે એબ્સ્ટ્રેક્ટ ક્લાસીસને મિક્સિન્સ સાથે જોડવાની મંજૂરી આપે છે. મિક્સિન્સ એ નાના, પુનઃઉપયોગી કાર્યક્ષમતાના ટુકડાઓને જોડીને ક્લાસીસ બનાવવાનો એક માર્ગ છે.

// ક્લાસના કન્સ્ટ્રક્ટર માટે એક ટાઇપ વ્યાખ્યાયિત કરો
type Constructor = new (...args: any[]) => T;

// એક મિક્સિન ફંક્શન વ્યાખ્યાયિત કરો
function Timestamped(Base: TBase) {
 return class extends Base {
 timestamp = new Date();
 };
}

// બીજું મિક્સિન ફંક્શન
function Logged(Base: TBase) {
 return class extends Base {
 log(message: string) {
 console.log(`${this.constructor.name}: ${message}`);
 }
 };
}

abstract class BaseEntity {
 abstract id: number;
}

// BaseEntity એબ્સ્ટ્રેક્ટ ક્લાસ પર મિક્સિન્સ લાગુ કરો
const TimestampedEntity = Timestamped(BaseEntity);
const LoggedEntity = Logged(TimestampedEntity);

class User extends LoggedEntity {
 id: number = 123;
 name: string = "John Doe";

 constructor() {
 super();
 this.log("User created");
 }
}

const user = new User();
console.log(user.id); // Output: 123
console.log(user.timestamp); // Output: Current timestamp
user.log("User updated"); // Output: User: User updated

આ ઉદાહરણ Timestamped અને Logged મિક્સિન્સને BaseEntity એબ્સ્ટ્રેક્ટ ક્લાસ સાથે જોડીને એક User ક્લાસ બનાવે છે જે ત્રણેયની કાર્યક્ષમતાને વારસામાં મેળવે છે.

ડિપેન્ડન્સી ઇન્જેક્શન

એબ્સ્ટ્રેક્ટ ક્લાસીસનો ઘટકોને ડીકપલ કરવા અને ટેસ્ટેબિલિટી સુધારવા માટે ડિપેન્ડન્સી ઇન્જેક્શન (DI) સાથે અસરકારક રીતે ઉપયોગ કરી શકાય છે. તમે તમારી ડિપેન્ડન્સીઝ માટે ઇન્ટરફેસ તરીકે એબ્સ્ટ્રેક્ટ ક્લાસીસને વ્યાખ્યાયિત કરી શકો છો અને પછી તમારા ક્લાસીસમાં કોંક્રિટ ઇમ્પ્લીમેન્ટેશન ઇન્જેક્ટ કરી શકો છો.

abstract class Logger {
 abstract log(message: string): void;
}

class ConsoleLogger extends Logger {
 log(message: string): void {
 console.log(`[Console]: ${message}`);
 }
}

class FileLogger extends Logger {
 log(message: string): void {
 // ફાઇલમાં લોગ કરવા માટેનું અમલીકરણ
 console.log(`[File]: ${message}`);
 }
}

class AppService {
 private logger: Logger;

 constructor(logger: Logger) {
 this.logger = logger;
 }

 doSomething() {
 this.logger.log("Doing something...");
 }
}

// ConsoleLogger ઇન્જેક્ટ કરો
const consoleLogger = new ConsoleLogger();
const appService1 = new AppService(consoleLogger);
appService1.doSomething();

// FileLogger ઇન્જેક્ટ કરો
const fileLogger = new FileLogger();
const appService2 = new AppService(fileLogger);
appService2.doSomething();

આ ઉદાહરણમાં, AppService ક્લાસ Logger એબ્સ્ટ્રેક્ટ ક્લાસ પર આધાર રાખે છે. કોંક્રિટ ઇમ્પ્લીમેન્ટેશન્સ (ConsoleLogger, FileLogger) રનટાઇમ પર ઇન્જેક્ટ કરવામાં આવે છે, જે તમને વિવિધ લોગિંગ વ્યૂહરચનાઓ વચ્ચે સરળતાથી સ્વિચ કરવાની મંજૂરી આપે છે.

શ્રેષ્ઠ પદ્ધતિઓ

• એબ્સ્ટ્રેક્ટ ક્લાસીસને કેન્દ્રિત રાખો: દરેક એબ્સ્ટ્રેક્ટ ક્લાસનો સ્પષ્ટ અને સુવ્યાખ્યાયિત હેતુ હોવો જોઈએ.
• અતિશય એબ્સ્ટ્રેક્શન ટાળો: એબ્સ્ટ્રેક્ટ ક્લાસીસ બનાવશો નહીં સિવાય કે તેઓ કોડ પુનઃઉપયોગીતા અથવા લાગુ કરેલ માળખાની દ્રષ્ટિએ નોંધપાત્ર મૂલ્ય પ્રદાન કરે.
• મુખ્ય કાર્યક્ષમતા માટે એબ્સ્ટ્રેક્ટ ક્લાસીસનો ઉપયોગ કરો: સામાન્ય તર્ક અને અલ્ગોરિધમ્સને એબ્સ્ટ્રેક્ટ ક્લાસીસમાં મૂકો, જ્યારે ચોક્કસ અમલીકરણોને ડિરાઇવ્ડ ક્લાસીસને સોંપો.
• એબ્સ્ટ્રેક્ટ ક્લાસીસનું સંપૂર્ણ દસ્તાવેજીકરણ કરો: એબ્સ્ટ્રેક્ટ ક્લાસના હેતુ અને ડિરાઇવ્ડ ક્લાસીસની જવાબદારીઓનું સ્પષ્ટપણે દસ્તાવેજીકરણ કરો.
• ઇન્ટરફેસનો વિચાર કરો: જો તમારે ફક્ત કોઈપણ અમલીકરણ વિના કોન્ટ્રેક્ટ વ્યાખ્યાયિત કરવાની જરૂર હોય, તો એબ્સ્ટ્રેક્ટ ક્લાસીસને બદલે ઇન્ટરફેસનો ઉપયોગ કરવાનું વિચારો.

નિષ્કર્ષ

ટાઇપસ્ક્રીપ્ટ એબ્સ્ટ્રેક્ટ ક્લાસીસ મજબૂત અને જાળવણીક્ષમ એપ્લિકેશન્સ બનાવવા માટે એક શક્તિશાળી સાધન છે. પાર્શિયલ ઇમ્પ્લીમેન્ટેશન પેટર્ન્સને સમજીને અને લાગુ કરીને, તમે લવચીક, પુનઃઉપયોગી અને સુવ્યવસ્થિત કોડ બનાવવા માટે એબ્સ્ટ્રેક્ટ ક્લાસીસના ફાયદાઓનો લાભ લઈ શકો છો. ડિફોલ્ટ ઇમ્પ્લીમેન્ટેશન સાથે એબ્સ્ટ્રેક્ટ મેથડ્સ વ્યાખ્યાયિત કરવાથી લઈને મિક્સિન્સ અને ડિપેન્ડન્સી ઇન્જેક્શન સાથે એબ્સ્ટ્રેક્ટ ક્લાસીસનો ઉપયોગ કરવા સુધી, શક્યતાઓ વિશાળ છે. શ્રેષ્ઠ પદ્ધતિઓનું પાલન કરીને અને તમારી ડિઝાઇન પસંદગીઓ પર કાળજીપૂર્વક વિચાર કરીને, તમે તમારા ટાઇપસ્ક્રીપ્ટ પ્રોજેક્ટ્સની ગુણવત્તા અને માપનીયતા વધારવા માટે એબ્સ્ટ્રેક્ટ ક્લાસીસનો અસરકારક રીતે ઉપયોગ કરી શકો છો.

ભલે તમે મોટા પાયે એન્ટરપ્રાઇઝ એપ્લિકેશન બનાવી રહ્યા હોવ કે નાની યુટિલિટી લાઇબ્રેરી, ટાઇપસ્ક્રીપ્ટમાં એબ્સ્ટ્રેક્ટ ક્લાસીસમાં નિપુણતા મેળવવી નિઃશંકપણે તમારી સોફ્ટવેર ડેવલપમેન્ટ કુશળતામાં સુધારો કરશે અને તમને વધુ અત્યાધુનિક અને જાળવણીક્ષમ ઉકેલો બનાવવામાં સક્ષમ બનાવશે.