ஜாவாஸ்கிரிப்ட் பேட்டர்ன் மேட்சிங்: ஸ்ட்ரக்சரல் டிஸ்ட்ரக்சரிங் மற்றும் கார்டுகள்

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

பேட்டர்ன் மேட்சிங் என்றால் என்ன?

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

ஸ்ட்ரக்சரல் டிஸ்ட்ரக்சரிங்: மதிப்புகளை பிரித்தெடுத்தல்

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

அரேக்களை டிஸ்ட்ரக்சரிங் செய்தல்

ஒரு புவியியல் ஆயத்தொலைவைக் குறிக்கும் ஒரு அரேவைக் கவனியுங்கள்:

            
const coordinate = [40.7128, -74.0060]; // New York City

const [latitude, longitude] = coordinate;

console.log(latitude);  // Output: 40.7128
console.log(longitude); // Output: -74.0060

            

              
                Copy
              
            
          

இங்கே, நாம் `coordinate` அரேவை `latitude` மற்றும் `longitude` மாறிகளாக டிஸ்ட்ரக்சர் செய்துள்ளோம். இது இன்டெக்ஸ் அடிப்படையிலான குறியீட்டைப் பயன்படுத்தி (எ.கா., `coordinate[0]`) கூறுகளை அணுகுவதை விட மிகவும் தெளிவாக உள்ளது.

ஒரு அரேவில் மீதமுள்ள கூறுகளைப் பிடிக்க ரெஸ்ட் சிண்டாக்ஸையும் (`...`) பயன்படுத்தலாம்:

            
const colors = ['red', 'green', 'blue', 'yellow', 'purple'];

const [first, second, ...rest] = colors;

console.log(first);   // Output: red
console.log(second);  // Output: green
console.log(rest);    // Output: ['blue', 'yellow', 'purple']

            

              
                Copy
              
            
          

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

ஆப்ஜெக்ட்களை டிஸ்ட்ரக்சரிங் செய்தல்

ஆப்ஜெக்ட் டிஸ்ட்ரக்சரிங் சமமாக சக்தி வாய்ந்தது. ஒரு பயனர் சுயவிவரத்தைக் குறிக்கும் ஒரு ஆப்ஜெக்ட்டை கற்பனை செய்து பாருங்கள்:

            
const user = {
  id: 123,
  name: 'Alice Smith',
  location: { city: 'London', country: 'UK' },
  email: 'alice.smith@example.com'
};

const { name, location: { city, country }, email } = user;

console.log(name);     // Output: Alice Smith
console.log(city);     // Output: London
console.log(country);  // Output: UK
console.log(email);    // Output: alice.smith@example.com

            

              
                Copy
              
            
          

இங்கே, நாம் `user` ஆப்ஜெக்ட்டை டிஸ்ட்ரக்சர் செய்து `name`, `city`, `country`, மற்றும் `email`-ஐ பிரித்தெடுத்துள்ளோம். டிஸ்ட்ரக்சரிங் செய்யும் போது மாறிகளின் பெயரை மாற்ற கோலன் (`:`) சிண்டாக்ஸை எவ்வாறு பயன்படுத்தலாம் என்பதைக் கவனியுங்கள். இது ஆழமாக உள்ளமைக்கப்பட்ட பண்புகளைப் பிரித்தெடுக்க மிகவும் பயனுள்ளதாக இருக்கும்.

இயல்புநிலை மதிப்புகள்

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

            
const product = {
  name: 'Laptop',
  price: 1200
};

const { name, price, description = 'No description available' } = product;

console.log(name);        // Output: Laptop
console.log(price);       // Output: 1200
console.log(description); // Output: No description available

            

              
                Copy
              
            
          

`product` ஆப்ஜெக்டில் `description` பண்பு இல்லை என்றால், `description` மாறி `'No description available'` என்ற இயல்புநிலை மதிப்பைப் பெறும்.

கார்டுகள்: நிபந்தனைகளைச் சேர்த்தல்

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

`if` கூற்றுகளைப் பயன்படுத்துதல்

கார்டுகளைச் செயல்படுத்த மிகவும் நேரடியான வழி, டிஸ்ட்ரக்சரிங் செய்த பிறகு `if` கூற்றுகளைப் பயன்படுத்துவதாகும்:

            
function processOrder(order) {
  const { customer, items, shippingAddress } = order;

  if (!customer) {
    return 'Error: Customer information is missing.';
  }

  if (!items || items.length === 0) {
    return 'Error: No items in the order.';
  }

  // ... process the order
  return 'Order processed successfully.';
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், நாம் `order` ஆப்ஜெக்ட்டை டிஸ்ட்ரக்சர் செய்து, பின்னர் `customer` மற்றும் `items` பண்புகள் உள்ளனவா மற்றும் செல்லுபடியாகின்றனவா என்பதைச் சரிபார்க்க `if` கூற்றுகளைப் பயன்படுத்துகிறோம். இது பேட்டர்ன் மேட்சிங்கின் ஒரு அடிப்படை வடிவமாகும் – நாம் `order` ஆப்ஜெக்டில் குறிப்பிட்ட பேட்டர்ன்களை சரிபார்த்து, அந்த பேட்டர்ன்களின் அடிப்படையில் வெவ்வேறு குறியீட்டுப் பாதைகளைச் செயல்படுத்துகிறோம்.

`switch` கூற்றுகளைப் பயன்படுத்துதல்

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

தனிப்பயன் கார்டு செயல்பாடுகளை உருவாக்குதல்

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

            
function isValidEmail(email) {
  // Basic email validation (for demonstration purposes only)
  return /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/.test(email);
}

function processUser(user) {
  const { name, email } = user;

  if (!name) {
    return 'Error: Name is required.';
  }

  if (!email || !isValidEmail(email)) {
    return 'Error: Invalid email address.';
  }

  // ... process the user
  return 'User processed successfully.';
}

            

              
                Copy
              
            
          

இங்கே, நாம் `isValidEmail` என்ற செயல்பாட்டை உருவாக்கியுள்ளோம், இது ஒரு அடிப்படை மின்னஞ்சல் சரிபார்ப்பைச் செய்கிறது. பயனரைச் செயலாக்குவதற்கு முன் `email` பண்பு செல்லுபடியாகிறதா என்பதை உறுதிப்படுத்த இந்தச் செயல்பாட்டை ஒரு கார்டாகப் பயன்படுத்துகிறோம்.

டிஸ்ட்ரக்சரிங் மற்றும் கார்டுகளுடன் பேட்டர்ன் மேட்சிங் எடுத்துக்காட்டுகள்

API பதில்களைக் கையாளுதல்

வெற்றி அல்லது பிழை பதில்களைத் தரும் ஒரு API எண்ட்பாயிண்ட்டைக் கவனியுங்கள்:

            
async function fetchData(url) {
  try {
    const response = await fetch(url);
    const data = await response.json();

    if (data.status === 'success') {
      const { status, data: payload } = data;
      console.log('Data:', payload); // Process the data
      return payload;
    } else if (data.status === 'error') {
      const { status, error } = data;
      console.error('Error:', error.message); // Handle the error
      throw new Error(error.message);
    } else {
      console.error('Unexpected response format:', data);
      throw new Error('Unexpected response format');
    }
  } catch (err) {
    console.error('Fetch error:', err);
    throw err;
  }
}

// Example usage (replace with a real API endpoint)
//fetchData('https://api.example.com/data')
//  .then(data => console.log('Received data:', data))
//  .catch(err => console.error('Failed to fetch data:', err));

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், அதன் `status` பண்பின் அடிப்படையில் பதில் தரவை நாம் டிஸ்ட்ரக்சர் செய்கிறோம். ஸ்டேட்டஸ் `'success'` ஆக இருந்தால், பேலோடைப் பிரித்தெடுக்கிறோம். ஸ்டேட்டஸ் `'error'` ஆக இருந்தால், பிழைச் செய்தியைப் பிரித்தெடுக்கிறோம். இது வெவ்வேறு பதில் வகைகளை ஒரு கட்டமைக்கப்பட்ட மற்றும் படிக்கக்கூடிய வழியில் கையாள நம்மை அனுமதிக்கிறது.

பயனர் உள்ளீட்டைச் செயலாக்குதல்

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

            
function processCommand(command) {
  const [action, ...args] = command.split(' ');

  switch (action) {
    case 'CREATE':
      const [type, name] = args;
      console.log(`Creating ${type} with name ${name}`);
      break;
    case 'DELETE':
      const [id] = args;
      console.log(`Deleting item with ID ${id}`);
      break;
    case 'UPDATE':
      const [id, property, value] = args;
      console.log(`Updating item with ID ${id}, property ${property} to ${value}`);
      break;
    default:
      console.log(`Unknown command: ${action}`);
  }
}

processCommand('CREATE user John');
processCommand('DELETE 123');
processCommand('UPDATE 456 name Jane');
processCommand('INVALID_COMMAND');

            

              
                Copy
              
            
          

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

конஃபிகரேஷன் ஆப்ஜெக்ட்களுடன் வேலை செய்தல்

конஃபிகரேஷன் ஆப்ஜெக்ட்கள் பெரும்பாலும் விருப்பப் பண்புகளைக் கொண்டிருக்கும். இயல்புநிலை மதிப்புகளுடன் டிஸ்ட்ரக்சரிங் இந்தச் சூழ்நிலைகளை நேர்த்தியாகக் கையாள அனுமதிக்கிறது:

            
function createServer(config) {
  const { port = 8080, host = 'localhost', timeout = 30 } = config;

  console.log(`Starting server on ${host}:${port} with timeout ${timeout} seconds.`);
  // ... server creation logic
}

createServer({}); // Uses default values
createServer({ port: 9000 }); // Overrides port
createServer({ host: 'api.example.com', timeout: 60 }); // Overrides host and timeout

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `port`, `host`, மற்றும் `timeout` பண்புகள் இயல்புநிலை மதிப்புகளைக் கொண்டுள்ளன. இந்தப் பண்புகள் `config` ஆப்ஜெக்டில் வழங்கப்படாவிட்டால், இயல்புநிலை மதிப்புகள் பயன்படுத்தப்படும். இது சர்வர் உருவாக்கும் தர்க்கத்தை எளிதாக்குகிறது மற்றும் அதை மேலும் வலுவானதாக ஆக்குகிறது.

டிஸ்ட்ரக்சரிங் மற்றும் கார்டுகளுடன் பேட்டர்ன் மேட்சிங்கின் நன்மைகள்

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

வரம்புகள்

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

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

மாற்று வழிகள் மற்றும் லைப்ரரிகள்

பல லைப்ரரிகள் ஜாவாஸ்கிரிப்டுக்கு மிகவும் விரிவான பேட்டர்ன் மேட்சிங் திறன்களைக் கொண்டுவர நோக்கமாகக் கொண்டுள்ளன. இந்த லைப்ரரிகள் பெரும்பாலும் மிகவும் வெளிப்படையான சிண்டாக்ஸ் மற்றும் முழுமையான சோதனை போன்ற அம்சங்களை வழங்குகின்றன.

• ts-pattern (டைப்ஸ்கிரிப்ட்): டைப்ஸ்கிரிப்ட்டுக்கான ஒரு பிரபலமான பேட்டர்ன் மேட்சிங் லைப்ரரி, சக்திவாய்ந்த மற்றும் வகை-பாதுகாப்பான பேட்டர்ன் மேட்சிங்கை வழங்குகிறது.
• MatchaJS: மிகவும் அறிவிப்பு ரீதியான பேட்டர்ன் மேட்சிங் சிண்டாக்ஸை வழங்கும் ஒரு ஜாவாஸ்கிரிப்ட் லைப்ரரி.

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

முடிவுரை

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