ஜாவாஸ்கிரிப்ட் குறியீட்டுத் தரம்: ESLint விதிகள் மற்றும் ஸ்டேடிக் அனாலிசிஸ்

இன்றைய வேகமான மென்பொருள் மேம்பாட்டு சூழலில், சுத்தமான, பராமரிக்கக்கூடிய, மற்றும் வலுவான குறியீட்டை எழுதுவது மிக முக்கியம். ஜாவாஸ்கிரிப்ட் டெவலப்பர்களுக்கு, குறிப்பாக பல்வேறு அணிகள் மற்றும் நேர மண்டலங்களில் ஒத்துழைப்பு பொதுவான உலகளாவிய திட்டங்களில், நம்பகமான பயன்பாடுகளை உருவாக்குவதற்கு உயர் குறியீட்டுத் தரத்தை உறுதி செய்வது மிகவும் அவசியமானது. இதை அடைவதற்கான மிகவும் பயனுள்ள கருவிகளில் ஒன்று ESLint மற்றும் ஸ்டேடிக் அனாலிசிஸ் செயல்படுத்துவதாகும்.

ESLint என்றால் என்ன?

ESLint என்பது ஒரு சக்திவாய்ந்த ஜாவாஸ்கிரிப்ட் லிண்டிங் கருவியாகும். இது உங்கள் குறியீட்டைப் பகுப்பாய்வு செய்து, சாத்தியமான சிக்கல்களைக் கண்டறியவும், குறியீட்டு பாணி மரபுகளைச் செயல்படுத்தவும், பிழைகள் ஏற்படுவதற்கு முன்பே தடுக்கவும் உதவுகிறது. இது உங்கள் குறியீட்டுத் தளம் முழுவதும் நிலைத்தன்மையை பராமரிக்க உதவுகிறது, இதனால் அணிகள் ஒத்துழைப்பதற்கும் எதிர்கால டெவலப்பர்கள் குறியீட்டைப் புரிந்துகொள்வதற்கும் மாற்றுவதற்கும் எளிதாக்குகிறது.

ESLint பயன்படுத்துவதன் முக்கிய நன்மைகள்:

• ஆரம்ப நிலை பிழை கண்டறிதல்: மேம்பாட்டின் போது சாத்தியமான பிழைகள் மற்றும் தவறுகளைக் கண்டறிந்து, இயக்க நேரச் சிக்கல்களின் அபாயத்தைக் குறைக்கிறது.
• குறியீட்டு பாணி அமலாக்கம்: சீரான குறியீட்டு பாணியை அமல்படுத்துகிறது, இது குறியீட்டுத் தளத்தை மேலும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் ஆக்குகிறது.
• மேம்படுத்தப்பட்ட ஒத்துழைப்பு: மேம்பாட்டுக் குழு முழுவதும் நிலைத்தன்மையை ஊக்குவிக்கும் ஒரு பகிரப்பட்ட விதிகளை வழங்குகிறது.
• தானியங்கு குறியீட்டு ஆய்வு: குறியீட்டு ஆய்வின் செயல்முறையைத் தானியங்குபடுத்துகிறது, டெவலப்பர்களை மிகவும் சிக்கலான பணிகளில் கவனம் செலுத்த அனுமதிக்கிறது.
• தனிப்பயனாக்கக்கூடிய விதிகள்: உங்கள் குறிப்பிட்ட திட்டத் தேவைகள் மற்றும் குறியீட்டு விருப்பங்களுடன் பொருந்தும் வகையில் விதிகளை உள்ளமைக்க உங்களை அனுமதிக்கிறது.

ஸ்டேடிக் அனாலிசிஸ்-ஐப் புரிந்துகொள்ளுதல்

ஸ்டேடிக் அனாலிசிஸ் என்பது ஒரு நிரல் இயக்கப்படுவதற்கு முன் மூலக் குறியீட்டை ஆய்வு செய்வதன் மூலம் பிழைத்திருத்தம் செய்யும் ஒரு முறையாகும். டைனமிக் அனாலிசிஸ் போலல்லாமல், சிக்கல்களைக் கண்டறிய குறியீட்டை இயக்க வேண்டியிருக்கும், ஸ்டேடிக் அனாலிசிஸ் குறியீட்டின் கட்டமைப்பு மற்றும் தொடரியலை பகுப்பாய்வு செய்வதை நம்பியுள்ளது. ESLint என்பது ஸ்டேடிக் அனாலிசிஸ் கருவியின் ஒரு வடிவமாகும், ஆனால் பரந்த கருத்து பாதுகாப்பு பாதிப்புகள், செயல்திறன் தடைகள் மற்றும் பிற சாத்தியமான சிக்கல்களைக் கண்டறியக்கூடிய பிற கருவிகளையும் உள்ளடக்கியது.

ஸ்டேடிக் அனாலிசிஸ் எவ்வாறு செயல்படுகிறது

ஸ்டேடிக் அனாலிசிஸ் கருவிகள் பொதுவாக குறியீட்டை பகுப்பாய்வு செய்ய பின்வரும் நுட்பங்களின் கலவையைப் பயன்படுத்துகின்றன:

• லெக்சிக்கல் அனாலிசிஸ்: குறியீட்டை டோக்கன்களாக (எ.கா., முக்கிய வார்த்தைகள், ஆபரேட்டர்கள், அடையாளங்காட்டிகள்) உடைத்தல்.
• தொடரியல் பகுப்பாய்வு (Syntax Analysis): குறியீட்டின் கட்டமைப்பைக் குறிக்க ஒரு பார்ஸ் ட்ரீ (parse tree) உருவாக்குதல்.
• சொற்பொருள் பகுப்பாய்வு (Semantic Analysis): குறியீட்டின் பொருள் மற்றும் நிலைத்தன்மையை சரிபார்த்தல்.
• தரவு ஓட்டப் பகுப்பாய்வு (Data Flow Analysis): சாத்தியமான சிக்கல்களைக் கண்டறிய குறியீட்டின் வழியாக தரவு ஓட்டத்தைக் கண்காணித்தல்.

உங்கள் திட்டத்தில் ESLint அமைத்தல்

ESLint அமைப்பது மிகவும் எளிது. இதோ ஒரு படிப்படியான வழிகாட்டி:

1. ESLint ஐ நிறுவவும்:

   உங்கள் திட்டத்தில் ESLint ஐ குளோபல் ஆகவோ அல்லது லோக்கல் ஆகவோ நிறுவலாம். ஒரு திட்டத்திற்கு சார்புகளை நிர்வகிக்க அதை லோக்கல் ஆக நிறுவுவது பொதுவாக பரிந்துரைக்கப்படுகிறது.

               npm install eslint --save-dev
   # or
   yarn add eslint --dev
               
   
                 
                   Copy
                 
               
             

2. ESLint உள்ளமைவைத் தொடங்கவும்:

   உங்கள் திட்டத்தின் ரூட் டைரக்டரியில் ESLint உள்ளமைவு கோப்பை உருவாக்க பின்வரும் கட்டளையை இயக்கவும்.

               npx eslint --init
               
   
                 
                   Copy
                 
               
             

   இது உங்கள் திட்டத்தின் தேவைகளின் அடிப்படையில் ESLint ஐ உள்ளமைக்க தொடர்ச்சியான கேள்விகள் மூலம் உங்களுக்கு வழிகாட்டும். ஏற்கனவே உள்ள உள்ளமைவை (எ.கா., Airbnb, Google, Standard) நீட்டிக்க அல்லது உங்கள் சொந்த உள்ளமைவை உருவாக்க நீங்கள் தேர்வு செய்யலாம்.

3. ESLint விதிகளை உள்ளமைக்கவும்:

   ESLint உள்ளமைவு கோப்பு (.eslintrc.js, .eslintrc.yaml, அல்லது .eslintrc.json) ESLint செயல்படுத்தும் விதிகளை வரையறுக்கிறது. உங்கள் திட்டத்தின் குறியீட்டு பாணி மற்றும் தேவைகளுடன் பொருந்தும் வகையில் இந்த விதிகளை நீங்கள் தனிப்பயனாக்கலாம்.

   எடுத்துக்காட்டு .eslintrc.js:

               module.exports = {
     env: {
       browser: true,
       es2021: true,
       node: true
     },
     extends: [
       'eslint:recommended',
       'plugin:react/recommended',
       'plugin:@typescript-eslint/recommended'
     ],
     parser: '@typescript-eslint/parser',
     parserOptions: {
       ecmaFeatures: {
         jsx: true
       },
       ecmaVersion: 12,
       sourceType: 'module'
     },
     plugins: [
       'react',
       '@typescript-eslint'
     ],
     rules: {
       'no-unused-vars': 'warn',
       'no-console': 'warn',
       'react/prop-types': 'off',
       '@typescript-eslint/explicit-function-return-type': 'off'
     }
   };
               
   
                 
                   Copy
                 
               
             

4. உங்கள் எடிட்டருடன் ESLint ஐ ஒருங்கிணைக்கவும்:

   பெரும்பாலான பிரபலமான கோட் எடிட்டர்களில் ESLint செருகுநிரல்கள் உள்ளன, அவை நீங்கள் குறியீட்டை எழுதும்போது நிகழ்நேரக் கருத்தை வழங்குகின்றன. இது பிழைகளை உடனடியாகக் கண்டறிந்து சரிசெய்ய உங்களை அனுமதிக்கிறது.

   • VS Code: VS Code மார்க்கெட்பிளேஸிலிருந்து ESLint நீட்டிப்பை நிறுவவும்.
   • Sublime Text: SublimeLinter-eslint செருகுநிரலுடன் SublimeLinter தொகுப்பைப் பயன்படுத்தவும்.
   • Atom: linter-eslint தொகுப்பை நிறுவவும்.
5. ESLint ஐ இயக்கவும்:

   உங்கள் குறியீட்டைப் பகுப்பாய்வு செய்ய நீங்கள் கட்டளை வரியிலிருந்து ESLint ஐ இயக்கலாம்.

               npx eslint .
               
   
                 
                   Copy
                 
               
             

   இந்த கட்டளை தற்போதைய டைரக்டரியில் உள்ள அனைத்து ஜாவாஸ்கிரிப்ட் கோப்புகளையும் பகுப்பாய்வு செய்து, உள்ளமைக்கப்பட்ட விதிகளின் மீறல்களைப் புகாரளிக்கும்.

பொதுவான ESLint விதிகள் மற்றும் சிறந்த நடைமுறைகள்

ESLint குறியீட்டு பாணி மரபுகளை அமல்படுத்தவும் பிழைகளைத் தடுக்கவும் பயன்படுத்தக்கூடிய பரந்த அளவிலான விதிகளை வழங்குகிறது. மிகவும் பொதுவான மற்றும் பயனுள்ள சில விதிகள் இங்கே:

• no-unused-vars: அறிவிக்கப்பட்ட ஆனால் ஒருபோதும் பயன்படுத்தப்படாத மாறிகள் குறித்து எச்சரிக்கிறது. இது இறந்த குறியீட்டைத் தடுக்கவும் ஒழுங்கீனத்தைக் குறைக்கவும் உதவுகிறது.
• no-console: புரொடக்ஷன் குறியீட்டில் console.log அறிக்கைகளின் பயன்பாட்டை அனுமதிக்காது. வரிசைப்படுத்தலுக்கு முன் பிழைத்திருத்த அறிக்கைகளை சுத்தம் செய்ய பயனுள்ளதாக இருக்கும்.
• no-unused-expressions: எந்த பக்க விளைவுகளையும் ஏற்படுத்தாத கோவைகள் போன்ற பயன்படுத்தப்படாத கோவைகளை அனுமதிக்காது.
• eqeqeq: சுருக்க சமத்துவத்திற்கு (== மற்றும் !=) பதிலாக கடுமையான சமத்துவத்தை (=== மற்றும் !==) பயன்படுத்த கட்டாயப்படுத்துகிறது. இது எதிர்பாராத வகை வற்புறுத்தல் சிக்கல்களைத் தடுக்க உதவுகிறது.
• no-shadow: வெளிப்புற வரம்புகளில் அறிவிக்கப்பட்ட மாறிகளை மறைக்கும் மாறி அறிவிப்புகளை அனுமதிக்காது.
• no-undef: அறிவிக்கப்படாத மாறிகளின் பயன்பாட்டை அனுமதிக்காது.
• no-use-before-define: மாறிகள் வரையறுக்கப்படுவதற்கு முன்பு அவற்றின் பயன்பாட்டை அனுமதிக்காது.
• indent: சீரான உள்தள்ளல் பாணியை (எ.கா., 2 இடைவெளிகள், 4 இடைவெளிகள், அல்லது தாவல்கள்) அமல்படுத்துகிறது.
• quotes: மேற்கோள்களின் சீரான பயன்பாட்டை (எ.கா., ஒற்றை மேற்கோள்கள் அல்லது இரட்டை மேற்கோள்கள்) அமல்படுத்துகிறது.
• semi: அறிக்கைகளின் முடிவில் அரைப்புள்ளிகளின் பயன்பாட்டை அமல்படுத்துகிறது.

எடுத்துக்காட்டு: சீரான மேற்கோள்களை அமல்படுத்துதல்

உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டில் ஒற்றை மேற்கோள்களின் பயன்பாட்டை அமல்படுத்த, உங்கள் ESLint உள்ளமைவில் பின்வரும் விதியைச் சேர்க்கவும்:

            rules: {
  'quotes': ['error', 'single']
}
            

              
                Copy
              
            
          

இந்த விதி இயக்கப்பட்டால், நீங்கள் ஒற்றை மேற்கோள்களுக்குப் பதிலாக இரட்டை மேற்கோள்களைப் பயன்படுத்தினால் ESLint ஒரு பிழையைப் புகாரளிக்கும்.

உங்கள் பணிப்பாய்வில் ESLint ஐ ஒருங்கிணைத்தல்

ESLint-ன் நன்மைகளை அதிகரிக்க, அதை உங்கள் மேம்பாட்டு பணிப்பாய்வில் ஒருங்கிணைப்பது முக்கியம். இங்கே சில சிறந்த நடைமுறைகள் உள்ளன:

• ப்ரீ-கமிட் ஹூக்கைப் பயன்படுத்தவும்:

  குறியீட்டை கமிட் செய்வதற்கு முன்பு ESLint-ஐ இயக்க ஒரு ப்ரீ-கமிட் ஹூக்கை உள்ளமைக்கவும். இது ESLint விதிகளை மீறும் குறியீடு களஞ்சியத்தில் கமிட் செய்யப்படுவதைத் தடுக்கிறது.

  ப்ரீ-கமிட் ஹூக்குகளை அமைக்க Husky மற்றும் lint-staged போன்ற கருவிகளைப் பயன்படுத்தலாம்.

              npm install husky --save-dev
  npm install lint-staged --save-dev
              
  
                
                  Copy
                
              
            

  உங்கள் package.json இல் பின்வரும் உள்ளமைவைச் சேர்க்கவும்:

              {
    "husky": {
      "hooks": {
        "pre-commit": "lint-staged"
      }
    },
    "lint-staged": {
      "*.js": [
        "eslint --fix",
        "git add"
      ]
    }
  }
              
  
                
                  Copy
                
              
            

• தொடர்ச்சியான ஒருங்கிணைப்புடன் (CI) ஒருங்கிணைக்கவும்:

  வரிசைப்படுத்தப்படுவதற்கு முன்பு அனைத்து குறியீடுகளும் உங்கள் தரத் தரநிலைகளைப் பூர்த்தி செய்வதை உறுதிசெய்ய, உங்கள் CI பைப்லைனின் ஒரு பகுதியாக ESLint-ஐ இயக்கவும். இது பிழைகளை ஆரம்பத்திலேயே பிடிக்க உதவுகிறது மற்றும் அவை தயாரிப்புக்கு வருவதைத் தடுக்கிறது.

  Jenkins, Travis CI, CircleCI, மற்றும் GitHub Actions போன்ற பிரபலமான CI கருவிகள் ESLint-ஐ இயக்குவதற்கான ஒருங்கிணைப்புகளை வழங்குகின்றன.

• குறியீடு வடிவமைப்பைத் தானியங்குபடுத்துங்கள்:

  உங்கள் உள்ளமைக்கப்பட்ட பாணி விதிகளின்படி உங்கள் குறியீட்டைத் தானாக வடிவமைக்க Prettier போன்ற குறியீடு வடிவமைப்பாளரைப் பயன்படுத்தவும். இது கைமுறையாக குறியீட்டை வடிவமைக்க வேண்டிய தேவையை நீக்குகிறது மற்றும் குறியீட்டுத்தளம் முழுவதும் நிலைத்தன்மையை உறுதி செய்கிறது.

  வடிவமைப்பு சிக்கல்களைத் தானாகச் சரிசெய்ய நீங்கள் Prettier-ஐ ESLint உடன் ஒருங்கிணைக்கலாம்.

              npm install prettier eslint-config-prettier eslint-plugin-prettier --save-dev
              
  
                
                  Copy
                
              
            

  உங்கள் .eslintrc.js ஐப் புதுப்பிக்கவும்:

              module.exports = {
    extends: [
      'eslint:recommended',
      'plugin:react/recommended',
      'plugin:@typescript-eslint/recommended',
      'prettier'
    ],
    plugins: [
      'react',
      '@typescript-eslint',
      'prettier'
    ],
    rules: {
      'prettier/prettier': 'error'
    }
  };
              
  
                
                  Copy
                
              
            

ESLint-க்கு அப்பால்: பிற ஸ்டேடிக் அனாலிசிஸ் கருவிகளை ஆராய்தல்

ESLint லிண்டிங் மற்றும் ஸ்டைல் அமலாக்கத்திற்கு ஒரு அருமையான கருவியாக இருந்தாலும், பல பிற ஸ்டேடிக் அனாலிசிஸ் கருவிகள் உங்கள் குறியீட்டைப் பற்றி ஆழமான நுண்ணறிவுகளை வழங்கலாம் மற்றும் மிகவும் சிக்கலான சிக்கல்களைக் கண்டறியலாம்.

• SonarQube: குறியீட்டுத் தரத்தின் தொடர்ச்சியான ஆய்வுக்கான ஒரு விரிவான தளம். இது ஜாவாஸ்கிரிப்ட் உட்பட பல்வேறு மொழிகளில் பிழைகள், பாதிப்புகள் மற்றும் குறியீட்டு நாற்றங்களைக் கண்டறிகிறது. SonarQube காலப்போக்கில் குறியீட்டுத் தரத்தைக் கண்காணிக்கவும் மேம்படுத்தவும் உங்களுக்கு உதவ விரிவான அறிக்கைகள் மற்றும் அளவீடுகளை வழங்குகிறது.
• JSHint: ஒரு பழைய, ஆனால் இன்னும் பயனுள்ள, ஜாவாஸ்கிரிப்ட் லிண்டிங் கருவி. இது சில பகுதிகளில் ESLint-ஐ விட அதிக உள்ளமைக்கக்கூடியது.
• TSLint: (வழக்கற்றுப் போனது, இப்போது டைப்ஸ்கிரிப்ட் செருகுநிரலுடன் ESLint விரும்பப்படுகிறது) குறிப்பாக டைப்ஸ்கிரிப்ட்டுக்கான ஒரு லின்டர். இப்போது டைப்ஸ்கிரிப்ட் திட்டங்கள் @typescript-eslint/eslint-plugin மற்றும் @typescript-eslint/parser உடன் ESLint-ஐப் பெருகிய முறையில் பயன்படுத்துகின்றன.
• FindBugs: ஜாவாவிற்கான ஒரு ஸ்டேடிக் அனாலிசிஸ் கருவி, இது ஜாவாஸ்கிரிப்ட் குறியீட்டை பகுப்பாய்வு செய்யவும் பயன்படுத்தப்படலாம். இது சாத்தியமான பிழைகள் மற்றும் செயல்திறன் சிக்கல்களைக் கண்டறிகிறது. முதன்மையாக ஜாவாவிற்கு இருந்தாலும், சில விதிகள் ஜாவாஸ்கிரிப்ட்டிற்குப் பயன்படுத்தப்படலாம்.
• PMD: ஜாவாஸ்கிரிப்ட் உட்பட பல மொழிகளை ஆதரிக்கும் ஒரு மூலக் குறியீடு பகுப்பாய்வி. இது இறந்த குறியீடு, நகல் குறியீடு மற்றும் அதிகப்படியான சிக்கலான குறியீடு போன்ற சாத்தியமான சிக்கல்களைக் கண்டறிகிறது.

உலகளாவிய திட்டங்களில் ESLint: சர்வதேச அணிகளுக்கான பரிசீலனைகள்

பரவலாக்கப்பட்ட அணிகளுடன் உலகளாவிய ஜாவாஸ்கிரிப்ட் திட்டங்களில் பணிபுரியும் போது, ESLint இன்னும் முக்கியமானதாகிறது. இங்கே சில பரிசீலனைகள் உள்ளன:

• பகிரப்பட்ட உள்ளமைவு: அனைத்து குழு உறுப்பினர்களும் ஒரே ESLint உள்ளமைவு கோப்பைப் பயன்படுத்துவதை உறுதிப்படுத்தவும். இது குறியீட்டுத்தளம் முழுவதும் நிலைத்தன்மையை ஊக்குவிக்கிறது மற்றும் பாணி மோதல்களின் அபாயத்தைக் குறைக்கிறது. உள்ளமைவு கோப்பை நிர்வகிக்கவும், அதை புதுப்பித்த நிலையில் வைத்திருக்கவும் பதிப்புக் கட்டுப்பாட்டைப் பயன்படுத்தவும்.
• தெளிவான தொடர்பு: தேர்ந்தெடுக்கப்பட்ட ESLint விதிகளுக்குப் பின்னால் உள்ள காரணத்தை குழுவிடம் தெரிவிக்கவும். இது சில விதிகள் ஏன் உள்ளன என்பதை அனைவரும் புரிந்துகொள்ள உதவுகிறது மற்றும் அவற்றைப் பின்பற்ற அவர்களை ஊக்குவிக்கிறது. தேவைக்கேற்ப பயிற்சி மற்றும் ஆவணங்களை வழங்கவும்.
• தானியங்கு அமலாக்கம்: ESLint விதிகளை தானாக அமல்படுத்த ப்ரீ-கமிட் ஹூக்குகள் மற்றும் CI ஒருங்கிணைப்பைப் பயன்படுத்தவும். இது யார் எழுதியிருந்தாலும், அனைத்து குறியீடுகளும் தரத் தரங்களை பூர்த்தி செய்வதை உறுதி செய்கிறது.
• உள்ளூர்மயமாக்கல் பரிசீலனைகள்: உங்கள் திட்டம் உள்ளூர்மயமாக்கலை உள்ளடக்கியிருந்தால், உங்கள் ESLint விதிகள் உள்ளூர்மயமாக்கப்பட்ட சரங்களைப் பயன்படுத்துவதில் தலையிடாது என்பதை உறுதிப்படுத்தவும். எடுத்துக்காட்டாக, சில எழுத்துக்கள் அல்லது குறியாக்கத் திட்டங்களின் பயன்பாட்டைக் கட்டுப்படுத்தும் விதிகளைத் தவிர்க்கவும்.
• நேர மண்டல வேறுபாடுகள்: வெவ்வேறு நேர மண்டலங்களில் உள்ள அணிகளுடன் ஒத்துழைக்கும்போது, ESLint மீறல்கள் உடனடியாக கவனிக்கப்படுவதை உறுதிப்படுத்தவும். இது குறியீட்டுத் தர சிக்கல்கள் குவிந்து சரிசெய்வது கடினமாக மாறுவதைத் தடுக்கிறது. சாத்தியமான இடங்களில், தானியங்கு திருத்தங்கள் மிகவும் பயனுள்ளதாக இருக்கும்.

எடுத்துக்காட்டு: உள்ளூர்மயமாக்கல் சரங்களைக் கையாளுதல்

உங்கள் பயன்பாடு பல மொழிகளை ஆதரிக்கும் ஒரு சூழ்நிலையைக் கவனியுங்கள், மேலும் உள்ளூர்மயமாக்கப்பட்ட சரங்களை நிர்வகிக்க i18next போன்ற சர்வதேசமயமாக்கல் (i18n) நூலகங்களைப் பயன்படுத்துகிறீர்கள். சில ESLint விதிகள் இந்த சரங்களைப் பயன்படுத்தப்படாத மாறிகள் அல்லது தவறான தொடரியல் எனக் கொடியிடக்கூடும், குறிப்பாக அவை சிறப்பு எழுத்துக்கள் அல்லது வடிவமைப்பைக் கொண்டிருந்தால். இந்த நிகழ்வுகளைப் புறக்கணிக்க நீங்கள் ESLint-ஐ உள்ளமைக்க வேண்டும்.

உதாரணமாக, உங்கள் உள்ளூர்மயமாக்கப்பட்ட சரங்களை ஒரு தனி கோப்பில் (எ.கா., locales/en.json) சேமித்தால், இந்த கோப்புகளை லிண்டிங்கிலிருந்து விலக்க ESLint-ன் .eslintignore கோப்பைப் பயன்படுத்தலாம்:

            locales/*.json
            

              
                Copy
              
            
          

மாற்றாக, உள்ளூர்மயமாக்கப்பட்ட சரங்களுக்குப் பயன்படுத்தப்படும் மாறிகளை அறிவிக்க ESLint-ன் globals உள்ளமைவைப் பயன்படுத்தலாம்:

            module.exports = {
  globals: {
    'i18n': 'readonly',
    't': 'readonly'
  }
};
            

              
                Copy
              
            
          

முடிவுரை

ESLint மற்றும் ஸ்டேடிக் அனாலிசிஸ் பயன்பாட்டின் மூலம் ஜாவாஸ்கிரிப்ட் குறியீட்டுத் தரத்தில் முதலீடு செய்வது, குறிப்பாக உலகளாவிய சூழலில், பராமரிக்கக்கூடிய, வலுவான மற்றும் கூட்டுறவுத் திட்டங்களை உருவாக்குவதற்கு அவசியமானது. சீரான குறியீட்டு பாணிகளைச் செயல்படுத்துவதன் மூலமும், பிழைகளை ஆரம்பத்திலேயே கண்டறிவதன் மூலமும், குறியீட்டு ஆய்வைத் தானியங்குபடுத்துவதன் மூலமும், உங்கள் குறியீட்டுத் தளத்தின் ஒட்டுமொத்த தரத்தை மேம்படுத்தலாம் மற்றும் மேம்பாட்டு செயல்முறையை நெறிப்படுத்தலாம். உங்கள் குறிப்பிட்ட திட்டத் தேவைகளுக்கு ஏற்ப உங்கள் ESLint உள்ளமைவைத் தனிப்பயனாக்க நினைவில் கொள்ளுங்கள் மற்றும் இந்த சக்திவாய்ந்த கருவியின் முழு நன்மைகளையும் அறுவடை செய்ய உங்கள் பணிப்பாய்வில் தடையின்றி ஒருங்கிணைக்கவும். உங்கள் மேம்பாட்டுக் குழுவை மேம்படுத்தவும், உலகளாவிய பார்வையாளர்களின் கோரிக்கைகளைப் பூர்த்தி செய்யும் உயர்தர ஜாவாஸ்கிரிப்ட் பயன்பாடுகளை வழங்கவும் இந்த நடைமுறைகளைத் தழுவுங்கள்.