M

MLOG

ಕನ್ನಡ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸಿ: ಕೋಡ್ ರಚನೆ, ಪುನರ್ಬಳಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್ ವೈಶಿಷ್ಟ್ಯ. ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅವುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಕಲಿಯಿರಿ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು: ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಶಕ್ತಿಯನ್ನು ಅನಾವರಣಗೊಳಿಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ ಹೆಚ್ಚಿಸಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಸುಂದರವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವು ಕ್ಲಾಸ್‌ಗಳು, ಮೆಥಡ್‌ಗಳು, ಪ್ರಾಪರ್ಟಿಗಳು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಡಿಸೈನ್ ಸಮಯದಲ್ಲಿ ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ವಿಸ್ತರಿಸಲು ಒಂದು ಯಾಂತ್ರಿಕತೆಯನ್ನು ನೀಡುತ್ತವೆ, ನಿಮ್ಮ ಕೋಡ್‌ನ ಮೂಲ ತರ್ಕವನ್ನು ಬದಲಾಯಿಸದೆ ನಡವಳಿಕೆ ಮತ್ತು ಅನೋಟೇಶನ್‌ಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳ ಜಟಿಲತೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಹಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಾವು ಡೆಕೋರೇಟರ್‌ಗಳು ಯಾವುವು, ಅವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಲಭ್ಯವಿರುವ ವಿವಿಧ ಪ್ರಕಾರಗಳು, ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಅವುಗಳ ಪರಿಣಾಮಕಾರಿ ಬಳಕೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನೀವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೊಸಬರಾಗಿರಲಿ ಅಥವಾ ಅನುಭವಿ ಡೆವಲಪರ್ ಆಗಿರಲಿ, ಈ ಮಾರ್ಗದರ್ಶಿ ನಿಮಗೆ ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತ ಕೋಡ್‌ಗಾಗಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಜ್ಞಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಎಂದರೇನು?

ಅವುಗಳ ಮೂಲದಲ್ಲಿ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಒಂದು ರೂಪವಾಗಿದೆ. ಅವು ಮೂಲತಃ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು (ಸಾಮಾನ್ಯವಾಗಿ ಅಲಂಕರಿಸಲಾಗುತ್ತಿರುವ ವಸ್ತು, ಉದಾಹರಣೆಗೆ ಕ್ಲಾಸ್, ಮೆಥಡ್, ಪ್ರಾಪರ್ಟಿ, ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್) ತೆಗೆದುಕೊಳ್ಳುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ ಮತ್ತು ಅದನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು ಅಥವಾ ಹೊಸ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಬಹುದು. ಇವುಗಳನ್ನು ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ನೀವು ಲಗತ್ತಿಸುವ ಅನೋಟೇಶನ್‌ಗಳು ಅಥವಾ ಅಟ್ರಿಬ್ಯೂಟ್‌ಗಳೆಂದು ಯೋಚಿಸಿ. ಈ ಅನೋಟೇಶನ್‌ಗಳನ್ನು ನಂತರ ಕೋಡ್ ಬಗ್ಗೆ ಮೆಟಾಡೇಟಾ ಒದಗಿಸಲು ಅಥವಾ ಅದರ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಲು ಬಳಸಬಹುದು.

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು `@` ಚಿಹ್ನೆಯನ್ನು ಬಳಸಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಫಂಕ್ಷನ್ ಕರೆಯನ್ನು (ಉದಾಹರಣೆಗೆ, `@decoratorName()`) ನೀಡಲಾಗುತ್ತದೆ. ನಂತರ ಡೆಕೋರೇಟರ್ ಫಂಕ್ಷನ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಡಿಸೈನ್-ಟೈಮ್ ಹಂತದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ.

ಡೆಕೋರೇಟರ್‌ಗಳು ಜಾವಾ, ಸಿ#, ಮತ್ತು ಪೈಥಾನ್‌ನಂತಹ ಭಾಷೆಗಳಲ್ಲಿನ ಇದೇ ರೀತಿಯ ವೈಶಿಷ್ಟ್ಯಗಳಿಂದ ಪ್ರೇರಿತವಾಗಿವೆ. ಅವು ನಿಮ್ಮ ಮೂಲ ತರ್ಕವನ್ನು ಸ್ವಚ್ಛವಾಗಿಟ್ಟುಕೊಂಡು ನಿಮ್ಮ ಮೆಟಾಡೇಟಾ ಅಥವಾ ಮಾರ್ಪಾಡು ಅಂಶಗಳನ್ನು ಮೀಸಲಾದ ಸ್ಥಳದಲ್ಲಿ ಇರಿಸುವ ಮೂಲಕ ಕಾಳಜಿಗಳ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಮತ್ತು ಕೋಡ್ ಪುನರ್ಬಳಕೆಯನ್ನು ಉತ್ತೇಜಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ.

ಡೆಕೋರೇಟರ್‌ಗಳು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಡಿಸೈನ್ ಸಮಯದಲ್ಲಿ ಕರೆಯಲಾಗುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಡೆಕೋರೇಟರ್ ಫಂಕ್ಷನ್‌ಗೆ ರವಾನಿಸಲಾದ ನಿಖರವಾದ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಬಳಸಲಾಗುತ್ತಿರುವ ಡೆಕೋರೇಟರ್ ಪ್ರಕಾರವನ್ನು (ಕ್ಲಾಸ್, ಮೆಥಡ್, ಪ್ರಾಪರ್ಟಿ, ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್) ಅವಲಂಬಿಸಿರುತ್ತದೆ. ವಿವಿಧ ರೀತಿಯ ಡೆಕೋರೇಟರ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಸಂಬಂಧಿತ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ವಿಂಗಡಿಸೋಣ:

ಪರಿಣಾಮಕಾರಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬರೆಯಲು ಈ ಆರ್ಗ್ಯುಮೆಂಟ್ ಸಹಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ.

ಡೆಕೋರೇಟರ್‌ಗಳ ವಿಧಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಹಲವಾರು ರೀತಿಯ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶವನ್ನು ಪೂರೈಸುತ್ತದೆ:

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.

ಕ್ಲಾಸ್ ಡೆಕೋರೇಟರ್ ಉದಾಹರಣೆ: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಸೇರಿಸುವುದು

ಪ್ರತಿ ಕ್ಲಾಸ್ ಇನ್‌ಸ್ಟಾನ್ಸ್‌ಗೆ ನೀವು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಸೇರಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಇದನ್ನು ಸಾಧಿಸಲು ನೀವು ಕ್ಲಾಸ್ ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು:


function addTimestamp<T extends { new(...args: any[]): {} }>(constructor: T) {
  return class extends constructor {
    timestamp = Date.now();
  };
}

@addTimestamp
class MyClass {
  constructor() {
    console.log('MyClass created');
  }
}

const instance = new MyClass();
console.log(instance.timestamp); // ಔಟ್‌ಪುಟ್: ಒಂದು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `addTimestamp` ಡೆಕೋರೇಟರ್ ಕ್ಲಾಸ್ ಇನ್‌ಸ್ಟಾನ್ಸ್‌ಗೆ `timestamp` ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ. ಇದು ಮೂಲ ಕ್ಲಾಸ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸದೆ ಮೌಲ್ಯಯುತ ಡೀಬಗ್ಗಿಂಗ್ ಅಥವಾ ಆಡಿಟ್ ಟ್ರಯಲ್ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಮೆಥಡ್ ಡೆಕೋರೇಟರ್ ಉದಾಹರಣೆ: ಮೆಥಡ್ ಕರೆಗಳನ್ನು ಲಾಗಿಂಗ್ ಮಾಡುವುದು

ಮೆಥಡ್ ಕರೆಗಳು ಮತ್ತು ಅವುಗಳ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಲಾಗ್ ಮಾಡಲು ನೀವು ಮೆಥಡ್ ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು:


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

  descriptor.value = function (...args: any[]) {
    console.log(`[ಲಾಗ್] ${key} ಮೆಥಡ್ ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಕರೆಯಲಾಗಿದೆ:`, args);
    const result = originalMethod.apply(this, args);
    console.log(`[ಲಾಗ್] ${key} ಮೆಥಡ್ ಹಿಂತಿರುಗಿಸಿದ್ದು:`, result);
    return result;
  };

  return descriptor;
}

class Greeter {
  @logMethod
  greet(message: string): string {
    return `Hello, ${message}!`;
  }
}

const greeter = new Greeter();
greeter.greet('World');
// ಔಟ್‌ಪುಟ್:
// [ಲಾಗ್] greet ಮೆಥಡ್ ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಕರೆಯಲಾಗಿದೆ: [ 'World' ]
// [ಲಾಗ್] greet ಮೆಥಡ್ ಹಿಂತಿರುಗಿಸಿದ್ದು: Hello, World!

ಈ ಉದಾಹರಣೆಯು `greet` ಮೆಥಡ್ ಅನ್ನು ಕರೆದಾಗಲೆಲ್ಲಾ, ಅದರ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಮತ್ತು ಹಿಂತಿರುಗುವ ಮೌಲ್ಯದೊಂದಿಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ಮಾನಿಟರಿಂಗ್‌ಗೆ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಪ್ರಾಪರ್ಟಿ ಡೆಕೋರೇಟರ್ ಉದಾಹರಣೆ: ಮೌಲ್ಯೀಕರಣವನ್ನು ಸೇರಿಸುವುದು

ಮೂಲಭೂತ ಮೌಲ್ಯೀಕರಣವನ್ನು ಸೇರಿಸುವ ಪ್ರಾಪರ್ಟಿ ಡೆಕೋರೇಟರ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:


function validate(target: any, key: string) {
  let value: any;

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

  const setter = function (newValue: any) {
    if (typeof newValue !== 'number') {
      console.warn(`[ಎಚ್ಚರಿಕೆ] ಅಮಾನ್ಯ ಪ್ರಾಪರ್ಟಿ ಮೌಲ್ಯ: ${key}. ಸಂಖ್ಯೆಯನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.`);
      return;
    }
    value = newValue;
  };

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

class Person {
  @validate
  age: number; //  <- ಮೌಲ್ಯೀಕರಣದೊಂದಿಗೆ ಪ್ರಾಪರ್ಟಿ
}

const person = new Person();
person.age = 'abc'; // ಎಚ್ಚರಿಕೆಯನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ
person.age = 30;   // ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ
console.log(person.age); // ಔಟ್‌ಪುಟ್: 30

ಈ `validate` ಡೆಕೋರೇಟರ್‌ನಲ್ಲಿ, ನಿಯೋಜಿಸಲಾದ ಮೌಲ್ಯವು ಸಂಖ್ಯೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಎಚ್ಚರಿಕೆಯನ್ನು ಲಾಗ್ ಮಾಡುತ್ತೇವೆ. ಇದು ಸರಳ ಉದಾಹರಣೆಯಾಗಿದ್ದರೂ, ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಜಾರಿಗೊಳಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಇದು ತೋರಿಸುತ್ತದೆ.

ಪ್ಯಾರಾಮೀಟರ್ ಡೆಕೋರೇಟರ್ ಉದಾಹರಣೆ: ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ (ಸರಳೀಕೃತ)

ಪೂರ್ಣ ಪ್ರಮಾಣದ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಹೆಚ್ಚಾಗಿ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತವೆಯಾದರೂ, ಇಂಜೆಕ್ಷನ್‌ಗಾಗಿ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು. ಈ ಉದಾಹರಣೆಯು ಒಂದು ಸರಳೀಕೃತ ಚಿತ್ರಣವಾಗಿದೆ:


// ಇದು ಒಂದು ಸರಳೀಕರಣ ಮತ್ತು ನಿಜವಾದ ಇಂಜೆಕ್ಷನ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ನಿಜವಾದ DI ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ.
function Inject(service: any) {
  return function (target: any, propertyKey: string | symbol, parameterIndex: number) {
    // ಸೇವೆಯನ್ನು ಎಲ್ಲೋ ಸಂಗ್ರಹಿಸಿ (ಉದಾ., ಸ್ಟ್ಯಾಟಿಕ್ ಪ್ರಾಪರ್ಟಿ ಅಥವಾ ಮ್ಯಾಪ್‌ನಲ್ಲಿ)
    if (!target.injectedServices) {
      target.injectedServices = {};
    }
    target.injectedServices[parameterIndex] = service;
  };
}

class MyService {
  doSomething() { /* ... */ }
}

class MyComponent {
  constructor(@Inject(MyService) private myService: MyService) {
    // ನಿಜವಾದ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ, DI ಕಂಟೇನರ್ ಇಲ್ಲಿ 'myService' ಅನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.
    console.log('MyComponent constructed with:', myService.constructor.name); //ಉದಾಹರಣೆ
  }
}

const component = new MyComponent(new MyService());  // ಸೇವೆಯನ್ನು ಇಂಜೆಕ್ಟ್ ಮಾಡುವುದು (ಸರಳೀಕೃತ).

`Inject` ಡೆಕೋರೇಟರ್ ಒಂದು ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಸೇವೆ ಅಗತ್ಯವಿದೆ ಎಂದು ಗುರುತಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಅಗತ್ಯವಿರುವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಗುರುತಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ (ಆದರೆ ನಿಜವಾದ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗೆ ಸೇವಾ ರೆಸಲ್ಯೂಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿದೆ).

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಮುಂದುವರಿದ ಪರಿಕಲ್ಪನೆಗಳು

ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಗಳು

ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಗಳು ಡೆಕೋರೇಟರ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ಇದು ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳಿಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಅವುಗಳನ್ನು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದಂತೆ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಮೌಲ್ಯೀಕರಣ ನಿಯಮಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮೌಲ್ಯೀಕರಣ ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಯನ್ನು ನೀವು ರಚಿಸಬಹುದು:


function validate(minLength: number) {
  return function (target: any, key: string) {
    let value: string;

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

    const setter = function (newValue: string) {
      if (typeof newValue !== 'string') {
        console.warn(`[ಎಚ್ಚರಿಕೆ] ಅಮಾನ್ಯ ಪ್ರಾಪರ್ಟಿ ಮೌಲ್ಯ: ${key}. ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.`);
        return;
      }
      if (newValue.length < minLength) {
        console.warn(`[ಎಚ್ಚರಿಕೆ] ${key} ಕನಿಷ್ಠ ${minLength} ಅಕ್ಷರಗಳಷ್ಟು ಉದ್ದವಿರಬೇಕು.`);
        return;
      }
      value = newValue;
    };

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

class Person {
  @validate(3) // ಕನಿಷ್ಠ 3 ಅಕ್ಷರಗಳ ಉದ್ದದೊಂದಿಗೆ ಮೌಲ್ಯೀಕರಿಸಿ
  name: string;
}

const person = new Person();
person.name = 'Jo';
console.log(person.name); // ಎಚ್ಚರಿಕೆಯನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ, ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
person.name = 'John';
console.log(person.name); // ಔಟ್‌ಪುಟ್: John

ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಗಳು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಮಾಡುತ್ತವೆ.

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

ನೀವು ಒಂದೇ ಅಂಶಕ್ಕೆ ಬಹು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಬಹುದು. ಅವುಗಳನ್ನು ಅನ್ವಯಿಸುವ ಕ್ರಮವು ಕೆಲವೊಮ್ಮೆ ಮುಖ್ಯವಾಗಿರುತ್ತದೆ. ಕ್ರಮವು ಕೆಳಗಿನಿಂದ ಮೇಲಕ್ಕೆ ಇರುತ್ತದೆ (ಬರೆದಂತೆ). ಉದಾಹರಣೆಗೆ:


function first() {
  console.log('first(): ಫ್ಯಾಕ್ಟರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗಿದೆ');
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('first(): ಕರೆಯಲಾಗಿದೆ');
  }
}

function second() {
  console.log('second(): ಫ್ಯಾಕ್ಟರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗಿದೆ');
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    console.log('second(): ಕರೆಯಲಾಗಿದೆ');
  }
}

class ExampleClass {
  @first()
  @second()
  method() {}
}

// ಔಟ್‌ಪುಟ್:
// second(): ಫ್ಯಾಕ್ಟರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗಿದೆ
// first(): ಫ್ಯಾಕ್ಟರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗಿದೆ
// second(): ಕರೆಯಲಾಗಿದೆ
// first(): ಕರೆಯಲಾಗಿದೆ

ಫ್ಯಾಕ್ಟರಿ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಅವು ಕಾಣಿಸಿಕೊಳ್ಳುವ ಕ್ರಮದಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ, ಆದರೆ ಡೆಕೋರೇಟರ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನಿಮ್ಮ ಡೆಕೋರೇಟರ್‌ಗಳು ಪರಸ್ಪರ ಅವಲಂಬಿತವಾಗಿದ್ದರೆ ಈ ಕ್ರಮವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ.

ಡೆಕೋರೇಟರ್‌ಗಳು ಮತ್ತು ಮೆಟಾಡೇಟಾ ಪ್ರತಿಫಲನ

ಡೆಕೋರೇಟರ್‌ಗಳು ಮೆಟಾಡೇಟಾ ಪ್ರತಿಫಲನದೊಂದಿಗೆ (ಉದಾಹರಣೆಗೆ, `reflect-metadata` ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ) ಕೈಜೋಡಿಸಿ ಹೆಚ್ಚು ಡೈನಾಮಿಕ್ ನಡವಳಿಕೆಯನ್ನು ಪಡೆಯಬಹುದು. ಇದು ನಿಮಗೆ, ಉದಾಹರಣೆಗೆ, ರನ್‌ಟೈಮ್ ಸಮಯದಲ್ಲಿ ಅಲಂಕರಿಸಿದ ಅಂಶಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಸಹಾಯಕವಾಗಿದೆ. ಡೆಕೋರೇಟರ್‌ಗಳು ಕ್ಲಾಸ್‌ಗಳು ಅಥವಾ ಮೆಥಡ್‌ಗಳನ್ನು ಮೆಟಾಡೇಟಾದೊಂದಿಗೆ ಅನೋಟೇಟ್ ಮಾಡಬಹುದು, ಮತ್ತು ನಂತರ ಆ ಮೆಟಾಡೇಟಾವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮತ್ತು ಬಳಸಲು ಪ್ರತಿಫಲನವನ್ನು ಬಳಸಬಹುದು.

ಜನಪ್ರಿಯ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳು

ಡೆಕೋರೇಟರ್‌ಗಳು ಅನೇಕ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳ ಅವಿಭಾಜ್ಯ ಅಂಗಗಳಾಗಿವೆ. ಅವುಗಳ ಅನ್ವಯವನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ ಆರ್ಕಿಟೆಕ್ಚರ್ ಮತ್ತು ಅದು ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಸುಗಮಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಈ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು ಡೆಕೋರೇಟರ್‌ಗಳು ಕೋಡ್ ಸಂಘಟನೆಯನ್ನು ಹೇಗೆ ಹೆಚ್ಚಿಸುತ್ತವೆ, ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತವೆ ಮತ್ತು ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ.

ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಒಂದು ಶಕ್ತಿಯುತ ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಇದು ನಿಮ್ಮ ಕೋಡ್‌ನ ರಚನೆ, ಪುನರ್ಬಳಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. ವಿವಿಧ ರೀತಿಯ ಡೆಕೋರೇಟರ್‌ಗಳು, ಅವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಅವುಗಳ ಬಳಕೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತ ಮತ್ತು ಹೆಚ್ಚು ಸಮರ್ಥ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಅವುಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ನೀವು ಸರಳ ಅಪ್ಲಿಕೇಶನ್ ಅಥವಾ ಸಂಕೀರ್ಣ ಎಂಟರ್‌ಪ್ರೈಸ್-ಮಟ್ಟದ ಸಿಸ್ಟಮ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ಡೆಕೋರೇಟರ್‌ಗಳು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವನ್ನು ಹೆಚ್ಚಿಸಲು ಒಂದು ಮೌಲ್ಯಯುತ ಸಾಧನವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು ಕೋಡ್ ಗುಣಮಟ್ಟದಲ್ಲಿ ಗಮನಾರ್ಹ ಸುಧಾರಣೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆಂಗುಲರ್ ಮತ್ತು ನೆಸ್ಟ್‌ಜೆಎಸ್‌ನಂತಹ ಜನಪ್ರಿಯ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳು ಹೇಗೆ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಸ್ಕೇಲೆಬಲ್, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ತಮ್ಮ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಪ್ರಮುಖವಾದುದು ಅವುಗಳ ಉದ್ದೇಶವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಸೂಕ್ತ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅವುಗಳನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸುವುದು, ಪ್ರಯೋಜನಗಳು ಯಾವುದೇ ಸಂಭಾವ್ಯ ಅನಾನುಕೂಲಗಳನ್ನು ಮೀರಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು.

ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ, ನೀವು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚಿನ ರಚನೆ, ನಿರ್ವಹಣೆ ಮತ್ತು ದಕ್ಷತೆಯೊಂದಿಗೆ ಹೆಚ್ಚಿಸಬಹುದು. ಈ ಮಾರ್ಗದರ್ಶಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಬಗ್ಗೆ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಜ್ಞಾನದೊಂದಿಗೆ, ನೀವು ಉತ್ತಮ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಅಧಿಕಾರ ಪಡೆದಿದ್ದೀರಿ. ಮುಂದುವರಿಯಿರಿ ಮತ್ತು ಅಲಂಕರಿಸಿ!