జావాస్క్రిప్ట్ ఇంపోర్ట్ మెటా URL రిజల్యూషన్: మాడ్యూల్ పాత్ లెక్కింపులో నైపుణ్యం

జావాస్క్రిప్ట్ మాడ్యూల్స్ మనం కోడ్‌ను ఎలా నిర్మించుకుంటామో మరియు వ్యవస్థీకరించుకుంటామో విప్లవాత్మకంగా మార్చాయి, ఇది మెరుగైన పునర్వినియోగం మరియు నిర్వహణను సాధ్యం చేస్తుంది. మాడ్యూల్ అభివృద్ధిలో ఒక కీలకమైన అంశం మాడ్యూల్ పాత్‌లను ఎలా పరిష్కరించాలో అర్థం చేసుకోవడం, మరియు ఈ ప్రక్రియలో import.meta.url ప్రాపర్టీ ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది. ఈ వ్యాసం import.meta.url కు ఒక సమగ్ర మార్గదర్శినిని అందిస్తుంది, దాని కార్యాచరణ, వినియోగ సందర్భాలు, మరియు వివిధ పరిసరాలలో మాడ్యూల్ పాత్‌లను సమర్థవంతంగా పరిష్కరించడానికి ఉత్తమ పద్ధతులను అన్వేషిస్తుంది.

import.meta.url అంటే ఏమిటి?

import.meta.url అనేది ప్రస్తుత జావాస్క్రిప్ట్ మాడ్యూల్ యొక్క సంపూర్ణ URL ను బహిర్గతం చేసే ఒక ప్రత్యేక ప్రాపర్టీ. ఇది మాడ్యూల్ గురించిన మెటాడేటాను అందించే import.meta ఆబ్జెక్ట్‌లో భాగంగా ఉంటుంది. Node.js (CommonJS మాడ్యూల్స్) లో అందుబాటులో ఉన్న __filename లేదా __dirname వంటి గ్లోబల్ వేరియబుల్స్ లా కాకుండా, import.meta.url ప్రత్యేకంగా ES మాడ్యూల్స్ కోసం రూపొందించబడింది మరియు ES మాడ్యూల్స్‌కు మద్దతు ఇచ్చే బ్రౌజర్‌లు మరియు Node.js పరిసరాలలో స్థిరంగా పనిచేస్తుంది.

import.meta.url విలువ మాడ్యూల్ యొక్క URL ను సూచించే ఒక స్ట్రింగ్. ఈ URL ఫైల్ పాత్ (ఉదా., file:///path/to/module.js) లేదా వెబ్ చిరునామా (ఉదా., https://example.com/module.js) కావచ్చు, ఇది మాడ్యూల్ ఎక్కడ నుండి లోడ్ చేయబడింది అనే దానిపై ఆధారపడి ఉంటుంది.

ప్రాథమిక వినియోగం

import.meta.url ను ఉపయోగించడానికి సులభమైన మార్గం దానిని మాడ్యూల్‌లో నేరుగా యాక్సెస్ చేయడం:

            // my-module.js
console.log(import.meta.url);

            

              
                Copy
              
            
          

మీ ఫైల్ సిస్టమ్‌లో my-module.js /path/to/my-module.js వద్ద ఉంటే మరియు మీరు దానిని ES మాడ్యూల్స్‌కు మద్దతు ఇచ్చే Node.js పరిసరంలో (ఉదా., --experimental-modules ఫ్లాగ్‌తో లేదా "type": "module" ఉన్న ప్యాకేజీలో) రన్ చేస్తే, అవుట్‌పుట్ ఇలా ఉంటుంది:

            file:///path/to/my-module.js

            

              
                Copy
              
            
          

ఒక బ్రౌజర్ పరిసరంలో, మాడ్యూల్ https://example.com/my-module.js నుండి సర్వ్ చేయబడితే, అవుట్‌పుట్ ఇలా ఉంటుంది:

            https://example.com/my-module.js

            

              
                Copy
              
            
          

వినియోగ సందర్భాలు మరియు ఉదాహరణలు

import.meta.url వివిధ పనులకు చాలా ఉపయోగకరంగా ఉంటుంది, వాటిలో ఇవి ఉన్నాయి:

1. రిలేటివ్ పాత్‌లను పరిష్కరించడం

అత్యంత సాధారణ వినియోగ సందర్భాలలో ఒకటి, మాడ్యూల్ ఉన్న అదే డైరెక్టరీలో లేదా సంబంధిత డైరెక్టరీలో ఉన్న వనరులకు రిలేటివ్ పాత్‌లను పరిష్కరించడం. మీరు రిలేటివ్ పాత్‌ల నుండి సంపూర్ణ URLలను సృష్టించడానికి URL కన్‌స్ట్రక్టర్‌ను import.meta.url తో కలిపి ఉపయోగించవచ్చు.

            // my-module.js
const imageUrl = new URL('./images/logo.png', import.meta.url).href;
console.log(imageUrl);

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, ./images/logo.png ఒక రిలేటివ్ పాత్. URL కన్‌స్ట్రక్టర్ రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది: రిలేటివ్ పాత్ మరియు బేస్ URL (import.meta.url). ఇది తర్వాత రిలేటివ్ పాత్‌ను బేస్ URL తో పరిష్కరించి ఒక సంపూర్ణ URL ను సృష్టిస్తుంది. .href ప్రాపర్టీ URL యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని తిరిగి ఇస్తుంది.

my-module.js /path/to/my-module.js వద్ద ఉంటే, imageUrl విలువ ఇలా ఉంటుంది:

            file:///path/to/images/logo.png

            

              
                Copy
              
            
          

ఈ టెక్నిక్ మాడ్యూల్‌కు సంబంధించి ఉన్న చిత్రాలు, ఫాంట్‌లు లేదా డేటా ఫైల్‌ల వంటి ఆస్తులను లోడ్ చేయడానికి చాలా ముఖ్యం.

2. కాన్ఫిగరేషన్ ఫైల్‌లను లోడ్ చేయడం

మరొక వినియోగ సందర్భం మాడ్యూల్ దగ్గర ఉన్న కాన్ఫిగరేషన్ ఫైల్‌లను (ఉదా., JSON ఫైల్‌లు) లోడ్ చేయడం. ఇది పాత్‌లను హార్డ్‌కోడ్ చేయకుండా మీ మాడ్యూల్స్‌ను వాటి డిప్లాయ్‌మెంట్ పరిసరం ఆధారంగా కాన్ఫిగర్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

            // my-module.js
async function loadConfig() {
  const configUrl = new URL('./config.json', import.meta.url);
  const response = await fetch(configUrl);
  const config = await response.json();
  return config;
}

loadConfig().then(config => {
  console.log(config);
});

            

              
                Copy
              
            
          

ఇక్కడ, loadConfig ఫంక్షన్ my-module.js తో అదే డైరెక్టరీలో ఉన్న config.json ఫైల్‌ను ఫెచ్ చేస్తుంది. ఫైల్ కంటెంట్‌లను తిరిగి పొందడానికి fetch API ఉపయోగించబడుతుంది, మరియు response.json() పద్ధతి JSON డేటాను పార్స్ చేస్తుంది.

config.json లో ఇది ఉంటే:

            {
  "apiUrl": "https://api.example.com",
  "timeout": 5000
}

            

              
                Copy
              
            
          

అవుట్‌పుట్ ఇలా ఉంటుంది:

            { apiUrl: 'https://api.example.com', timeout: 5000 }

            

              
                Copy
              
            
          

3. డైనమిక్ మాడ్యూల్ లోడింగ్

import.meta.url ను రన్‌టైమ్ పరిస్థితుల ఆధారంగా మాడ్యూల్స్‌ను డైనమిక్‌గా లోడ్ చేయడానికి డైనమిక్ import() తో కూడా ఉపయోగించవచ్చు. ఇది కోడ్ స్ప్లిటింగ్ లేదా లేజీ లోడింగ్ వంటి ఫీచర్‌లను అమలు చేయడానికి ఉపయోగపడుతుంది.

            // my-module.js
async function loadModule(moduleName) {
  const moduleUrl = new URL(`./modules/${moduleName}.js`, import.meta.url);
  const module = await import(moduleUrl);
  return module;
}

loadModule('featureA').then(module => {
  module.init();
});

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, loadModule ఫంక్షన్ moduleName ఆర్గ్యుమెంట్ ఆధారంగా డైనమిక్‌గా ఒక మాడ్యూల్‌ను ఇంపోర్ట్ చేస్తుంది. మాడ్యూల్‌కు సరైన పాత్ పరిష్కరించబడిందని నిర్ధారించడానికి URL ను import.meta.url ఉపయోగించి నిర్మించబడింది.

ఈ టెక్నిక్ ప్లగిన్ సిస్టమ్‌లను సృష్టించడానికి లేదా డిమాండ్‌పై మాడ్యూల్స్‌ను లోడ్ చేయడానికి చాలా శక్తివంతమైనది, ఇది అప్లికేషన్ పనితీరును మెరుగుపరుస్తుంది మరియు ప్రారంభ లోడ్ సమయాలను తగ్గిస్తుంది.

4. వెబ్ వర్కర్స్‌తో పనిచేయడం

వెబ్ వర్కర్స్‌తో పనిచేస్తున్నప్పుడు, వర్కర్ స్క్రిప్ట్ యొక్క URL ను పేర్కొనడానికి import.meta.url చాలా అవసరం. ఇది ప్రధాన స్క్రిప్ట్ ఎక్కడ ఉన్నప్పటికీ వర్కర్ స్క్రిప్ట్ సరిగ్గా లోడ్ చేయబడిందని నిర్ధారిస్తుంది.

            // main.js
const workerUrl = new URL('./worker.js', import.meta.url);
const worker = new Worker(workerUrl);

worker.onmessage = (event) => {
  console.log('Message from worker:', event.data);
};

worker.postMessage('Hello from main!');

// worker.js
self.onmessage = (event) => {
  console.log('Message from main:', event.data);
  self.postMessage('Hello from worker!');
};

            

              
                Copy
              
            
          

ఇక్కడ, workerUrl ను import.meta.url ఉపయోగించి నిర్మించబడింది, ఇది main.js కు సంబంధించి సరైన ప్రదేశం నుండి worker.js స్క్రిప్ట్ లోడ్ చేయబడిందని నిర్ధారిస్తుంది.

5. ఫ్రేమ్‌వర్క్ మరియు లైబ్రరీ డెవలప్‌మెంట్

ఫ్రేమ్‌వర్క్‌లు మరియు లైబ్రరీలు వనరులు, ప్లగిన్‌లు, లేదా టెంప్లేట్‌లను గుర్తించడానికి తరచుగా import.meta.url పై ఆధారపడతాయి. ఇది లైబ్రరీ ఎలా ఇన్‌స్టాల్ చేయబడింది లేదా ఉపయోగించబడింది అనే దానితో సంబంధం లేకుండా లైబ్రరీ యొక్క ఫైల్‌ల స్థానాన్ని నిర్ణయించడానికి ఒక విశ్వసనీయ మార్గాన్ని అందిస్తుంది.

ఉదాహరణకు, ఒక UI లైబ్రరీ దాని CSS ఫైల్‌లు లేదా కాంపోనెంట్ టెంప్లేట్‌లను గుర్తించడానికి import.meta.url ను ఉపయోగించవచ్చు.

            // my-library.js
const cssUrl = new URL('./styles.css', import.meta.url);
const link = document.createElement('link');
link.rel = 'stylesheet';
link.href = cssUrl;
document.head.appendChild(link);

            

              
                Copy
              
            
          

ఇది వినియోగదారు లైబ్రరీ యొక్క జావాస్క్రిప్ట్ ఫైల్‌ను ఎక్కడ ఉంచినా లైబ్రరీ యొక్క CSS సరిగ్గా లోడ్ చేయబడిందని నిర్ధారిస్తుంది.

అధునాతన పద్ధతులు మరియు పరిగణనలు

1. వివిధ పరిసరాలను నిర్వహించడం

import.meta.url మాడ్యూల్ పాత్‌లను పరిష్కరించడానికి ఒక స్థిరమైన మార్గాన్ని అందించినప్పటికీ, మీరు బ్రౌజర్ మరియు Node.js పరిసరాల మధ్య తేడాలను ఇప్పటికీ నిర్వహించాల్సి రావచ్చు. ఉదాహరణకు, URL స్కీమ్ భిన్నంగా ఉండవచ్చు (Node.js లో file:/// vs. బ్రౌజర్‌లో https://). మీ కోడ్‌ను తదనుగుణంగా మార్చుకోవడానికి మీరు ఫీచర్ డిటెక్షన్‌ను ఉపయోగించవచ్చు.

            // my-module.js
const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
const baseUrl = import.meta.url;

let apiUrl;
if (isBrowser) {
  apiUrl = new URL('/api', baseUrl).href; // Browser: relative to the domain
} else {
  apiUrl = new URL('./api', baseUrl).href; // Node.js: relative to the file path
}

console.log(apiUrl);

            

              
                Copy
              
            
          

ఈ ఉదాహరణలో, కోడ్ బ్రౌజర్ పరిసరంలో రన్ అవుతుందో లేదో తనిఖీ చేస్తుంది. అలా అయితే, ఇది డొమైన్‌కు సంబంధించి API URL ను నిర్మిస్తుంది. లేకపోతే, ఇది ఫైల్ పాత్‌కు సంబంధించి URL ను నిర్మిస్తుంది, ఇది Node.js లో రన్ అవుతుందని భావించి.

2. బండ్లర్లు మరియు మినిఫైయర్‌లతో వ్యవహరించడం

ఆధునిక జావాస్క్రిప్ట్ బండ్లర్లు వెబ్‌ప్యాక్, పార్సెల్ మరియు రోలప్ వంటివి మీ కోడ్‌ను మార్చవచ్చు మరియు చివరి అవుట్‌పుట్ ఫైల్ నిర్మాణాన్ని మార్చవచ్చు. ఇది import.meta.url విలువపై ప్రభావం చూపవచ్చు. చాలా బండ్లర్లు దీనిని సరిగ్గా నిర్వహించడానికి యంత్రాంగాలను అందిస్తాయి, కానీ సంభావ్య సమస్యల గురించి తెలుసుకోవడం ముఖ్యం.

ఉదాహరణకు, కొన్ని బండ్లర్లు import.meta.url ను రన్‌టైమ్‌లో పరిష్కరించబడే ప్లేస్‌హోల్డర్‌తో భర్తీ చేయవచ్చు. మరికొన్ని పరిష్కరించబడిన URL ను నేరుగా కోడ్‌లో ఇన్‌లైన్ చేయవచ్చు. మీ బండ్లర్ import.meta.url ను ఎలా నిర్వహిస్తుందనే దానిపై నిర్దిష్ట వివరాల కోసం మీ బండ్లర్ యొక్క డాక్యుమెంటేషన్‌ను చూడండి.

3. భద్రతా పరిగణనలు

వనరులను డైనమిక్‌గా లోడ్ చేయడానికి import.meta.url ను ఉపయోగిస్తున్నప్పుడు, భద్రతాపరమైన చిక్కుల గురించి జాగ్రత్తగా ఉండండి. సరైన ధ్రువీకరణ మరియు శానిటైజేషన్ లేకుండా వినియోగదారు ఇన్‌పుట్ ఆధారంగా URL లను నిర్మించడం మానుకోండి. ఇది సంభావ్య పాత్ ట్రావర్సల్ దుర్బలత్వాలను నివారించగలదు.

ఉదాహరణకు, మీరు వినియోగదారు అందించిన moduleName ఆధారంగా మాడ్యూల్స్‌ను లోడ్ చేస్తుంటే, వినియోగదారులు ఏకపక్ష ఫైల్‌లను లోడ్ చేయకుండా నిరోధించడానికి moduleName ను అనుమతించబడిన విలువల యొక్క వైట్‌లిస్ట్‌కు వ్యతిరేకంగా ధ్రువీకరించబడిందని నిర్ధారించుకోండి.

4. ఎర్రర్ హ్యాండ్లింగ్

ఫైల్ పాత్‌లు మరియు URL లతో పనిచేస్తున్నప్పుడు, ఎల్లప్పుడూ బలమైన ఎర్రర్ హ్యాండ్లింగ్‌ను చేర్చండి. ఫైల్‌లను లోడ్ చేయడానికి ప్రయత్నించే ముందు అవి ఉన్నాయో లేదో తనిఖీ చేయండి మరియు సంభావ్య నెట్‌వర్క్ లోపాలను సున్నితంగా నిర్వహించండి. ఇది మీ అప్లికేషన్‌ల యొక్క పటుత్వం మరియు విశ్వసనీయతను మెరుగుపరుస్తుంది.

ఉదాహరణకు, ఒక కాన్ఫిగరేషన్ ఫైల్‌ను ఫెచ్ చేస్తున్నప్పుడు, ఫైల్ కనుగొనబడనప్పుడు లేదా నెట్‌వర్క్ కనెక్షన్ విఫలమైనప్పుడు కేసులను నిర్వహించండి.

            // my-module.js
async function loadConfig() {
  try {
    const configUrl = new URL('./config.json', import.meta.url);
    const response = await fetch(configUrl);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const config = await response.json();
    return config;
  } catch (error) {
    console.error('Failed to load config:', error);
    return null; // Or a default config
  }
}

            

              
                Copy
              
            
          

ఉత్తమ పద్ధతులు

import.meta.url ను సమర్థవంతంగా ఉపయోగించడానికి, ఈ క్రింది ఉత్తమ పద్ధతులను పరిగణించండి:

• సాధ్యమైనప్పుడల్లా రిలేటివ్ పాత్‌లను ఉపయోగించండి: రిలేటివ్ పాత్‌లు మీ కోడ్‌ను మరింత పోర్టబుల్ మరియు నిర్వహించడానికి సులభతరం చేస్తాయి.
• వినియోగదారు ఇన్‌పుట్‌ను ధ్రువీకరించండి మరియు శానిటైజ్ చేయండి: URL లను నిర్మించడానికి ఉపయోగించే ఏదైనా వినియోగదారు అందించిన ఇన్‌పుట్‌ను ధ్రువీకరించడం ద్వారా పాత్ ట్రావర్సల్ దుర్బలత్వాలను నివారించండి.
• వివిధ పరిసరాలను సున్నితంగా నిర్వహించండి: వివిధ పరిసరాలకు (బ్రౌజర్ vs. Node.js) మీ కోడ్‌ను మార్చుకోవడానికి ఫీచర్ డిటెక్షన్‌ను ఉపయోగించండి.
• బలమైన ఎర్రర్ హ్యాండ్లింగ్‌ను చేర్చండి: ఫైల్ ఉనికిని తనిఖీ చేయండి మరియు సంభావ్య నెట్‌వర్క్ లోపాలను నిర్వహించండి.
• బండ్లర్ ప్రవర్తన గురించి తెలుసుకోండి: మీ బండ్లర్ import.meta.url ను ఎలా నిర్వహిస్తుందో అర్థం చేసుకోండి మరియు మీ కోడ్‌ను తదనుగుణంగా సర్దుబాటు చేయండి.
• మీ కోడ్‌ను స్పష్టంగా డాక్యుమెంట్ చేయండి: మీరు import.meta.url ను ఎలా ఉపయోగిస్తున్నారో మరియు ఎందుకు ఉపయోగిస్తున్నారో వివరించండి, ఇది ఇతరులకు మీ కోడ్‌ను అర్థం చేసుకోవడానికి మరియు నిర్వహించడానికి సులభం చేస్తుంది.

import.meta.url కు ప్రత్యామ్నాయాలు

ES మాడ్యూల్స్‌లో మాడ్యూల్ పాత్‌లను పరిష్కరించడానికి import.meta.url ప్రామాణిక మార్గం అయినప్పటికీ, ప్రత్యామ్నాయ విధానాలు ఉన్నాయి, ముఖ్యంగా లెగసీ కోడ్ లేదా ES మాడ్యూల్స్‌కు పూర్తిగా మద్దతు ఇవ్వని పరిసరాలతో వ్యవహరిస్తున్నప్పుడు.

1. __filename మరియు __dirname (Node.js CommonJS)

Node.js CommonJS మాడ్యూల్స్‌లో, __filename ప్రస్తుత ఫైల్‌కు సంపూర్ణ పాత్‌ను అందిస్తుంది, మరియు __dirname ఫైల్‌ను కలిగి ఉన్న డైరెక్టరీకి సంపూర్ణ పాత్‌ను అందిస్తుంది. అయితే, ఈ వేరియబుల్స్ ES మాడ్యూల్స్ లేదా బ్రౌజర్ పరిసరాలలో అందుబాటులో ఉండవు.

వాటిని CommonJS పరిసరంలో ఉపయోగించడానికి:

            // my-module.js (CommonJS)
const path = require('path');

const filename = __filename;
const dirname = __dirname;

console.log('Filename:', filename);
console.log('Dirname:', dirname);

const imageUrl = path.join(dirname, 'images', 'logo.png');
console.log('Image URL:', imageUrl);

            

              
                Copy
              
            
          

ఈ విధానం ఫైల్ పాత్‌లను మార్చడానికి path మాడ్యూల్‌పై ఆధారపడి ఉంటుంది, ఇది import.meta.url తో URL కన్‌స్ట్రక్టర్‌ను ఉపయోగించడం కంటే తక్కువ సౌకర్యవంతంగా ఉండవచ్చు.

2. పాలిఫిల్స్ మరియు షిమ్స్

import.meta.url కు స్థానికంగా మద్దతు ఇవ్వని పరిసరాల కోసం, మీరు ఇదే విధమైన కార్యాచరణను అందించడానికి పాలిఫిల్స్ లేదా షిమ్స్‌ను ఉపయోగించవచ్చు. ఇవి సాధారణంగా పరిసరాన్ని గుర్తించడం మరియు ఇతర అందుబాటులో ఉన్న యంత్రాంగాల ఆధారంగా ఒక ఫాల్‌బ్యాక్ అమలును అందించడం కలిగి ఉంటాయి.

అయితే, పాలిఫిల్స్‌ను ఉపయోగించడం మీ కోడ్‌బేస్ పరిమాణాన్ని పెంచవచ్చు మరియు అనుకూలత సమస్యలను పరిచయం చేయవచ్చు, కాబట్టి సాధారణంగా సాధ్యమైనప్పుడల్లా import.meta.url ను ఉపయోగించడం మరియు దానికి స్థానికంగా మద్దతు ఇచ్చే పరిసరాలను లక్ష్యంగా చేసుకోవడం సిఫార్సు చేయబడింది.

ముగింపు

import.meta.url జావాస్క్రిప్ట్‌లో మాడ్యూల్ పాత్‌లను పరిష్కరించడానికి ఒక శక్తివంతమైన సాధనం, ఇది వివిధ పరిసరాలలో వనరులు మరియు మాడ్యూల్స్‌ను గుర్తించడానికి ఒక స్థిరమైన మరియు విశ్వసనీయమైన మార్గాన్ని అందిస్తుంది. దాని కార్యాచరణ, వినియోగ సందర్భాలు, మరియు ఉత్తమ పద్ధతులను అర్థం చేసుకోవడం ద్వారా, మీరు మరింత పోర్టబుల్, నిర్వహించదగిన, మరియు బలమైన కోడ్‌ను వ్రాయవచ్చు. మీరు వెబ్ అప్లికేషన్‌లు, Node.js సేవలు, లేదా జావాస్క్రిప్ట్ లైబ్రరీలు నిర్మిస్తున్నా, సమర్థవంతమైన మాడ్యూల్ అభివృద్ధి కోసం import.meta.url నైపుణ్యం సాధించాల్సిన ఒక ముఖ్యమైన భావన.

import.meta.url ను ఉపయోగిస్తున్నప్పుడు మీ ప్రాజెక్ట్ యొక్క నిర్దిష్ట అవసరాలు మరియు మీరు లక్ష్యంగా చేసుకుంటున్న పరిసరాలను పరిగణనలోకి తీసుకోవడం గుర్తుంచుకోండి. ఈ వ్యాసంలో వివరించిన మార్గదర్శకాలను అనుసరించడం ద్వారా, మీరు ప్రపంచవ్యాప్తంగా సులభంగా డిప్లాయ్ చేయడానికి మరియు నిర్వహించడానికి వీలైన అధిక-నాణ్యత జావాస్క్రిప్ట్ అప్లికేషన్‌లను సృష్టించడానికి దాని సామర్థ్యాలను ఉపయోగించుకోవచ్చు.