ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಭಾವ: ಮೆಟಾಡೇಟಾ ಸಂಸ್ಕರಣೆಯ ಓವರ್‌ಹೆಡ್

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

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

ಡೆಕೋರೇಟರ್‌ಗಳು ಒಂದು ಡಿಸೈನ್ ಪ್ಯಾಟರ್ನ್ ಮತ್ತು ಭಾಷಾ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು (ಪ್ರಸ್ತುತ ECMAScript ಗಾಗಿ ಹಂತ 3 ಪ್ರಸ್ತಾಪದಲ್ಲಿದೆ), ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ನ ರಚನೆಯನ್ನು ಬದಲಾಯಿಸದೆ ಅದಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇವುಗಳನ್ನು ವ್ರ್ಯಾಪರ್‌ಗಳು ಅಥವಾ ಎನ್‌ಹ್ಯಾನ್ಸರ್‌ಗಳು ಎಂದು ಭಾವಿಸಬಹುದು. ಇವುಗಳನ್ನು ಆಂಗ್ಯುಲರ್‌ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಹೆಚ್ಚು ಜನಪ್ರಿಯವಾಗುತ್ತಿವೆ.

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

ಉದಾಹರಣೆ (ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್):

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

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

  return descriptor;
}

class MyClass {
  @logMethod
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3); // Output will include logging information

            

              
                Copy
              
            
          

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

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

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

ಮೆಟಾಡೇಟಾವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ reflect-metadata ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳೊಂದಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುವ ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಈ ಲೈಬ್ರರಿಯು Reflect.defineMetadata, Reflect.getMetadata, ಮತ್ತು ಸಂಬಂಧಿತ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲಾಸ್‌ಗಳು, ಮೆಥಡ್‌ಗಳು, ಪ್ರಾಪರ್ಟಿಗಳು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ ಅನಿಯಂತ್ರಿತ ಡೇಟಾವನ್ನು ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

reflect-metadata ಬಳಸುವ ಉದಾಹರಣೆ:

            
import 'reflect-metadata';

const requiredMetadataKey = Symbol('required');

function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {
  let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];
  existingRequiredParameters.push(parameterIndex);
  Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);
}

function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {
  let method = descriptor.value!;

  descriptor.value = function () {
    let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);
    if (requiredParameters) {
      for (let parameterIndex of requiredParameters) {
        if (arguments.length <= parameterIndex || arguments[parameterIndex] === undefined) {
          throw new Error("Missing required argument.");
        }
      }
    }

    return method.apply(this, arguments);
  }
}

class Greeter {
  greeting: string;

  constructor(message: string) {
    this.greeting = message;
  }

  @validate
  greet(@required name: string) {
    return "Hello " + name + ", " + this.greeting;
  }
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, @required ಡೆಕೋರೇಟರ್ ಅಗತ್ಯವಿರುವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಸೂಚ್ಯಂಕವನ್ನು ಸಂಗ್ರಹಿಸಲು reflect-metadata ಅನ್ನು ಬಳಸುತ್ತದೆ. ನಂತರ @validate ಡೆಕೋರೇಟರ್ ಈ ಮೆಟಾಡೇಟಾವನ್ನು ಹಿಂಪಡೆದು ಎಲ್ಲಾ ಅಗತ್ಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಮೆಟಾಡೇಟಾ ಸಂಸ್ಕರಣೆಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್

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

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

ಪ್ರಭಾವವನ್ನು ಅಳೆಯುವುದು

ಡೆಕೋರೇಟರ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಭಾವವು ಸೂಕ್ಷ್ಮವಾಗಿರಬಹುದು ಆದರೆ ಗಮನಾರ್ಹವಾಗಿರುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ. ಆಪ್ಟಿಮೈಸೇಶನ್ ಅಗತ್ಯವಿದೆಯೇ ಎಂದು ತಿಳಿಯಲು ಪ್ರಭಾವವನ್ನು ಅಳೆಯುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

ಅಳತೆಗಾಗಿ ಉಪಕರಣಗಳು:

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

ಉದಾಹರಣೆ ಬೆಂಚ್‌ಮಾರ್ಕಿಂಗ್ (Benchmark.js ಬಳಸಿ):

            
const Benchmark = require('benchmark');
require('reflect-metadata');

const metadataKey = Symbol('test');

class TestClass {
  @Reflect.metadata(metadataKey, 'testValue')
  testMethod() {}
}

const instance = new TestClass();

const suite = new Benchmark.Suite;

suite.add('Get Metadata', function() {
  Reflect.getMetadata(metadataKey, instance, 'testMethod');
})
.on('cycle', function(event: any) {
  console.log(String(event.target));
})
.on('complete', function() {
  console.log('Fastest is ' + this.filter('fastest').map('name'));
})
.run({ 'async': true });

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು Reflect.getMetadata ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಳೆಯಲು Benchmark.js ಅನ್ನು ಬಳಸುತ್ತದೆ. ಈ ಬೆಂಚ್‌ಮಾರ್ಕ್ ಅನ್ನು ಚಲಾಯಿಸುವುದು ಮೆಟಾಡೇಟಾ ಹಿಂಪಡೆಯುವಿಕೆಗೆ ಸಂಬಂಧಿಸಿದ ಓವರ್‌ಹೆಡ್‌ನ ಒಂದು ಕಲ್ಪನೆಯನ್ನು ನೀಡುತ್ತದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ತಗ್ಗಿಸುವ ತಂತ್ರಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಮತ್ತು ಮೆಟಾಡೇಟಾ ಸಂಸ್ಕರಣೆಗೆ ಸಂಬಂಧಿಸಿದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ತಗ್ಗಿಸಲು ಹಲವಾರು ತಂತ್ರಗಳನ್ನು ಬಳಸಬಹುದು:

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

ಆಪ್ಟಿಮೈಸೇಶನ್‌ನ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

1. ಕ್ಯಾಶಿಂಗ್ ಮೆಟಾಡೇಟಾ:

            
const metadataCache = new Map();

function getCachedMetadata(target: any, propertyKey: string, metadataKey: any) {
  const cacheKey = `${target.constructor.name}-${propertyKey}-${String(metadataKey)}`;
  if (metadataCache.has(cacheKey)) {
    return metadataCache.get(cacheKey);
  }
  const metadata = Reflect.getMetadata(metadataKey, target, propertyKey);
  metadataCache.set(cacheKey, metadata);
  return metadata;
}

function myDecorator(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  // Use getCachedMetadata instead of Reflect.getMetadata
  const metadataValue = getCachedMetadata(target, propertyKey, 'my-metadata');
  // ...
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು Reflect.getMetadata ಗೆ ಪುನರಾವರ್ತಿತ ಕರೆಗಳನ್ನು ತಪ್ಪಿಸಲು Map ನಲ್ಲಿ ಮೆಟಾಡೇಟಾವನ್ನು ಕ್ಯಾಶಿಂಗ್ ಮಾಡುವುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

2. ಬೇಬಲ್‌ನೊಂದಿಗೆ ಕಂಪೈಲ್-ಟೈಮ್ ರೂಪಾಂತರ:

ಬೇಬಲ್ ಪ್ಲಗಿನ್ ಬಳಸಿ, ನೀವು ನಿಮ್ಮ ಡೆಕೋರೇಟರ್ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ರೂಪಾಂತರಿಸಬಹುದು, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ರನ್‌ಟೈಮ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ಡೆಕೋರೇಟರ್ ಕರೆಗಳನ್ನು ಕ್ಲಾಸ್ ಅಥವಾ ಮೆಥಡ್‌ಗೆ ನೇರ ಮಾರ್ಪಾಡುಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು.

ಉದಾಹರಣೆ (ಕಾನ್ಸೆಪ್ಟ್):

ನೀವು ಸರಳ ಲಾಗಿಂಗ್ ಡೆಕೋರೇಟರ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ:

            
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function(...args: any[]) {
    console.log(`Calling ${propertyKey} with ${args}`);
    const result = originalMethod.apply(this, args);
    console.log(`Result: ${result}`);
    return result;
  };
}

class MyClass {
  @log
  myMethod(arg: number) {
    return arg * 2;
  }
}

            

              
                Copy
              
            
          

ಒಂದು ಬೇಬಲ್ ಪ್ಲಗಿನ್ ಇದನ್ನು ಹೀಗೆ ರೂಪಾಂತರಿಸಬಹುದು:

            
class MyClass {
  myMethod(arg: number) {
    console.log(`Calling myMethod with ${arg}`);
    const result = arg * 2;
    console.log(`Result: ${result}`);
    return result;
  }
}

            

              
                Copy
              
            
          

ಡೆಕೋರೇಟರ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಇನ್‌ಲೈನ್ ಮಾಡಲಾಗಿದೆ, ರನ್‌ಟೈಮ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

ನೈಜ-ಪ್ರಪಂಚದ ಪರಿಗಣನೆಗಳು

ಡೆಕೋರೇಟರ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಭಾವವು ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಸಂದರ್ಭ ಮತ್ತು ಡೆಕೋರೇಟರ್‌ಗಳ ಸಂಕೀರ್ಣತೆಯನ್ನು ಅವಲಂಬಿಸಿ ಬದಲಾಗಬಹುದು. ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ಓವರ್‌ಹೆಡ್ ನಗಣ್ಯವಾಗಿರಬಹುದು, ಮತ್ತು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ವೆಚ್ಚವನ್ನು ಮೀರಿಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸುವುದು ಮತ್ತು ಸೂಕ್ತವಾದ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಕೇಸ್ ಸ್ಟಡಿ: ಆಂಗ್ಯುಲರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

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

ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಮತ್ತು ಸ್ಥಳೀಕರಣ (l10n) ಪರಿಗಣನೆಗಳು:

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

ತೀರ್ಮಾನ

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

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