ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್: ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ. ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, ಡೆವಲಪರ್‌ಗಳು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ OR ಆಪರೇಟರ್ (||) ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರು. ಆದಾಗ್ಯೂ, ECMAScript 2020 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ (??), ವಿಶೇಷವಾಗಿ null ಅಥವಾ undefined ಮೌಲ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ ನಿಯೋಜನೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ಹೆಚ್ಚು ನಿಖರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್‌ನ ಆಳವಾದ ವಿವರಣೆ, ಅದರ ಸಿಂಟ್ಯಾಕ್ಸ್, ಕಾರ್ಯವಿಧಾನ, OR ಆಪರೇಟರ್‌ನಿಂದ ವ್ಯತ್ಯಾಸಗಳು, ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಎಂದರೇನು?

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ (??) ಒಂದು ತಾರ್ಕಿಕ ಆಪರೇಟರ್ ಆಗಿದ್ದು, ಅದರ ಎಡಭಾಗದ ಆಪರಾಂಡ್ null ಅಥವಾ undefined ಆಗಿದ್ದರೆ, ಅದು ತನ್ನ ಬಲಭಾಗದ ಆಪರಾಂಡ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು ತನ್ನ ಎಡಭಾಗದ ಆಪರಾಂಡ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಒಂದು ವೇರಿಯೇಬಲ್ ಕಟ್ಟುನಿಟ್ಟಾಗಿ null ಅಥವಾ undefined ಆಗಿದ್ದಾಗ ಮಾತ್ರ ಇದು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ನೇರವಾಗಿದೆ:

leftOperand ?? rightOperand

ಇಲ್ಲಿ, leftOperand ನೀವು null ಅಥವಾ undefined ಗಾಗಿ ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ವೇರಿಯೇಬಲ್ ಅಥವಾ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಆಗಿದೆ, ಮತ್ತು leftOperand ನಿಜವಾಗಿಯೂ null ಅಥವಾ undefined ಆಗಿದ್ದರೆ, ನೀವು ನಿಯೋಜಿಸಲು ಬಯಸುವ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ rightOperand ಆಗಿದೆ.

ಉದಾಹರಣೆ

ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

const username = null ?? "Guest";
console.log(username); // ಔಟ್‌ಪುಟ್: Guest

const age = undefined ?? 25;
console.log(age); // ಔಟ್‌ಪುಟ್: 25

const city = "London" ?? "Unknown";
console.log(city); // ಔಟ್‌ಪುಟ್: London

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, username ಗೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ "Guest" ಅನ್ನು ನಿಯೋಜಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಅದು ಆರಂಭದಲ್ಲಿ null ಆಗಿದೆ. ಹಾಗೆಯೇ, age ಗೆ 25 ಅನ್ನು ನಿಯೋಜಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಅದು undefined ನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, city ತನ್ನ ಮೂಲ ಮೌಲ್ಯ "London" ಅನ್ನು ಉಳಿಸಿಕೊಂಡಿದೆ, ಏಕೆಂದರೆ ಅದು null ಅಥವಾ undefined ಅಲ್ಲ.

ನಲಿಶ್ ಮತ್ತು ಫಾಲ್ಸಿ ಮೌಲ್ಯಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಲಿಶ್ ಮತ್ತು ಫಾಲ್ಸಿ ಮೌಲ್ಯಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ನಲಿಶ್ ಮೌಲ್ಯವೆಂದರೆ null ಅಥವಾ undefined. ಫಾಲ್ಸಿ ಮೌಲ್ಯವೆಂದರೆ ಬೂಲಿಯನ್ ಸಂದರ್ಭದಲ್ಲಿ ಸುಳ್ಳು ಎಂದು ಪರಿಗಣಿಸಲಾಗುವ ಮೌಲ್ಯ. ಫಾಲ್ಸಿ ಮೌಲ್ಯಗಳು ಇವುಗಳನ್ನು ಒಳಗೊಂಡಿವೆ:

• null
• undefined
• 0 (ಶೂನ್ಯ)
• NaN (ಸಂಖ್ಯೆಯಲ್ಲ)
• '' (ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್)
• false

ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಕೇವಲ null ಅಥವಾ undefined ಅನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸುತ್ತದೆ, ಆದರೆ OR ಆಪರೇಟರ್ (||) ಯಾವುದೇ ಫಾಲ್ಸಿ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.

?? ಮತ್ತು || ನಡುವಿನ ವ್ಯತ್ಯಾಸ

OR ಆಪರೇಟರ್ (||) ಒಂದು ತಾರ್ಕಿಕ OR ಆಪರೇಟರ್ ಆಗಿದ್ದು, ಎಡಭಾಗದ ಆಪರಾಂಡ್ ಫಾಲ್ಸಿ ಆಗಿದ್ದರೆ ಬಲಭಾಗದ ಆಪರಾಂಡ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದನ್ನು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು ಬಳಸಬಹುದಾದರೂ, 0 ಅಥವಾ ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್‌ನಂತಹ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಉದಾಹರಣೆ: || ನ ಅಪಾಯಗಳು

const quantity = 0 || 10; // quantity ಇಲ್ಲದಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ 10 ಎಂದು ನಾವು ಬಯಸುತ್ತೇವೆ
console.log(quantity); // ಔಟ್‌ಪುಟ್: 10 (ಅನಿರೀಕ್ಷಿತ!) ಏಕೆಂದರೆ 0 ಫಾಲ್ಸಿ ಆಗಿದೆ

const text = '' || 'Default Text'; // text ಇಲ್ಲದಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಪಠ್ಯವನ್ನು ನಾವು ಬಯಸುತ್ತೇವೆ
console.log(text); // ಔಟ್‌ಪುಟ್: Default Text (ಅನಿರೀಕ್ಷಿತ!) ಏಕೆಂದರೆ '' ಫಾಲ್ಸಿ ಆಗಿದೆ

ಮೊದಲ ಉದಾಹರಣೆಯಲ್ಲಿ, quantity ಇಲ್ಲದಿದ್ದರೆ (null ಅಥವಾ undefined) ಮಾತ್ರ ಡೀಫಾಲ್ಟ್ 10 ಅನ್ನು ನಿಯೋಜಿಸಲು ನಾವು ಉದ್ದೇಶಿಸಿದ್ದೇವೆ. ಆದಾಗ್ಯೂ, 0 ಒಂದು ಫಾಲ್ಸಿ ಮೌಲ್ಯವಾಗಿರುವುದರಿಂದ, OR ಆಪರೇಟರ್ ತಪ್ಪಾಗಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿದೆ. ಅಂತೆಯೇ, ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಇದ್ದರೂ (ಆದರೆ ಖಾಲಿಯಾಗಿದ್ದರೂ) ಡೀಫಾಲ್ಟ್ ಪಠ್ಯವನ್ನು ತೋರಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ.

ನಿಖರತೆಗಾಗಿ ?? ಬಳಸುವುದು

ಹಿಂದಿನ ಉದಾಹರಣೆಯನ್ನು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಬಳಸಿ ಪುನಃ ಬರೆಯೋಣ:

const quantity = 0 ?? 10;
console.log(quantity); // ಔಟ್‌ಪುಟ್: 0 (ಸರಿ!)

const text = '' ?? 'Default Text';
console.log(text); // ಔಟ್‌ಪುಟ್: '' (ಸರಿ!)

ಈಗ, ಔಟ್‌ಪುಟ್ ನಿರೀಕ್ಷೆಯಂತಿದೆ. ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಕೇವಲ null ಅಥವಾ undefined ಅನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ 0 ಮತ್ತು '' ಅನ್ನು ಮಾನ್ಯ ಮೌಲ್ಯಗಳಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಮೂಲ ಮೌಲ್ಯಗಳನ್ನು ಸಂರಕ್ಷಿಸಲಾಗುತ್ತದೆ.

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್‌ನ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಒಂದು ವೇರಿಯೇಬಲ್ ಕಟ್ಟುನಿಟ್ಟಾಗಿ null ಅಥವಾ undefined ಆಗಿದ್ದಾಗ ಮಾತ್ರ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಒದಗಿಸಬೇಕಾದ ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಉಪಯುಕ್ತವಾಗಿದೆ. ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳಿವೆ:

1. ಐಚ್ಛಿಕ ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ನಿಭಾಯಿಸುವುದು

ಐಚ್ಛಿಕ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ ಫಂಕ್ಷನ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡುವಾಗ, ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಒದಗಿಸದಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಒದಗಿಸಲು ನೀವು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.

function greet(name, greeting) {
  const userName = name ?? "User";
  const userGreeting = greeting ?? "Hello";
  console.log(`${userGreeting}, ${userName}!`);
}

greet(); // ಔಟ್‌ಪುಟ್: Hello, User!
greet("Alice"); // ಔಟ್‌ಪುಟ್: Hello, Alice!
greet("Bob", "Greetings"); // ಔಟ್‌ಪುಟ್: Greetings, Bob!

2. ಡೀಫಾಲ್ಟ್ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿಸುವುದು

ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಕೆಲವು ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.

const config = {
  timeout: 5000,
  retries: 3
};

function fetchData(options) {
  const timeout = options.timeout ?? 10000; // 10 ಸೆಕೆಂಡುಗಳ ಡೀಫಾಲ್ಟ್ ಟೈಮ್‌ಔಟ್
  const retries = options.retries ?? 5; // ಡೀಫಾಲ್ಟ್ 5 ಪ್ರಯತ್ನಗಳು
  console.log(`Timeout: ${timeout}, Retries: ${retries}`);
}

fetchData(config); // ಔಟ್‌ಪುಟ್: Timeout: 5000, Retries: 3
fetchData({}); // ಔಟ್‌ಪುಟ್: Timeout: 10000, Retries: 5
fetchData({timeout:null, retries: undefined}); // ಔಟ್‌ಪುಟ್: Timeout: 10000, Retries: 5

3. ನೆಸ್ಟೆಡ್ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು

ನೆಸ್ಟೆಡ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ, ಮಧ್ಯಂತರ ಪ್ರಾಪರ್ಟಿಗಳಲ್ಲಿ ಯಾವುದಾದರೂ null ಅಥವಾ undefined ಆಗಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಒದಗಿಸಲು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಐಚ್ಛಿಕ ಚೈನಿಂಗ್ (?.) ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು.

const user = {
  profile: {
    address: {
      city: "New York"
    }
  }
};

const cityName = user?.profile?.address?.city ?? "Unknown";
console.log(cityName); // ಔಟ್‌ಪುಟ್: New York

const unknownUser = {};
const unknownCityName = unknownUser?.profile?.address?.city ?? "Unknown";
console.log(unknownCityName); // ಔಟ್‌ಪುಟ್: Unknown

4. APIಗಳು ಮತ್ತು ಬಾಹ್ಯ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

APIಗಳಿಂದ ಅಥವಾ ಬಾಹ್ಯ ಮೂಲಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವಾಗ, ಕೆಲವು ಡೇಟಾ ಫೀಲ್ಡ್‌ಗಳು ಕಾಣೆಯಾಗಿದ್ದರೆ ಅಥವಾ null ಅಥವಾ undefined ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಒದಗಿಸಲು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು. ವಿವಿಧ ಪ್ರದೇಶಗಳಿಂದ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಕೆಲವು ಪ್ರದೇಶಗಳು ತಮ್ಮ ಬಳಕೆದಾರರ ಡೇಟಾದಲ್ಲಿ `country` ಫೀಲ್ಡ್ ಅನ್ನು ಸೇರಿಸದೇ ಇರಬಹುದು ಎಂದು ಭಾವಿಸೋಣ.

async function getUserData(userId) {
  try {
    const response = await fetch(`https://api.example.com/users/${userId}`);
    const data = await response.json();
    const country = data.country ?? "Unknown Country";
    const timezone = data.timezone ?? "UTC";
    console.log(`User is from: ${country}, Timezone: ${timezone}`);
  } catch (error) {
    console.error("Error fetching user data:", error);
  }
}

// ವಿಭಿನ್ನ API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡುವುದು:
const userWithCountry = { name: "John", country: "USA", timezone: "EST" };
const userWithoutCountry = { name: "Jane", timezone: "GMT" };

// ಇದನ್ನು ಪರೀಕ್ಷಿಸಲು, ನಿಮಗೆ ನಿಜವಾದ API ಅಥವಾ ಮಾಕ್ ಫೆಚ್ ಅಗತ್ಯವಿದೆ.
// ಪ್ರದರ್ಶನ ಉದ್ದೇಶಗಳಿಗಾಗಿ, ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡೋಣ:
global.fetch = async (url) => {
    if (url.includes("123")) {
        return { json: async () => userWithCountry };
    } else if (url.includes("456")) {
        return { json: async () => userWithoutCountry };
    }
    throw new Error("Unexpected URL");
};

getUserData(123); // ಔಟ್‌ಪುಟ್: User is from: USA, Timezone: EST
getUserData(456); // ಔಟ್‌ಪುಟ್: User is from: Unknown Country, Timezone: GMT

ಆಪರೇಟರ್ ಪ್ರಾಶಸ್ತ್ಯ (Operator Precedence)

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ತುಲನಾತ್ಮಕವಾಗಿ ಕಡಿಮೆ ಆಪರೇಟರ್ ಪ್ರಾಶಸ್ತ್ಯವನ್ನು ಹೊಂದಿದೆ. ಇದು OR (||) ಮತ್ತು AND (&&) ಆಪರೇಟರ್‌ಗಳಿಗಿಂತ ಕಡಿಮೆಯಾಗಿದೆ. ಆದ್ದರಿಂದ, ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಇತರ ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವಾಗ, ಕಾರ್ಯಾಚರಣೆಗಳ ಕ್ರಮವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಪ್ಯಾರಾಂಥಿಸಿಸ್ (ಆವರಣ) ಬಳಸುವುದು ಅತ್ಯಗತ್ಯ. ಹಾಗೆ ಮಾಡಲು ವಿಫಲವಾದರೆ ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳು ಅಥವಾ ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಉದಾಹರಣೆ: ಸ್ಪಷ್ಟತೆಗಾಗಿ ಪ್ಯಾರಾಂಥಿಸಿಸ್ ಬಳಸುವುದು

// ಪ್ಯಾರಾಂಥಿಸಿಸ್ ಇಲ್ಲದೆ (ಸಿಂಟ್ಯಾಕ್ಸ್‌ ಎರರ್)
// const result = false || null ?? "Default"; // SyntaxError: Unexpected token '??'

// ಪ್ಯಾರಾಂಥಿಸಿಸ್‌ನೊಂದಿಗೆ (ಸರಿ)
const result = false || (null ?? "Default");
console.log(result); // ಔಟ್‌ಪುಟ್: Default

const anotherResult = (false || null) ?? "Default";
console.log(anotherResult); // ಔಟ್‌ಪುಟ್: null

ಮೊದಲ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪ್ಯಾರಾಂಥಿಸಿಸ್‌ನ ಕೊರತೆಯು SyntaxError ಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಉದ್ದೇಶಿತ ಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಪ್ಯಾರಾಂಥಿಸಿಸ್ ಸೇರಿಸುವ ಮೂಲಕ, ನಾವು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಮೊದಲು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಇಂಜಿನ್‌ಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳುತ್ತೇವೆ. ಎರಡನೇ ಉದಾಹರಣೆ ಮಾನ್ಯವಾಗಿದೆ; ಆದಾಗ್ಯೂ, ಔಟ್‌ಪುಟ್ ವಿಭಿನ್ನವಾಗಿದೆ ಏಕೆಂದರೆ `||` ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಮೊದಲು ಮೌಲ್ಯಮಾಪನಗೊಳ್ಳುತ್ತದೆ.

ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ (??) ತುಲನಾತ್ಮಕವಾಗಿ ಹೊಸ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ, ಆದ್ದರಿಂದ ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಗಣಿಸುವುದು ಬಹಳ ಮುಖ್ಯ, ವಿಶೇಷವಾಗಿ ನೀವು ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳನ್ನು ಗುರಿಯಾಗಿಸಿಕೊಂಡಿದ್ದರೆ. ಹೆಚ್ಚಿನ ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ, ಅವುಗಳೆಂದರೆ:

• Chrome 80+
• Firefox 72+
• Safari 13.1+
• Edge 80+
• Node.js 14+

ನೀವು ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸಬೇಕಾದರೆ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಹೊಂದಾಣಿಕೆಯ ಆವೃತ್ತಿಗೆ ಪರಿವರ್ತಿಸಲು ನೀವು Babel ನಂತಹ ಟ್ರಾನ್ಸ್‌ಪೈಲರ್ ಅನ್ನು ಬಳಸಬಹುದು. Babel ?? ಆಪರೇಟರ್ ಅನ್ನು ಹಳೆಯ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಸಮಾನವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು ಇಲ್ಲಿ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳಿವೆ:

• ನಲಿಶ್ ಚೆಕ್‌ಗಳಿಗಾಗಿ ?? ಬಳಸಿ: ಒಂದು ವೇರಿಯೇಬಲ್ null ಅಥವಾ undefined ಆಗಿದ್ದಾಗ ಮಾತ್ರ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಒದಗಿಸಲು ನೀವು ನಿರ್ದಿಷ್ಟವಾಗಿ ಬಯಸಿದಾಗ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ (??) ಅನ್ನು ಬಳಸಿ.
• ಸಂಕೀರ್ಣ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಗಾಗಿ ಪ್ಯಾರಾಂಥಿಸಿಸ್ ಬಳಸಿ: ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಇತರ ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವಾಗ, ಕಾರ್ಯಾಚರಣೆಗಳ ಕ್ರಮವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಪ್ಯಾರಾಂಥಿಸಿಸ್ ಬಳಸಿ.
• ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಗಣಿಸಿ: ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಅಗತ್ಯವಿದ್ದರೆ ಟ್ರಾನ್ಸ್‌ಪೈಲರ್ ಬಳಸಿ.
• ಸ್ಥಿರವಾಗಿ ಬಳಸಿ: ಪ್ರಾಜೆಕ್ಟ್‌ನಾದ್ಯಂತ ಹೆಚ್ಚು ನಿರೀಕ್ಷಿತ ಕೋಡಿಂಗ್ ಶೈಲಿಗಾಗಿ ಸೂಕ್ತವಾದಲ್ಲೆಲ್ಲಾ ?? ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ.
• ಐಚ್ಛಿಕ ಚೈನಿಂಗ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: ನೆಸ್ಟೆಡ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಸುರಕ್ಷಿತವಾಗಿ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು ?? ಅನ್ನು ಐಚ್ಛಿಕ ಚೈನಿಂಗ್ ?. ನೊಂದಿಗೆ ಬಳಸಿ.

ಜಾಗತಿಕ ಪರಿಗಣನೆಗಳು

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ ನಿಯೋಜನೆಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಈ ಕೆಳಗಿನ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಸ್ಥಳೀಕರಣ (Localization): ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಬಳಕೆದಾರರ ಭಾಷೆ ಅಥವಾ ಪ್ರದೇಶದ ಆಧಾರದ ಮೇಲೆ ಸ್ಥಳೀಕರಿಸಬೇಕಾಗಬಹುದು. ಉದಾಹರಣೆಗೆ, ಡೀಫಾಲ್ಟ್ ಕರೆನ್ಸಿ ಚಿಹ್ನೆ ಅಥವಾ ದಿನಾಂಕ ಸ್ವರೂಪ.
• ಸಾಂಸ್ಕೃತಿಕ ನಿಯಮಗಳು: ಕೆಲವು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಸಾಂಸ್ಕೃತಿಕ ನಿಯಮಗಳ ಆಧಾರದ ಮೇಲೆ ಸರಿಹೊಂದಿಸಬೇಕಾಗಬಹುದು. ಉದಾಹರಣೆಗೆ, ವಿಭಿನ್ನ ಸಂಸ್ಕೃತಿಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಶುಭಾಶಯ ಸಂದೇಶವು ವಿಭಿನ್ನವಾಗಿರಬೇಕಾಗಬಹುದು.
• ಪ್ರವೇಶಿಸುವಿಕೆ (Accessibility): ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳು ಅಂಗವಿಕಲ ಬಳಕೆದಾರರಿಗೆ ಪ್ರವೇಶಿಸಬಲ್ಲವು ಮತ್ತು ಅರ್ಥವಾಗುವಂತಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್‌ಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳಿಗಾಗಿ ಸ್ಪಷ್ಟ ಮತ್ತು ವಿವರಣಾತ್ಮಕ ಲೇಬಲ್‌ಗಳನ್ನು ಒದಗಿಸಿ.
• ಟೈಮ್‌ಝೋನ್‌ಗಳು ಮತ್ತು ದಿನಾಂಕಗಳು: ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳಲ್ಲಿನ ಬಳಕೆದಾರರಿಗೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳು ಸರಿಯಾಗಿ ಪ್ರದರ್ಶನಗೊಳ್ಳುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸೂಕ್ತವಾದ ಟೈಮ್‌ಝೋನ್‌ಗಳು ಮತ್ತು ದಿನಾಂಕ ಸ್ವರೂಪಗಳನ್ನು ಬಳಸಿ.

ಉದಾಹರಣೆ: ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್‌ನೊಂದಿಗೆ ಸ್ಥಳೀಕರಣ

ಬಳಕೆದಾರರ ಲೊಕೇಲ್ ಆಧರಿಸಿ ನೀವು ವಿಭಿನ್ನ ಭಾಷೆಗಳಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಸ್ವಾಗತ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ಸ್ಥಳೀಕರಿಸಿದ ಸಂದೇಶ ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೆ ಡೀಫಾಲ್ಟ್ ಸಂದೇಶವನ್ನು ಒದಗಿಸಲು ನೀವು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು.

function getWelcomeMessage(locale) {
  const localizedMessages = {
    en: "Welcome!",
    fr: "Bienvenue !",
    de: "Willkommen!"
  };

  const message = localizedMessages[locale] ?? "Welcome!"; // ಲೊಕೇಲ್ ಕಂಡುಬರದಿದ್ದರೆ ಇಂಗ್ಲಿಷ್‌ಗೆ ಡೀಫಾಲ್ಟ್ ಮಾಡಿ
  return message;
}

console.log(getWelcomeMessage("fr")); // ಔಟ್‌ಪುಟ್: Bienvenue !
console.log(getWelcomeMessage("es")); // ಔಟ್‌ಪುಟ್: Welcome! (ಇಂಗ್ಲಿಷ್‌ಗೆ ಡೀಫಾಲ್ಟ್ ಆಗುತ್ತಿದೆ)

ತೀರ್ಮಾನ

ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ (??) ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಗೆ ಒಂದು ಮೌಲ್ಯಯುತ ಸೇರ್ಪಡೆಯಾಗಿದೆ. ಇದು OR ಆಪರೇಟರ್‌ಗೆ (||) ಹೋಲಿಸಿದರೆ, ವಿಶೇಷವಾಗಿ 0 ಅಥವಾ ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳಂತಹ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು ಹೆಚ್ಚು ನಿಖರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅದರ ಸಿಂಟ್ಯಾಕ್ಸ್, ಕಾರ್ಯವಿಧಾನ ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ ನಿಯೋಜನೆಗಳನ್ನು ನಿಖರವಾಗಿ ನಿಭಾಯಿಸುವ ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು. ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುವಾಗ ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ, ಆಪರೇಟರ್ ಪ್ರಾಶಸ್ತ್ಯ ಮತ್ತು ಜಾಗತಿಕ ಪರಿಗಣನೆಗಳನ್ನು ನೆನಪಿಡಿ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ವಿವರಿಸಲಾದ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನ ಗುಣಮಟ್ಟ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸಲು ನೀವು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳಬಹುದು, ಅದನ್ನು ಹೆಚ್ಚು ದೃಢ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗಿಸಬಹುದು. ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಯಾವಾಗಲೂ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ನಿರ್ವಹಣೆಗೆ ಆದ್ಯತೆ ನೀಡುವುದನ್ನು ನೆನಪಿಡಿ, ಮತ್ತು ಈ ಗುರಿಗಳನ್ನು ಸಾಧಿಸಲು ನಲಿಶ್ ಕೋಲೆಸಿಂಗ್ ಆಪರೇಟರ್ ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಬಹುದು.