જાવાસ્ક્રિપ્ટ ડેકોરેટર્સ: મેટાડેટા પ્રોગ્રામિંગ અને AOP પેટર્ન

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

જાવાસ્ક્રિપ્ટ ડેકોરેટર્સ શું છે?

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

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

ડેકોરેટર્સનો ઉપયોગ કરવાના ફાયદા

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

ડેકોરેટરના પ્રકારો

જાવાસ્ક્રિપ્ટ ડેકોરેટર્સને વિવિધ પ્રકારની ઘોષણાઓ પર લાગુ કરી શકાય છે, દરેકનો પોતાનો ચોક્કસ હેતુ અને સિન્ટેક્સ હોય છે:

ક્લાસ ડેકોરેટર્સ

ક્લાસ ડેકોરેટર્સ ક્લાસ કન્સ્ટ્રક્ટર પર લાગુ થાય છે અને તેનો ઉપયોગ ક્લાસની વ્યાખ્યાને સંશોધિત કરવા અથવા મેટાડેટા ઉમેરવા માટે કરી શકાય છે. ક્લાસ ડેકોરેટર તેના એકમાત્ર આર્ગ્યુમેન્ટ તરીકે ક્લાસ કન્સ્ટ્રક્ટર મેળવે છે.

ઉદાહરણ: ક્લાસમાં મેટાડેટા ઉમેરવું.

            
function Component(options: { selector: string, template: string }) {
  return function (constructor: T) {
    return class extends constructor {
      selector = options.selector;
      template = options.template;
    }
  }
}

@Component({ selector: 'my-component', template: '
Hello
' })
class MyComponent {
  constructor() {
    // ...
  }
}

console.log(new MyComponent().selector); // Output: my-component

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, Component ડેકોરેટર MyComponent ક્લાસમાં selector અને template પ્રોપર્ટીઝ ઉમેરે છે, જે તમને ઘટકના મેટાડેટાને ઘોષણાત્મક રીતે ગોઠવવાની મંજૂરી આપે છે. આ એંગ્યુલર ઘટકોને કેવી રીતે વ્યાખ્યાયિત કરવામાં આવે છે તેના જેવું જ છે.

મેથડ ડેકોરેટર્સ

મેથડ ડેકોરેટર્સ ક્લાસની અંદરની મેથડ્સ પર લાગુ થાય છે અને તેનો ઉપયોગ મેથડના વર્તનને સંશોધિત કરવા અથવા મેટાડેટા ઉમેરવા માટે કરી શકાય છે. મેથડ ડેકોરેટર ત્રણ આર્ગ્યુમેન્ટ્સ મેળવે છે:

• ટાર્ગેટ ઓબ્જેક્ટ (કાં તો ક્લાસ પ્રોટોટાઇપ અથવા ક્લાસ કન્સ્ટ્રક્ટર, મેથડ સ્ટેટિક છે કે નહીં તેના આધારે).
• મેથડનું નામ.
• મેથડ માટે પ્રોપર્ટી ડિસ્ક્રિપ્ટર.

ઉદાહરણ: મેથડ કોલ્સ લોગિંગ.

            
function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`Calling ${propertyKey} with arguments: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`${propertyKey} returned: ${result}`);
    return result;
  }

  return descriptor;
}

class Calculator {
  @Log
  add(a: number, b: number) {
    return a + b;
  }
}

const calculator = new Calculator();
calculator.add(2, 3); // Output: Calling add with arguments: [2,3]
                     //         add returned: 5

            

              
                Copy
              
            
          

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

પ્રોપર્ટી ડેકોરેટર્સ

પ્રોપર્ટી ડેકોરેટર્સ ક્લાસની અંદરની પ્રોપર્ટીઝ પર લાગુ થાય છે અને તેનો ઉપયોગ પ્રોપર્ટીના વર્તનને સંશોધિત કરવા અથવા મેટાડેટા ઉમેરવા માટે કરી શકાય છે. પ્રોપર્ટી ડેકોરેટર બે આર્ગ્યુમેન્ટ્સ મેળવે છે:

• ટાર્ગેટ ઓબ્જેક્ટ (કાં તો ક્લાસ પ્રોટોટાઇપ અથવા ક્લાસ કન્સ્ટ્રક્ટર, પ્રોપર્ટી સ્ટેટિક છે કે નહીં તેના આધારે).
• પ્રોપર્ટીનું નામ.

ઉદાહરણ: પ્રોપર્ટી મૂલ્યોને માન્ય કરવું.

            
function Validate(target: any, propertyKey: string) {
  let value: any;

  const getter = function () {
    return value;
  };

  const setter = function (newVal: any) {
    if (typeof newVal !== 'number' || newVal < 0) {
      throw new Error(`Invalid value for ${propertyKey}. Must be a non-negative number.`);
    }
    value = newVal;
  };

  Object.defineProperty(target, propertyKey, {
    get: getter,
    set: setter,
    enumerable: true,
    configurable: true,
  });
}

class Product {
  @Validate
  price: number;

  constructor(price: number) {
    this.price = price;
  }
}

const product = new Product(10);
console.log(product.price); // Output: 10

try {
  product.price = -5; // Throws an error
} catch (e) {
  console.error(e.message);
}

            

              
                Copy
              
            
          

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

પેરામીટર ડેકોરેટર્સ

પેરામીટર ડેકોરેટર્સ મેથડના પેરામીટર્સ પર લાગુ થાય છે અને તેનો ઉપયોગ મેટાડેટા ઉમેરવા અથવા પેરામીટરના વર્તનને સંશોધિત કરવા માટે કરી શકાય છે. પેરામીટર ડેકોરેટર ત્રણ આર્ગ્યુમેન્ટ્સ મેળવે છે:

• ટાર્ગેટ ઓબ્જેક્ટ (કાં તો ક્લાસ પ્રોટોટાઇપ અથવા ક્લાસ કન્સ્ટ્રક્ટર, મેથડ સ્ટેટિક છે કે નહીં તેના આધારે).
• મેથડનું નામ.
• મેથડની પેરામીટર સૂચિમાં પેરામીટરનો ઇન્ડેક્સ.

ઉદાહરણ: ડિપેન્ડન્સી ઇન્જેક્ટ કરવી.

            
import 'reflect-metadata';

const Injectable = (): ClassDecorator => {
    return (target: any) => {
        Reflect.defineMetadata('injectable', true, target);
    };
};

const Inject = (token: string): ParameterDecorator => {
    return (target: any, propertyKey: string | symbol, parameterIndex: number) => {
        let existingParameters: string[] = Reflect.getOwnMetadata('parameters', target, propertyKey) || [];
        existingParameters[parameterIndex] = token;
        Reflect.defineMetadata('parameters', existingParameters, target, propertyKey);
    };
};

@Injectable()
class Logger {
    log(message: string) {
        console.log(`Logger: ${message}`);
    }
}

class Greeter {
    private logger: Logger;

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

    greet(name: string) {
        this.logger.log(`Hello, ${name}!`);
    }
}

// Simple dependency injection container
class Container {
    private dependencies: Map = new Map();

    register(token: string, dependency: any) {
        this.dependencies.set(token, dependency);
    }

    resolve(target: any): T {
        const parameters: string[] = Reflect.getMetadata('parameters', target) || [];
        const resolvedDependencies = parameters.map(token => this.dependencies.get(token));
        return new target(...resolvedDependencies);
    }
}

const container = new Container();
container.register('Logger', new Logger());

const greeter = container.resolve(Greeter);
greeter.greet('World'); // Output: Logger: Hello, World!

            

              
                Copy
              
            
          

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

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

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

લોગિંગ અને ઓડિટિંગ

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

            
function LogMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = function (...args: any[]) {
        const startTime = performance.now();
        console.log(`[${new Date().toISOString()}] Calling method: ${propertyKey} with arguments: ${JSON.stringify(args)}`);
        const result = originalMethod.apply(this, args);
        const endTime = performance.now();
        const executionTime = endTime - startTime;
        console.log(`[${new Date().toISOString()}] Method ${propertyKey} returned: ${result}. Execution time: ${executionTime.toFixed(2)}ms`);
        return result;
    };

    return descriptor;
}

class ExampleClass {
    @LogMethod
    complexOperation(a: number, b: number): number {
        // Simulate a time-consuming operation
        let sum = 0;
        for (let i = 0; i < 1000000; i++) {
            sum += a + b + i;
        }
        return sum;
    }
}

const example = new ExampleClass();
example.complexOperation(5, 10);

            

              
                Copy
              
            
          

આ વિસ્તૃત ઉદાહરણ મેથડના અમલનો સમય માપે છે અને તેને વર્તમાન ટાઇમસ્ટેમ્પ સાથે લોગ કરે છે, જે પ્રદર્શન વિશ્લેષણ માટે વધુ વિગતવાર માહિતી પ્રદાન કરે છે.

અધિકૃતતા અને પ્રમાણીકરણ

ડેકોરેટર્સનો ઉપયોગ સુરક્ષા નીતિઓ લાગુ કરવા માટે કરી શકાય છે, મેથડ એક્ઝિક્યુટ કરતા પહેલા વપરાશકર્તાની ભૂમિકાઓ અને પરવાનગીઓ તપાસીને. આ સંવેદનશીલ ડેટા અને કાર્યક્ષમતામાં અનધિકૃત ઍક્સેસને અટકાવી શકે છે.

            
function Authorize(role: string) {
    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        const originalMethod = descriptor.value;

        descriptor.value = function (...args: any[]) {
            const userRole = getCurrentUserRole(); // Function to retrieve the current user's role

            if (userRole !== role) {
                throw new Error(`Unauthorized: User does not have the required role (${role}) to access this method.`);
            }

            return originalMethod.apply(this, args);
        };

        return descriptor;
    };
}

function getCurrentUserRole(): string {
    // In a real application, this would retrieve the user's role from authentication context
    return 'admin'; // Example: Hardcoded role for demonstration
}

class AdminPanel {
    @Authorize('admin')
    deleteUser(userId: number) {
        console.log(`User ${userId} deleted successfully.`);
    }

    @Authorize('editor')
    editArticle(articleId: number) {
        console.log(`Article ${articleId} edited successfully.`);
    }
}

const adminPanel = new AdminPanel();

try {
    adminPanel.deleteUser(123);
    adminPanel.editArticle(456); // This will throw an error because the user role is 'admin'
} catch (error) {
    console.error(error.message);
}

            

              
                Copy
              
            
          

આ વિસ્તૃત ઉદાહરણમાં, Authorize ડેકોરેટર મેથડને ઍક્સેસ કરવાની મંજૂરી આપતા પહેલા તપાસે છે કે વર્તમાન વપરાશકર્તા પાસે નિર્દિષ્ટ ભૂમિકા છે કે નહીં. getCurrentUserRole ફંક્શન (જે વાસ્તવિક એપ્લિકેશનમાં વાસ્તવિક વપરાશકર્તાની ભૂમિકા લાવશે) વપરાશકર્તાની વર્તમાન ભૂમિકા નક્કી કરવા માટે વપરાય છે. જો વપરાશકર્તા પાસે જરૂરી ભૂમિકા ન હોય, તો એક ભૂલ ફેંકવામાં આવે છે, જે મેથડને એક્ઝિક્યુટ થતી અટકાવે છે.

કેશિંગ

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

            
function Cache(ttl: number = 60) { // ttl in seconds, default to 60 seconds
    const cache = new Map();

    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        const originalMethod = descriptor.value;

        descriptor.value = async function (...args: any[]) {
            const cacheKey = `${propertyKey}-${JSON.stringify(args)}`;
            const cachedData = cache.get(cacheKey);

            if (cachedData && Date.now() < cachedData.expiry) {
                console.log(`Retrieving from cache: ${propertyKey} with arguments: ${JSON.stringify(args)}`);
                return cachedData.data;
            }

            console.log(`Executing and caching: ${propertyKey} with arguments: ${JSON.stringify(args)}`);
            const result = await originalMethod.apply(this, args);

            cache.set(cacheKey, {
                data: result,
                expiry: Date.now() + ttl * 1000, // Calculate expiry time
            });

            return result;
        };

        return descriptor;
    };
}

class DataService {
    @Cache(120) // Cache for 120 seconds
    async fetchData(id: number): Promise {
        // Simulate fetching data from a database or API
        return new Promise((resolve) => {
            setTimeout(() => {
                resolve(`Data for ID ${id} fetched from source.`);
            }, 1000); // Simulate a 1-second delay
        });
    }
}

const dataService = new DataService();

(async () => {
    console.log(await dataService.fetchData(1)); // Executes the method
    console.log(await dataService.fetchData(1)); // Retrieves from cache
    await new Promise(resolve => setTimeout(resolve, 121000)); // Wait for 121 seconds to allow the cache to expire
    console.log(await dataService.fetchData(1)); // Executes the method again after cache expiry
})();

            

              
                Copy
              
            
          

આ વિસ્તૃત ઉદાહરણ Map નો ઉપયોગ કરીને મૂળભૂત કેશિંગ મિકેનિઝમ લાગુ કરે છે. Cache ડેકોરેટર ડેકોરેટેડ મેથડના પરિણામોને નિર્દિષ્ટ ટાઇમ-ટુ-લાઇવ (TTL) માટે સંગ્રહિત કરે છે. જ્યારે મેથડને સમાન આર્ગ્યુમેન્ટ્સ સાથે ફરીથી કોલ કરવામાં આવે છે, ત્યારે મેથડને ફરીથી એક્ઝિક્યુટ કરવાને બદલે કેશ કરેલું પરિણામ પરત કરવામાં આવે છે. TTL સમાપ્ત થયા પછી, મેથડ ફરીથી એક્ઝિક્યુટ થાય છે, અને પરિણામ કેશ કરવામાં આવે છે.

વેલિડેશન

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

            
function Required() {
    return function (target: any, propertyKey: string) {
        if (!target.constructor.requiredFields) {
            target.constructor.requiredFields = [];
        }
        target.constructor.requiredFields.push(propertyKey);
    };
}

function ValidateClass(target: any) {
    const originalConstructor = target;

    function construct(constructor: any, args: any[]) {
        const instance: any = new constructor(...args);
        if (constructor.requiredFields) {
            constructor.requiredFields.forEach((field: string) => {
                if (!instance[field]) {
                    throw new Error(`Missing required field: ${field}`);
                }
            });
        }
        return instance;
    }

    const newConstructor: any = function (...args: any[]) {
        return construct(originalConstructor, args);
    };

    newConstructor.prototype = originalConstructor.prototype;
    return newConstructor;
}

@ValidateClass
class User {
    @Required()
    name: string;

    @Required()
    email: string;

    constructor(name: string, email: string) {
        this.name = name;
        this.email = email;
    }
}

try {
    const validUser = new User('John Doe', 'john.doe@example.com');
    console.log('Valid user created:', validUser);

    const invalidUser = new User('Jane Doe', ''); // Missing email
} catch (error) {
    console.error('Validation error:', error.message);
}


            

              
                Copy
              
            
          

આ ઉદાહરણ બે ડેકોરેટર્સનો ઉપયોગ કરે છે: Required અને ValidateClass. Required ડેકોરેટર પ્રોપર્ટીઝને જરૂરી તરીકે ચિહ્નિત કરે છે. ValidateClass ડેકોરેટર ક્લાસ કન્સ્ટ્રક્ટરને અટકાવે છે અને તપાસે છે કે બધા જરૂરી ફીલ્ડ્સમાં મૂલ્યો છે કે નહીં. જો કોઈ જરૂરી ફીલ્ડ ખૂટે છે, તો એક ભૂલ ફેંકવામાં આવે છે.

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

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

વિચારણાઓ અને શ્રેષ્ઠ પદ્ધતિઓ

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

વૈશ્વિક પરિપ્રેક્ષ્ય અને ઉદાહરણો

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

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

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

નિષ્કર્ષ

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

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