ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸಿ: ಮೆಟಾಡೇಟಾ ಸೇರಿಸಿ, ಕ್ಲಾಸ್/ಮೆಥಡ್‌ಗಳನ್ನು ರೂಪಾಂತರಿಸಿ, ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನ ಕಾರ್ಯವನ್ನು ಸ್ವಚ್ಛ, ಘೋಷಣಾತ್ಮಕ ರೀತಿಯಲ್ಲಿ ಹೆಚ್ಚಿಸಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು: ಮೆಟಾಡೇಟಾ ಮತ್ತು ರೂಪಾಂತರ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು, ಪೈಥಾನ್ ಮತ್ತು ಜಾವಾದಂತಹ ಭಾಷೆಗಳಿಂದ ಪ್ರೇರಿತವಾದ ಒಂದು ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಮೆಟಾಡೇಟಾ ಸೇರಿಸಲು ಮತ್ತು ಕ್ಲಾಸ್‌ಗಳು, ಮೆಥಡ್‌ಗಳು, ಪ್ರಾಪರ್ಟಿಗಳು, ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ರೂಪಾಂತರಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವು ಕೋಡ್‌ನ ಕಾರ್ಯವನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಕಾಳಜಿಗಳ ಪ್ರತ್ಯೇಕತೆಯನ್ನು (separation of concerns) ಉತ್ತೇಜಿಸಲು ಒಂದು ಸ್ವಚ್ಛ, ಘೋಷಣಾತ್ಮಕ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ನೀಡುತ್ತವೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗೆ ಇವು ತುಲನಾತ್ಮಕವಾಗಿ ಹೊಸ ಸೇರ್ಪಡೆಯಾಗಿದ್ದರೂ, ಡೆಕೋರೇಟರ್‌ಗಳು ಜನಪ್ರಿಯತೆಯನ್ನು ಗಳಿಸುತ್ತಿವೆ, ವಿಶೇಷವಾಗಿ ಆಂಗ್ಯುಲರ್‌ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಮತ್ತು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಹಾಗೂ ಇತರ ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳಿಗಾಗಿ ಮೆಟಾಡೇಟಾವನ್ನು ಬಳಸುವ ಲೈಬ್ರರಿಗಳಲ್ಲಿ. ಈ ಲೇಖನವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳ ಮೂಲಭೂತ ಅಂಶಗಳು, ಅವುಗಳ ಅನ್ವಯ, ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಹಾಗೂ ವಿಸ್ತರಿಸಬಲ್ಲ ಕೋಡ್‌ಬೇಸ್‌ಗಳನ್ನು ರಚಿಸುವಲ್ಲಿ ಅವುಗಳ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಎಂದರೇನು?
ಮೂಲಭೂತವಾಗಿ, ಡೆಕೋರೇಟರ್‌ಗಳು ವಿಶೇಷ ರೀತಿಯ ಘೋಷಣೆಗಳಾಗಿದ್ದು, ಅವುಗಳನ್ನು ಕ್ಲಾಸ್‌ಗಳು, ಮೆಥಡ್‌ಗಳು, ಅಕ್ಸೆಸರ್‌ಗಳು, ಪ್ರಾಪರ್ಟಿಗಳು, ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗೆ ಲಗತ್ತಿಸಬಹುದು. ಅವು @expression ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತವೆ, ಇಲ್ಲಿ expression ಒಂದು ಫಂಕ್ಷನ್‌ಗೆ ಮೌಲ್ಯಮಾಪನ ಮಾಡಬೇಕು, ಮತ್ತು ಈ ಫಂಕ್ಷನ್‌ ಅನ್ನು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಅಲಂಕರಿಸಿದ ಘೋಷಣೆಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯೊಂದಿಗೆ ಕರೆಯಲಾಗುತ್ತದೆ. ಡೆಕೋರೇಟರ್‌ಗಳು ಮೂಲಭೂತವಾಗಿ ಅಲಂಕರಿಸಿದ ಅಂಶದ ನಡವಳಿಕೆಯನ್ನು ಮಾರ್ಪಡಿಸುವ ಅಥವಾ ವಿಸ್ತರಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.
ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಅನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸದೆ ಅದನ್ನು ಸುತ್ತುವರಿಯುವ ಅಥವಾ ವೃದ್ಧಿಸುವ ಒಂದು ಮಾರ್ಗವೆಂದು ಯೋಚಿಸಿ. ಸಾಫ್ಟ್‌ವೇರ್ ವಿನ್ಯಾಸದಲ್ಲಿ ಡೆಕೋರೇಟರ್ ಪ್ಯಾಟರ್ನ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಈ ತತ್ವವು, ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು
ಡೆಕೋರೇಟರ್‌ಗಳು ECMAScript ಸ್ಟ್ಯಾಂಡರ್ಡ್‌ನ ಭಾಗವಾಗಿದ್ದರೂ, ಅವುಗಳನ್ನು ಹೆಚ್ಚಿನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರಗಳಲ್ಲಿ ಡಿಫಾಲ್ಟ್ ಆಗಿ ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿಲ್ಲ. ಅವುಗಳನ್ನು ಬಳಸಲು, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮ ಬಿಲ್ಡ್ ಟೂಲ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಕೆಲವು ಸಾಮಾನ್ಯ ಪರಿಸರಗಳಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಸಕ್ರಿಯಗೊಳಿಸುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:
- ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್: ಡೆಕೋರೇಟರ್‌ಗಳು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಬೆಂಬಲಿತವಾಗಿವೆ. ನಿಮ್ಮ
tsconfig.jsonಫೈಲ್‌ನಲ್ಲಿexperimentalDecoratorsಕಂಪೈಲರ್ ಆಯ್ಕೆಯನ್ನುtrueಗೆ ಹೊಂದಿಸಲಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:
{
"compilerOptions": {
"target": "esnext",
"experimentalDecorators": true,
"emitDecoratorMetadata": true, // Optional, but often useful
"module": "commonjs", // Or another module system like "es6" or "esnext"
"moduleResolution": "node"
}
}
- ಬೇಬೆಲ್: ನೀವು ಬೇಬೆಲ್ ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು
@babel/plugin-proposal-decoratorsಪ್ಲಗಿನ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ:
npm install --save-dev @babel/plugin-proposal-decorators
ನಂತರ, ನಿಮ್ಮ ಬೇಬೆಲ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ (ಉದಾ., .babelrc ಅಥವಾ babel.config.js) ಪ್ಲಗಿನ್ ಅನ್ನು ಸೇರಿಸಿ:
{
"plugins": [["@babel/plugin-proposal-decorators", { "version": "2023-05" }]]
}
version ಆಯ್ಕೆಯು ಮುಖ್ಯವಾಗಿದೆ ಮತ್ತು ನೀವು ಗುರಿಯಾಗಿಸಿಕೊಂಡಿರುವ ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಸ್ತಾವನೆಯ ಆವೃತ್ತಿಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು. ಇತ್ತೀಚಿನ ಶಿಫಾರಸು ಮಾಡಲಾದ ಆವೃತ್ತಿಗಾಗಿ ಬೇಬೆಲ್ ಪ್ಲಗಿನ್ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿ.
ಡೆಕೋರೇಟರ್‌ಗಳ ವಿಧಗಳು
ಹಲವಾರು ರೀತಿಯ ಡೆಕೋರೇಟರ್‌ಗಳಿವೆ, ಪ್ರತಿಯೊಂದೂ ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ:
- ಕ್ಲಾಸ್ ಡೆಕೋರೇಟರ್‌ಗಳು: ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
- ಮೆಥಡ್ ಡೆಕೋರೇಟರ್‌ಗಳು: ಒಂದು ಕ್ಲಾಸ್‌ನೊಳಗಿನ ಮೆಥಡ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
- ಅಕ್ಸೆಸರ್ ಡೆಕೋರೇಟರ್‌ಗಳು: ಗೆಟರ್ ಅಥವಾ ಸೆಟರ್ ಅಕ್ಸೆಸರ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
- ಪ್ರಾಪರ್ಟಿ ಡೆಕೋರೇಟರ್‌ಗಳು: ಒಂದು ಕ್ಲಾಸ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
- ಪ್ಯಾರಾಮೀಟರ್ ಡೆಕೋರೇಟರ್‌ಗಳು: ಒಂದು ಮೆಥಡ್ ಅಥವಾ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.
ಕ್ಲಾಸ್ ಡೆಕೋರೇಟರ್‌ಗಳು
ಕ್ಲಾಸ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಒಂದು ಕ್ಲಾಸ್‌ನ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದು ಕ್ಲಾಸ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ವೀಕ್ಷಿಸಲು, ಮಾರ್ಪಡಿಸಲು, ಅಥವಾ ಬದಲಾಯಿಸಲು ಬಳಸಬಹುದು. ಅವು ತಮ್ಮ ಏಕೈಕ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಕ್ಲಾಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ.
ಉದಾಹರಣೆ:
function sealed(constructor: Function) {
Object.seal(constructor);
Object.seal(constructor.prototype);
}
@sealed
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
greet() {
return "Hello, " + this.greeting;
}
}
// Attempting to add properties to the sealed class or its prototype will fail
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, @sealed ಡೆಕೋರೇಟರ್ Greeter ಕ್ಲಾಸ್ ಮತ್ತು ಅದರ ಪ್ರೋಟೋಟೈಪ್‌ಗೆ ಮತ್ತಷ್ಟು ಮಾರ್ಪಾಡುಗಳನ್ನು ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಇಮ್ಮ್ಯೂಟಬಿಲಿಟಿಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಥವಾ ಆಕಸ್ಮಿಕ ಬದಲಾವಣೆಗಳನ್ನು ತಡೆಯಲು ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.
ಮೆಥಡ್ ಡೆಕೋರೇಟರ್‌ಗಳು
ಮೆಥಡ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಒಂದು ಕ್ಲಾಸ್‌ನೊಳಗಿನ ಮೆಥಡ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ. ಅವು ಮೂರು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ:
target: ಕ್ಲಾಸ್‌ನ ಪ್ರೋಟೋಟೈಪ್ (ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್‌ಗಳಿಗಾಗಿ) ಅಥವಾ ಕ್ಲಾಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ (ಸ್ಟಾಟಿಕ್ ಮೆಥಡ್‌ಗಳಿಗಾಗಿ).propertyKey: ಅಲಂಕರಿಸಲ್ಪಡುತ್ತಿರುವ ಮೆಥಡ್‌ನ ಹೆಸರು.descriptor: ಮೆಥಡ್‌ಗಾಗಿ ಪ್ರಾಪರ್ಟಿ ಡಿಸ್ಕ್ರಿಪ್ಟರ್.
ಉದಾಹರಣೆ:
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(`Method ${propertyKey} returned: ${result}`);
return result;
};
return descriptor;
}
class Calculator {
@log
add(x: number, y: number) {
return x + y;
}
}
const calculator = new Calculator();
calculator.add(2, 3); // Output: Calling add with arguments: [2,3]
// Method add returned: 5
@log ಡೆಕೋರೇಟರ್ add ಮೆಥಡ್‌ನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಮತ್ತು ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ. ಲಾಗಿಂಗ್, ಪ್ರೊಫೈಲಿಂಗ್, ಅಥವಾ ಇತರ ಕ್ರಾಸ್-ಕಟಿಂಗ್ ಕಾಳಜಿಗಳಿಗಾಗಿ ಮೆಥಡ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದಕ್ಕೆ ಇದು ಒಂದು ಸರಳ ಉದಾಹರಣೆಯಾಗಿದೆ.
ಅಕ್ಸೆಸರ್ ಡೆಕೋರೇಟರ್‌ಗಳು
ಅಕ್ಸೆಸರ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಮೆಥಡ್ ಡೆಕೋರೇಟರ್‌ಗಳಂತೆಯೇ ಇರುತ್ತವೆ ಆದರೆ ಅವುಗಳನ್ನು ಗೆಟರ್ ಅಥವಾ ಸೆಟರ್ ಅಕ್ಸೆಸರ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ. ಅವು ಸಹ ಅದೇ ಮೂರು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ: target, propertyKey, ಮತ್ತು descriptor.
ಉದಾಹರಣೆ:
function configurable(value: boolean) {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
descriptor.configurable = value;
};
}
class Point {
private _x: number;
private _y: number;
constructor(x: number, y: number) {
this._x = x;
this._y = y;
}
@configurable(false)
get x() {
return this._x;
}
set x(value: number) {
this._x = value;
}
}
const point = new Point(1, 2);
// Object.defineProperty(point, 'x', { configurable: true }); // Would throw an error because 'x' is not configurable
@configurable(false) ಡೆಕೋರೇಟರ್ x ಗೆಟರ್ ಅನ್ನು ಮರುಕಾನ್ಫಿಗರ್ ಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ, ಅದನ್ನು ನಾನ್-ಕಾನ್ಫಿಗರಬಲ್ ಮಾಡುತ್ತದೆ.
ಪ್ರಾಪರ್ಟಿ ಡೆಕೋರೇಟರ್‌ಗಳು
ಪ್ರಾಪರ್ಟಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಒಂದು ಕ್ಲಾಸ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ. ಅವು ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ:
target: ಕ್ಲಾಸ್‌ನ ಪ್ರೋಟೋಟೈಪ್ (ಇನ್‌ಸ್ಟೆನ್ಸ್ ಪ್ರಾಪರ್ಟಿಗಳಿಗಾಗಿ) ಅಥವಾ ಕ್ಲಾಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ (ಸ್ಟಾಟಿಕ್ ಪ್ರಾಪರ್ಟಿಗಳಿಗಾಗಿ).propertyKey: ಅಲಂಕರಿಸಲ್ಪಡುತ್ತಿರುವ ಪ್ರಾಪರ್ಟಿಯ ಹೆಸರು.
ಉದಾಹರಣೆ:
function readonly(target: any, propertyKey: string) {
Object.defineProperty(target, propertyKey, {
writable: false,
});
}
class Person {
@readonly
name: string;
constructor(name: string) {
this.name = name;
}
}
const person = new Person("Alice");
// person.name = "Bob"; // This will cause an error in strict mode because 'name' is readonly
@readonly ಡೆಕೋರೇಟರ್ name ಪ್ರಾಪರ್ಟಿಯನ್ನು ರೀಡ್-ಓನ್ಲಿ ಮಾಡುತ್ತದೆ, ಅದನ್ನು ಇನಿಶಿಯಲೈಸೇಶನ್ ನಂತರ ಮಾರ್ಪಡಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ.
ಪ್ಯಾರಾಮೀಟರ್ ಡೆಕೋರೇಟರ್‌ಗಳು
ಪ್ಯಾರಾಮೀಟರ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಒಂದು ಮೆಥಡ್ ಅಥವಾ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ. ಅವು ಮೂರು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ:
target: ಕ್ಲಾಸ್‌ನ ಪ್ರೋಟೋಟೈಪ್ (ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್‌ಗಳಿಗಾಗಿ) ಅಥವಾ ಕ್ಲಾಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ (ಸ್ಟಾಟಿಕ್ ಮೆಥಡ್‌ಗಳು ಅಥವಾ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳಿಗಾಗಿ).propertyKey: ಮೆಥಡ್ ಅಥವಾ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಹೆಸರು.parameterIndex: ಪ್ಯಾರಾಮೀಟರ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಸೂಚ್ಯಂಕ.
ಪ್ಯಾರಾಮೀಟರ್ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಒಂದು ಫಂಕ್ಷನ್‌ನ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಬಗ್ಗೆ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ರಿಫ್ಲೆಕ್ಷನ್‌ನೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಮೆಟಾಡೇಟಾವನ್ನು ನಂತರ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಅಥವಾ ಇತರ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಬಹುದು. ಇದು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು, ನಿಮ್ಮ tsconfig.json ಫೈಲ್‌ನಲ್ಲಿ emitDecoratorMetadata ಕಂಪೈಲರ್ ಆಯ್ಕೆಯನ್ನು ನೀವು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು.
ಉದಾಹರಣೆ (reflect-metadata ಬಳಸಿ):
import 'reflect-metadata';
function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {
let existingRequiredParameters: number[] = Reflect.getOwnMetadata("required", target, propertyKey) || [];
existingRequiredParameters.push(parameterIndex);
Reflect.defineMetadata("required", existingRequiredParameters, target, propertyKey);
}
function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {
let method = descriptor.value!;
descriptor.value = function (...args: any[]) {
let requiredParameters: number[] = Reflect.getOwnMetadata("required", target, propertyName);
if (requiredParameters) {
for (let parameterIndex of requiredParameters) {
if (args[parameterIndex] === null || args[parameterIndex] === undefined) {
throw new Error(`Missing required argument at index ${parameterIndex}`);
}
}
}
return method.apply(this, args);
};
}
class User {
name: string;
age: number;
constructor(@required name: string, public surname: string, @required age: number) {
this.name = name;
this.age = age;
}
@validate
greet(prefix: string, @required salutation: string): string {
return `${prefix} ${salutation} ${this.name}`;
}
}
// Usage
try {
const user1 = new User("John", "Doe", 30);
console.log(user1.greet("Mr.", "Hello"));
const user2 = new User(undefined as any, "Doe", null as any);
} catch (error) {
console.error(error.message);
}
try {
const user = new User("John", "Doe", 30);
console.log(user.greet("Mr.", undefined as any));
} catch (error) {
console.error(error.message);
}
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, @required ಡೆಕೋರೇಟರ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಅಗತ್ಯವೆಂದು ಗುರುತಿಸುತ್ತದೆ. ನಂತರ @validate ಡೆಕೋರೇಟರ್ ರಿಫ್ಲೆಕ್ಷನ್ (reflect-metadata ಮೂಲಕ) ಬಳಸಿ ಮೆಥಡ್ ಅನ್ನು ಕರೆಯುವ ಮೊದಲು ಅಗತ್ಯವಿರುವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಇವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯು ಮೂಲಭೂತ ಬಳಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ, ಮತ್ತು ಪ್ರೊಡಕ್ಷನ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ದೃಢವಾದ ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯೀಕರಣವನ್ನು ರಚಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
reflect-metadata ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಲು:
npm install reflect-metadata --save
ಮೆಟಾಡೇಟಾಗಾಗಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದು
ಡೆಕೋರೇಟರ್‌ಗಳ ಪ್ರಮುಖ ಉಪಯೋಗಗಳಲ್ಲಿ ಒಂದು ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಸದಸ್ಯರಿಗೆ ಮೆಟಾಡೇಟಾವನ್ನು ಲಗತ್ತಿಸುವುದು. ಈ ಮೆಟಾಡೇಟಾವನ್ನು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್, ಸೀರಿಯಲೈಸೇಶನ್, ಮತ್ತು ಮೌಲ್ಯೀಕರಣದಂತಹ ವಿವಿಧ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಬಳಸಬಹುದು. reflect-metadata ಲೈಬ್ರರಿಯು ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ಒಂದು ಪ್ರಮಾಣಿತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
import 'reflect-metadata';
const TYPE_KEY = "design:type";
const PARAMTYPES_KEY = "design:paramtypes";
const RETURNTYPE_KEY = "design:returntype";
function Type(type: any) {
return Reflect.metadata(TYPE_KEY, type);
}
function LogType(target: any, propertyKey: string) {
const t = Reflect.getMetadata(TYPE_KEY, target, propertyKey);
console.log(`${target.constructor.name}.${propertyKey} type: ${t.name}`);
}
class Demo {
@LogType
public name: string;
constructor(name: string){
this.name = name;
}
}
ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಗಳು
ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಗಳು ಡೆಕೋರೇಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ಗಳಾಗಿವೆ. ಅವು ನಿಮಗೆ ಡೆಕೋರೇಟರ್‌ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಲು ಅನುಮತಿಸುತ್ತವೆ, ಅದನ್ನು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡುವಂತೆ ಮಾಡುತ್ತದೆ.
ಉದಾಹರಣೆ:
function deprecated(deprecationReason: string) {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
console.warn(`Method ${propertyKey} is deprecated: ${deprecationReason}`);
return originalMethod.apply(this, args);
};
return descriptor;
};
}
class LegacyComponent {
@deprecated("Use the newMethod instead.")
oldMethod() {
console.log("Old method called");
}
newMethod() {
console.log("New method called");
}
}
const component = new LegacyComponent();
component.oldMethod(); // Output: Method oldMethod is deprecated: Use the newMethod instead.
// Old method called
@deprecated ಡೆಕೋರೇಟರ್ ಫ್ಯಾಕ್ಟರಿಯು ಡಿಪ್ರಿಕೇಶನ್ ಸಂದೇಶವನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅಲಂಕರಿಸಿದ ಮೆಥಡ್ ಅನ್ನು ಕರೆದಾಗ ಎಚ್ಚರಿಕೆಯನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ. ಇದು ನಿಮಗೆ ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಕೆಯಿಂದ ತೆಗೆದುಹಾಕಲಾಗಿದೆ ಎಂದು ಗುರುತಿಸಲು ಮತ್ತು ಹೊಸ ಪರ್ಯಾಯಗಳಿಗೆ ಹೇಗೆ ವಲಸೆ ಹೋಗಬೇಕು ಎಂಬುದರ ಕುರಿತು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡಲು ಅನುಮತಿಸುತ್ತದೆ.
ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೊಂದಿವೆ:
- ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್: ಆಂಗ್ಯುಲರ್‌ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್‌ಗಾಗಿ ಡೆಕೋರೇಟರ್‌ಗಳ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿವೆ.
- ರೂಟಿಂಗ್: ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ಕಂಟ್ರೋಲರ್‌ಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳಿಗಾಗಿ ರೂಟ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
- ಮೌಲ್ಯೀಕರಣ: ಇನ್‌ಪುಟ್ ಡೇಟಾವನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಮತ್ತು ಅದು ಕೆಲವು ಮಾನದಂಡಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
- ದೃಢೀಕರಣ: ಭದ್ರತಾ ನೀತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಮತ್ತು ಕೆಲವು ಮೆಥಡ್‌ಗಳು ಅಥವಾ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
- ಲಾಗಿಂಗ್ ಮತ್ತು ಪ್ರೊಫೈಲಿಂಗ್: ಮೇಲಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ ತೋರಿಸಿದಂತೆ, ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಲಾಗಿಂಗ್ ಮತ್ತು ಪ್ರೊಫೈಲಿಂಗ್ ಮಾಡಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.
- ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್: ಸ್ಥಿತಿ ಬದಲಾದಾಗ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಪ್‌ಡೇಟ್ ಮಾಡಲು ಡೆಕೋರೇಟರ್‌ಗಳು ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು.
ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು
- ಸುಧಾರಿತ ಕೋಡ್ ಓದುವಿಕೆ: ಡೆಕೋರೇಟರ್‌ಗಳು ಕಾರ್ಯವನ್ನು ಸೇರಿಸಲು ಘೋಷಣಾತ್ಮಕ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
- ಕಾಳಜಿಗಳ ಪ್ರತ್ಯೇಕತೆ: ಡೆಕೋರೇಟರ್‌ಗಳು ಕ್ರಾಸ್-ಕಟಿಂಗ್ ಕಾಳಜಿಗಳನ್ನು (ಉದಾ., ಲಾಗಿಂಗ್, ಮೌಲ್ಯೀಕರಣ, ದೃಢೀಕರಣ) ಕೋರ್ ಬಿಸಿನೆಸ್ ಲಾಜಿಕ್‌ನಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ.
- ಮರುಬಳಕೆ: ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅನೇಕ ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳಲ್ಲಿ ಮರುಬಳಕೆ ಮಾಡಬಹುದು, ಇದು ಕೋಡ್ ನಕಲು ಮಾಡುವುದನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
- ವಿಸ್ತರಣೀಯತೆ: ಡೆಕೋರೇಟರ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್‌ನ ಕಾರ್ಯವನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸದೆ ವಿಸ್ತರಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತವೆ.
ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು
- ಕಲಿಕೆಯ ರೇಖೆ: ಡೆಕೋರೇಟರ್‌ಗಳು ತುಲನಾತ್ಮಕವಾಗಿ ಹೊಸ ವೈಶಿಷ್ಟ್ಯವಾಗಿವೆ, ಮತ್ತು ಅವುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ಕಲಿಯಲು ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.
- ಹೊಂದಾಣಿಕೆ: ನಿಮ್ಮ ಗುರಿ ಪರಿಸರವು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಬಿಲ್ಡ್ ಟೂಲ್‌ಗಳನ್ನು ನೀವು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
- ಡೀಬಗ್ ಮಾಡುವುದು: ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಸವಾಲಾಗಿರಬಹುದು, ವಿಶೇಷವಾಗಿ ಡೆಕೋರೇಟರ್‌ಗಳು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೆ.
- ಅತಿಯಾದ ಬಳಕೆ: ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಅತಿಯಾಗಿ ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ, ಏಕೆಂದರೆ ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾಗಿಸಬಹುದು. ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅವುಗಳನ್ನು ಆಯಕಟ್ಟಿನ ರೀತಿಯಲ್ಲಿ ಬಳಸಿ.
- ರನ್‌ಟೈಮ್ ಓವರ್‌ಹೆಡ್: ಡೆಕೋರೇಟರ್‌ಗಳು ಕೆಲವು ರನ್‌ಟೈಮ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಪರಿಚಯಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಅವು ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೆ. ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಿ.
ತೀರ್ಮಾನ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆಕೋರೇಟರ್‌ಗಳು ಕೋಡ್‌ನ ಕಾರ್ಯವನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಕಾಳಜಿಗಳ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಉತ್ತೇಜಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ. ಮೆಟಾಡೇಟಾವನ್ನು ಸೇರಿಸಲು ಮತ್ತು ಕ್ಲಾಸ್‌ಗಳು, ಮೆಥಡ್‌ಗಳು, ಪ್ರಾಪರ್ಟಿಗಳು, ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ರೂಪಾಂತರಿಸಲು ಸ್ವಚ್ಛ, ಘೋಷಣಾತ್ಮಕ ಸಿಂಟ್ಯಾಕ್ಸ್ ಒದಗಿಸುವ ಮೂಲಕ, ಡೆಕೋರೇಟರ್‌ಗಳು ನಿಮಗೆ ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ, ಮರುಬಳಕೆ ಮಾಡಬಲ್ಲ ಮತ್ತು ವಿಸ್ತರಿಸಬಲ್ಲ ಕೋಡ್‌ಬೇಸ್‌ಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡಬಹುದು. ಅವುಗಳು ಕಲಿಕೆಯ ರೇಖೆ ಮತ್ತು ಕೆಲವು ಸಂಭಾವ್ಯ ಸವಾಲುಗಳೊಂದಿಗೆ ಬಂದರೂ, ಸರಿಯಾದ ಸಂದರ್ಭದಲ್ಲಿ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು ಗಮನಾರ್ಹವಾಗಿರಬಹುದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯು ವಿಕಸನಗೊಳ್ಳುತ್ತಲೇ ಇರುವುದರಿಂದ, ಡೆಕೋರೇಟರ್‌ಗಳು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯ ಹೆಚ್ಚು ಪ್ರಮುಖ ಭಾಗವಾಗುವ ಸಾಧ್ಯತೆಯಿದೆ.
ಡೆಕೋರೇಟರ್‌ಗಳು ನಿಮ್ಮ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಸರಳಗೊಳಿಸಬಹುದು ಅಥವಾ ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಹೇಗೆ ಅನುವು ಮಾಡಿಕೊಡಬಹುದು ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆ ಮತ್ತು ಅವುಗಳ ಸಾಮರ್ಥ್ಯಗಳ ಬಗ್ಗೆ ದೃಢವಾದ ತಿಳುವಳಿಕೆಯೊಂದಿಗೆ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಹಾರಗಳನ್ನು ರಚಿಸಲು ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.