ஜாவாஸ்கிரிப்ட் பேட்டர்ன் மேட்சிங்: 'When' மூலம் நிபந்தனை பேட்டர்ன் மதிப்பீடு

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

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

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

ஜாவாஸ்கிரிப்டில், பேட்டர்ன் மேட்சிங் பொதுவாக 'ts-pattern' (டைப்ஸ்கிரிப்ட்டிற்கு) போன்ற லைப்ரரிகள் மூலமாகவோ அல்லது தற்போது ECMAScript-க்காக பரிசீலனையில் உள்ள பேட்டர்ன் மேட்சிங் முன்மொழிவு போன்ற முன்மொழிவுகள் மூலமாகவோ அடையப்படுகிறது.

'When'-இன் சக்தி: நிபந்தனை பேட்டர்ன் மதிப்பீடு

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

ஒரு உலகளாவிய இ-காமர்ஸ் தளத்திலிருந்து பயனர் தரவைச் செயலாக்கும் ஒரு சூழ்நிலையை கற்பனை செய்து பாருங்கள். பயனரின் இருப்பிடம் மற்றும் செலவழிக்கும் பழக்கவழக்கங்களின் அடிப்படையில் வெவ்வேறு தள்ளுபடிகளைப் பயன்படுத்த நீங்கள் விரும்பலாம். 'when' இல்லாமல், உங்கள் பேட்டர்ன் மேட்சிங் வழக்குகளுக்குள் நெஸ்டட் `if` கூற்றுகளுடன் முடிவடையலாம், இது குறியீட்டைப் படிப்பதை கடினமாக்குகிறது மற்றும் பராமரிப்பதை கடினமாக்குகிறது. 'When' இந்த நிபந்தனைகளை பேட்டர்னுக்குள்ளேயே நேரடியாக வெளிப்படுத்த உங்களை அனுமதிக்கிறது.

விளக்க எடுத்துக்காட்டுகள்

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

எடுத்துக்காட்டு 1: 'When' உடன் அடிப்படை வகை சரிபார்ப்பு

ஒரு சிஸ்டம் மூலம் பெறப்பட்ட பல்வேறு வகையான செய்திகளைக் கையாள விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம்:

function processMessage(message) {
  match(message)
    .with({ type: "text", content: P.string }, (msg) => {
      console.log(`Processing text message: ${msg.content}`);
    })
    .with({ type: "image", url: P.string }, (msg) => {
      console.log(`Processing image message: ${msg.url}`);
    })
    .otherwise(() => {
      console.log("Unknown message type");
    });
}

processMessage({ type: "text", content: "Hello, world!" }); // வெளியீடு: உரை செய்தி செயலாக்கப்படுகிறது: Hello, world!
processMessage({ type: "image", url: "https://example.com/image.jpg" }); // வெளியீடு: படச் செய்தி செயலாக்கப்படுகிறது: https://example.com/image.jpg
processMessage({ type: "audio", file: "audio.mp3" }); // வெளியீடு: அறியப்படாத செய்தி வகை

இந்த அடிப்படை எடுத்துக்காட்டில், `type` ப்ராப்பர்ட்டி மற்றும் `content` அல்லது `url` போன்ற பிற ப்ராப்பர்ட்டிகள் இருப்பதை அடிப்படையாகக் கொண்டு பொருத்துகிறோம். `P.string` என்பது டேட்டா வகையைச் சரிபார்க்கும் ஒரு பிளேஸ்ஹோல்டர் ஆகும்.

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

இப்போது, பயனரின் இருப்பிடம் மற்றும் செலவினங்களின் அடிப்படையில் தள்ளுபடிகளைக் கையாள 'when' கிளாஸைச் சேர்ப்போம்:

function calculateDiscount(user) {
  match(user)
    .with(
      {
        country: "USA",
        spending: P.number.gt(100) //P.number.gt(100) செலவு 100-ஐ விட அதிகமாக உள்ளதா என சரிபார்க்கிறது
      },
      () => {
        console.log("Applying a 10% discount for US users spending over $100");
        return 0.1;
      }
    )
    .with(
      {
        country: "Canada",
        spending: P.number.gt(50)
      },
      () => {
        console.log("Applying a 5% discount for Canadian users spending over $50");
        return 0.05;
      }
    )
    .with({ country: P.string }, (u) => {
      console.log(`No special discount for users from ${u.country}`);
      return 0;
    })
    .otherwise(() => {
      console.log("No discount applied.");
      return 0;
    });
}

const user1 = { country: "USA", spending: 150 };
const user2 = { country: "Canada", spending: 75 };
const user3 = { country: "UK", spending: 200 };

console.log(`Discount for user1: ${calculateDiscount(user1)}`); // வெளியீடு: $100-க்கு மேல் செலவழிக்கும் அமெரிக்க பயனர்களுக்கு 10% தள்ளுபடி பயன்படுத்தப்படுகிறது; பயனர்1-க்கான தள்ளுபடி: 0.1
console.log(`Discount for user2: ${calculateDiscount(user2)}`); // வெளியீடு: $50-க்கு மேல் செலவழிக்கும் கனேடிய பயனர்களுக்கு 5% தள்ளுபடி பயன்படுத்தப்படுகிறது; பயனர்2-க்கான தள்ளுபடி: 0.05
console.log(`Discount for user3: ${calculateDiscount(user3)}`); // வெளியீடு: இங்கிலாந்து பயனர்களுக்கு சிறப்பு தள்ளுபடி இல்லை; பயனர்3-க்கான தள்ளுபடி: 0

இந்த எடுத்துக்காட்டில், 'when' கிளாஸ் (`with` செயல்பாட்டிற்குள் மறைமுகமாகக் குறிப்பிடப்பட்டுள்ளது) `spending` ப்ராப்பர்ட்டியில் நிபந்தனைகளைக் குறிப்பிட அனுமதிக்கிறது. தள்ளுபடியைப் பயன்படுத்துவதற்கு முன்பு செலவு ஒரு குறிப்பிட்ட வரம்புக்கு மேல் உள்ளதா என்பதை நாம் சரிபார்க்கலாம். இது ஒவ்வொரு வழக்கிலும் நெஸ்டட் `if` கூற்றுகளின் தேவையை நீக்குகிறது.

எடுத்துக்காட்டு 3: மாற்று விகிதங்களுடன் வெவ்வேறு நாணயங்களைக் கையாளுதல்

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

function processTransaction(transaction) {
  match(transaction)
    .with(
      { currency: "USD", amount: P.number.gt(0) },
      () => {
        console.log(`Processing USD transaction: ${transaction.amount}`);
        return transaction.amount;
      }
    )
    .with(
      { currency: "EUR", amount: P.number.gt(0) },
      () => {
        const amountInUSD = transaction.amount * 1.1; // 1 EUR = 1.1 USD என வைத்துக்கொள்வோம்
        console.log(`Processing EUR transaction: ${transaction.amount} EUR (converted to ${amountInUSD} USD)`);
        return amountInUSD;
      }
    )
    .with(
      { currency: "GBP", amount: P.number.gt(0) },
      () => {
        const amountInUSD = transaction.amount * 1.3; // 1 GBP = 1.3 USD என வைத்துக்கொள்வோம்
        console.log(`Processing GBP transaction: ${transaction.amount} GBP (converted to ${amountInUSD} USD)`);
        return amountInUSD;
      }
    )
    .otherwise(() => {
      console.log("Unsupported currency or invalid transaction.");
      return 0;
    });
}

const transaction1 = { currency: "USD", amount: 100 };
const transaction2 = { currency: "EUR", amount: 50 };
const transaction3 = { currency: "JPY", amount: 10000 };

console.log(`Transaction 1 USD Value: ${processTransaction(transaction1)}`); // வெளியீடு: USD பரிவர்த்தனை செயலாக்கப்படுகிறது: 100; பரிவர்த்தனை 1 USD மதிப்பு: 100
console.log(`Transaction 2 USD Value: ${processTransaction(transaction2)}`); // வெளியீடு: EUR பரிவர்த்தனை செயலாக்கப்படுகிறது: 50 EUR (55 USD ஆக மாற்றப்பட்டது); பரிவர்த்தனை 2 USD மதிப்பு: 55
console.log(`Transaction 3 USD Value: ${processTransaction(transaction3)}`); // வெளியீடு: ஆதரிக்கப்படாத நாணயம் அல்லது செல்லாத பரிவர்த்தனை.; பரிவர்த்தனை 3 USD மதிப்பு: 0

இந்த எடுத்துக்காட்டு நேரடியாக 'when' செயல்பாட்டைப் பயன்படுத்தாவிட்டாலும், பொதுவாக பேட்டர்ன் மேட்சிங் எவ்வாறு வெவ்வேறு சூழ்நிலைகளைக் (வெவ்வேறு நாணயங்கள்) கையாளவும் மற்றும் அதற்கேற்ற தர்க்கத்தை (மாற்று விகித மாற்றங்கள்) பயன்படுத்தவும் முடியும் என்பதைக் காட்டுகிறது. நிபந்தனைகளை மேலும் செம்மைப்படுத்த 'when' கிளாஸைச் சேர்க்கலாம். உதாரணமாக, பயனரின் இருப்பிடம் வட அமெரிக்காவில் இருந்தால் மட்டுமே EUR-ஐ USD ஆக மாற்றலாம், இல்லையெனில், EUR-ஐ CAD ஆக மாற்றலாம்.

பேட்டர்ன் மேட்சிங்கில் 'When' பயன்படுத்துவதன் நன்மைகள்

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

கருத்தாய்வுகள் மற்றும் சிறந்த நடைமுறைகள்

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

நிஜ-உலக பயன்பாடுகள்

பேட்டர்ன் மேட்சிங் உடன் 'when' பல்வேறு நிஜ-உலக சூழ்நிலைகளில் பயன்படுத்தப்படலாம், அவற்றுள் சில:

• டேட்டா சரிபார்ப்பு: API கோரிக்கைகள் அல்லது பயனர் உள்ளீடு போன்ற உள்வரும் டேட்டாவின் அமைப்பு மற்றும் மதிப்புகளைச் சரிபார்த்தல்.
• ரூட்டிங்: URL அல்லது பிற கோரிக்கை அளவுருக்களின் அடிப்படையில் ரூட்டிங் தர்க்கத்தை செயல்படுத்துதல்.
• நிலை மேலாண்மை: பயன்பாட்டு நிலையை கணிக்கக்கூடிய மற்றும் பராமரிக்கக்கூடிய வகையில் நிர்வகித்தல்.
• கம்பைலர் கட்டுமானம்: பார்சர்கள் மற்றும் பிற கம்பைலர் கூறுகளை செயல்படுத்துதல்.
• AI மற்றும் மெஷின் லேர்னிங்: அம்சப் பிரித்தெடுத்தல் மற்றும் டேட்டா முன் செயலாக்கம்.
• கேம் டெவலப்மெண்ட்: வெவ்வேறு கேம் நிகழ்வுகள் மற்றும் வீரர் செயல்களைக் கையாளுதல்.

உதாரணமாக, ஒரு சர்வதேச வங்கி பயன்பாட்டைக் கவனியுங்கள். பேட்டர்ன் மேட்சிங் உடன் 'when' ஐப் பயன்படுத்தி, பரிவர்த்தனை தொடங்கும் நாடு, நாணயம், தொகை மற்றும் பரிவர்த்தனை வகை (எ.கா., டெபாசிட், திரும்பப் பெறுதல், பரிமாற்றம்) ஆகியவற்றின் அடிப்படையில் பரிவர்த்தனைகளை வித்தியாசமாகக் கையாளலாம். சில நாடுகளில் இருந்து தொடங்கும் அல்லது சில தொகைகளைத் தாண்டும் பரிவர்த்தனைகளுக்கு வெவ்வேறு ஒழுங்குமுறை தேவைகள் இருக்கலாம்.

முடிவுரை

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

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