ટાઇપસ્ક્રિપ્ટ ડિક્લેરેશન મર્જિંગ: ઇન્ટરફેસ એક્સટેન્શનમાં નિપુણતા

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

ડિક્લેરેશન મર્જિંગને સમજવું

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

મુખ્ય ખ્યાલો

• સ્કોપ: ડિક્લેરેશન મર્જિંગ ફક્ત સમાન સ્કોપમાં જ થાય છે. વિવિધ મોડ્યુલો અથવા નેમસ્પેસમાંના ડિક્લેરેશન્સ મર્જ થશે નહીં.
• નામ: મર્જિંગ થવા માટે ડિક્લેરેશન્સનું નામ સમાન હોવું જોઈએ. કેસ સેન્સિટિવિટી મહત્વની છે.
• સભ્ય સુસંગતતા: ઇન્ટરફેસ મર્જ કરતી વખતે, સમાન નામના સભ્યો સુસંગત હોવા જોઈએ. જો તેમની પાસે વિરોધાભાસી ટાઇપ્સ હોય, તો કમ્પાઇલર એરર આપશે.

ડિક્લેરેશન મર્જિંગ સાથે ઇન્ટરફેસ એક્સટેન્શન

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

મૂળભૂત ઉદાહરણ

ચાલો એક સરળ ઉદાહરણથી શરૂઆત કરીએ. ધારો કે તમારી પાસે Person નામનું એક ઇન્ટરફેસ છે:

interface Person {
  name: string;
  age: number;
}

હવે, તમે મૂળ ડિક્લેરેશનમાં ફેરફાર કર્યા વિના Person ઇન્ટરફેસમાં વૈકલ્પિક email પ્રોપર્ટી ઉમેરવા માંગો છો. તમે ડિક્લેરેશન મર્જિંગનો ઉપયોગ કરીને આ કરી શકો છો:

interface Person {
  email?: string;
}

ટાઇપસ્ક્રિપ્ટ આ બે ડિક્લેરેશન્સને એક જ Person ઇન્ટરફેસમાં મર્જ કરશે:

interface Person {
  name: string;
  age: number;
  email?: string;
}

હવે, તમે નવી email પ્રોપર્ટી સાથે વિસ્તૃત Person ઇન્ટરફેસનો ઉપયોગ કરી શકો છો:

const person: Person = {
  name: "Alice",
  age: 30,
  email: "alice@example.com",
};

const anotherPerson: Person = {
  name: "Bob",
  age: 25,
};

console.log(person.email); // Output: alice@example.com
console.log(anotherPerson.email); // Output: undefined

બાહ્ય લાઇબ્રેરીઓમાંથી ઇન્ટરફેસનું વિસ્તરણ

ડિક્લેરેશન મર્જિંગનો એક સામાન્ય ઉપયોગ બાહ્ય લાઇબ્રેરીઓમાં વ્યાખ્યાયિત ઇન્ટરફેસનું વિસ્તરણ કરવાનો છે. ધારો કે તમે એક લાઇબ્રેરીનો ઉપયોગ કરી રહ્યાં છો જે Product નામનું ઇન્ટરફેસ પ્રદાન કરે છે:

// From an external library
interface Product {
  id: number;
  name: string;
  price: number;
}

તમે Product ઇન્ટરફેસમાં description પ્રોપર્ટી ઉમેરવા માંગો છો. તમે સમાન નામ સાથે એક નવો ઇન્ટરફેસ ડિક્લેર કરીને આ કરી શકો છો:

// In your code
interface Product {
  description?: string;
}

હવે, તમે નવી description પ્રોપર્ટી સાથે વિસ્તૃત Product ઇન્ટરફેસનો ઉપયોગ કરી શકો છો:

const product: Product = {
  id: 123,
  name: "Laptop",
  price: 1200,
  description: "A powerful laptop for professionals",
};

console.log(product.description); // Output: A powerful laptop for professionals

વ્યવહારુ ઉદાહરણો અને ઉપયોગના કિસ્સાઓ

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

૧. રિક્વેસ્ટ અને રિસ્પોન્સ ઑબ્જેક્ટ્સમાં પ્રોપર્ટીઝ ઉમેરવી

Express.js જેવા ફ્રેમવર્ક સાથે વેબ એપ્લિકેશન્સ બનાવતી વખતે, તમારે ઘણીવાર રિક્વેસ્ટ અથવા રિસ્પોન્સ ઑબ્જેક્ટ્સમાં કસ્ટમ પ્રોપર્ટીઝ ઉમેરવાની જરૂર પડે છે. ડિક્લેરેશન મર્જિંગ તમને ફ્રેમવર્કના સોર્સ કોડમાં ફેરફાર કર્યા વિના હાલના રિક્વેસ્ટ અને રિસ્પોન્સ ઇન્ટરફેસને વિસ્તારવાની મંજૂરી આપે છે.

ઉદાહરણ:

// Express.js
import express from 'express';

// Extend the Request interface
declare global {
  namespace Express {
    interface Request {
      userId?: string;
    }
  }
}

const app = express();

app.use((req, res, next) => {
  // Simulate authentication
  req.userId = "user123";
  next();
});

app.get('/', (req, res) => {
  const userId = req.userId;
  res.send(`Hello, user ${userId}!`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

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

૨. કન્ફિગરેશન ઑબ્જેક્ટ્સનું વિસ્તરણ

કન્ફિગરેશન ઑબ્જેક્ટ્સનો ઉપયોગ સામાન્ય રીતે એપ્લિકેશન્સ અને લાઇબ્રેરીઓના વર્તનને કન્ફિગર કરવા માટે થાય છે. ડિક્લેરેશન મર્જિંગનો ઉપયોગ તમારી એપ્લિકેશન માટે વિશિષ્ટ વધારાની પ્રોપર્ટીઝ સાથે કન્ફિગરેશન ઇન્ટરફેસને વિસ્તારવા માટે કરી શકાય છે.

ઉદાહરણ:

// Library configuration interface
interface Config {
  apiUrl: string;
  timeout: number;
}

// Extend the configuration interface
interface Config {
  debugMode?: boolean;
}

const defaultConfig: Config = {
  apiUrl: "https://api.example.com",
  timeout: 5000,
  debugMode: true,
};

// Function that uses the configuration
function fetchData(config: Config) {
  console.log(`Fetching data from ${config.apiUrl}`);
  console.log(`Timeout: ${config.timeout}ms`);
  if (config.debugMode) {
    console.log("Debug mode enabled");
  }
}

fetchData(defaultConfig);

આ ઉદાહરણમાં, અમે debugMode પ્રોપર્ટી ઉમેરવા માટે Config ઇન્ટરફેસને વિસ્તારી રહ્યાં છીએ. આ અમને કન્ફિગરેશન ઑબ્જેક્ટના આધારે ડિબગ મોડને સક્ષમ અથવા અક્ષમ કરવાની મંજૂરી આપે છે.

૩. હાલના ક્લાસમાં કસ્ટમ મેથડ્સ ઉમેરવી (મિક્સિન્સ)

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

ઉદાહરણ:

// Base class
class Logger {
  log(message: string) {
    console.log(`[LOG]: ${message}`);
  }
}

// Interface for the mixin
interface Timestamped {
  timestamp: Date;
  getTimestamp(): string;
}

// Mixin function
function Timestamped(Base: T) {
  return class extends Base implements Timestamped {
    timestamp: Date = new Date();

    getTimestamp(): string {
      return this.timestamp.toISOString();
    }
  };
}

type Constructor = new (...args: any[]) => {};

// Apply the mixin
const TimestampedLogger = Timestamped(Logger);

// Usage
const logger = new TimestampedLogger();
logger.log("Hello, world!");
console.log(logger.getTimestamp());

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

સંઘર્ષ નિવારણ

ઇન્ટરફેસ મર્જ કરતી વખતે, સમાન નામના સભ્યો વચ્ચેના સંભવિત સંઘર્ષો વિશે જાગૃત રહેવું મહત્વપૂર્ણ છે. ટાઇપસ્ક્રિપ્ટ પાસે આ સંઘર્ષોને ઉકેલવા માટે વિશિષ્ટ નિયમો છે.

વિરોધાભાસી ટાઇપ્સ

જો બે ઇન્ટરફેસ સમાન નામ પરંતુ અસંગત ટાઇપ્સ સાથે સભ્યો ડિક્લેર કરે, તો કમ્પાઇલર એરર આપશે.

ઉદાહરણ:

interface A {
  x: number;
}

interface A {
  x: string; // Error: Subsequent property declarations must have the same type.
}

આ સંઘર્ષને ઉકેલવા માટે, તમારે ખાતરી કરવાની જરૂર છે કે ટાઇપ્સ સુસંગત છે. આ કરવાની એક રીત યુનિયન ટાઇપનો ઉપયોગ કરવો છે:

interface A {
  x: number | string;
}

interface A {
  x: string | number;
}

આ કિસ્સામાં, બંને ડિક્લેરેશન્સ સુસંગત છે કારણ કે બંને ઇન્ટરફેસમાં x નો ટાઇપ number | string છે.

ફંક્શન ઓવરલોડ્સ

ફંક્શન ડિક્લેરેશન્સ સાથે ઇન્ટરફેસ મર્જ કરતી વખતે, ટાઇપસ્ક્રિપ્ટ ફંક્શન ઓવરલોડ્સને એક જ સેટમાં મર્જ કરે છે. કમ્પાઇલર કમ્પાઇલ સમયે કયો ઓવરલોડ વાપરવો તે નક્કી કરવા માટે ઓવરલોડ્સના ક્રમનો ઉપયોગ કરે છે.

ઉદાહરણ:

interface Calculator {
  add(x: number, y: number): number;
}

interface Calculator {
  add(x: string, y: string): string;
}

const calculator: Calculator = {
  add(x: number | string, y: number | string): number | string {
    if (typeof x === 'number' && typeof y === 'number') {
      return x + y;
    } else if (typeof x === 'string' && typeof y === 'string') {
      return x + y;
    } else {
      throw new Error('Invalid arguments');
    }
  },
};

console.log(calculator.add(1, 2)); // Output: 3
console.log(calculator.add("hello", "world")); // Output: hello world

આ ઉદાહરણમાં, અમે add મેથડ માટે અલગ-અલગ ફંક્શન ઓવરલોડ્સ સાથે બે Calculator ઇન્ટરફેસ મર્જ કરી રહ્યા છીએ. ટાઇપસ્ક્રિપ્ટ આ ઓવરલોડ્સને એક જ સેટમાં મર્જ કરે છે, જે અમને નંબર્સ અથવા સ્ટ્રિંગ્સ સાથે add મેથડને કૉલ કરવાની મંજૂરી આપે છે.

ઇન્ટરફેસ એક્સટેન્શન માટે શ્રેષ્ઠ પદ્ધતિઓ

તમે ઇન્ટરફેસ એક્સટેન્શનનો અસરકારક રીતે ઉપયોગ કરી રહ્યાં છો તેની ખાતરી કરવા માટે, આ શ્રેષ્ઠ પદ્ધતિઓનું પાલન કરો:

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

અદ્યતન દૃશ્યો

મૂળભૂત ઉદાહરણો ઉપરાંત, ડિક્લેરેશન મર્જિંગ વધુ જટિલ દૃશ્યોમાં શક્તિશાળી ક્ષમતાઓ પ્રદાન કરે છે.

જેનરિક ઇન્ટરફેસનું વિસ્તરણ

તમે ડિક્લેરેશન મર્જિંગનો ઉપયોગ કરીને જેનરિક ઇન્ટરફેસને વિસ્તારી શકો છો, જેમાં ટાઇપ સેફ્ટી અને લવચીકતા જાળવી શકાય છે.

interface DataStore {
  data: T[];
  add(item: T): void;
}

interface DataStore {
  find(predicate: (item: T) => boolean): T | undefined;
}

class MyDataStore implements DataStore {
  data: T[] = [];

  add(item: T): void {
    this.data.push(item);
  }

  find(predicate: (item: T) => boolean): T | undefined {
    return this.data.find(predicate);
  }
}

const numberStore = new MyDataStore();
numberStore.add(1);
numberStore.add(2);
const foundNumber = numberStore.find(n => n > 1);
console.log(foundNumber); // Output: 2

શરતી ઇન્ટરફેસ મર્જિંગ

જ્યારે આ સીધી સુવિધા નથી, તમે શરતી ટાઇપ્સ અને ડિક્લેરેશન મર્જિંગનો લાભ લઈને શરતી મર્જિંગની અસરો પ્રાપ્ત કરી શકો છો.

interface BaseConfig {
  apiUrl: string;
}

type FeatureFlags = {
  enableNewFeature: boolean;
};

// Conditional interface merging
interface BaseConfig {
  featureFlags?: FeatureFlags;
}

interface EnhancedConfig extends BaseConfig {
  featureFlags: FeatureFlags;
}

function processConfig(config: BaseConfig) {
  console.log(config.apiUrl);
  if (config.featureFlags?.enableNewFeature) {
    console.log("New feature is enabled");
  }
}

const configWithFlags: EnhancedConfig = {
  apiUrl: "https://example.com",
  featureFlags: {
    enableNewFeature: true,
  },
};

processConfig(configWithFlags);

ડિક્લેરેશન મર્જિંગનો ઉપયોગ કરવાના ફાયદા

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

ડિક્લેરેશન મર્જિંગની મર્યાદાઓ

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

નિષ્કર્ષ

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