Silent Errors
JavaScript அமைதியாக தோல்வியடையலாம்.
ஒரு அமைதியான பிழை உங்கள் நிரலை நிறுத்தாது. இயக்கம் தொடரும்.
அமைதியான பிழைகளுக்கான காரணம் வரலாற்று:
JavaScript இன் முதல் பதிப்பில் catch...try விதிவிலக்குகள் இல்லை.
குறிப்பு:
அமைதியான பிழைகள் விதிவிலக்குகளை வீசாது அல்லது இயக்கத்தை நிறுத்தாது, ஆனால் இன்னும் லாஜிக் பிழைகள், எதிர்பாராத நடத்தை அல்லது காணாமல் போக எளிதான தோல்விகளை ஏற்படுத்தும் பிரச்சினைகள்.
எடுத்துக்காட்டு
அமைதியான பிழைகள் உங்கள் நிரலை நிறுத்தாது.
let x = 1 / 0;கவனிக்க:
மேலே உள்ள குறியீடு Infinity மதிப்பை உருவாக்குகிறது, ஆனால் பிழையை வீசாது. இது ஒரு அமைதியான பிழையின் எடுத்துக்காட்டாகும்.
ஒதுக்கீடு, ஒப்பீடு அல்ல
let result = "Not Active.";
let isActive = false;
// ❌ ஒதுக்கீடு, ஒப்பீடு அல்ல
if (isActive = true) {
let result = "Active!";
}விளக்கம்
(isActive = true) isActive க்கு true ஐ ஒதுக்குகிறது, (isActive == true) உடன் சமத்தை சரிபார்க்காமல்.
அடுத்த வரி அமைதியாக இயங்குகிறது மற்றும் "Active!" என்று அச்சிடுகிறது, isActive false ஆக இருந்தாலும் கூட.
சரியான முறை:
ஒப்பீடு செய்ய === (கண்டிப்பான சமத்தன்மை) அல்லது == (சமத்தன்மை) ஆபரேட்டர்களைப் பயன்படுத்தவும்:
// சரியானது: கண்டிப்பான சமத்தன்மை
if (isActive === true) {
let result = "Active!";
}
// அல்லது இன்னும் சிறந்தது:
if (isActive) {
let result = "Active!";
}NaN உருவாக்கும் அமைதியான பிழைகள்
தோல்வியடையும் பல எண் செயல்பாடுகள் NaN (விதிவிலக்கு அல்ல) உருவாக்குகின்றன.
JavaScript செயலிழக்காது. இது அமைதியாக உங்களுக்கு NaN தருகிறது மற்றும் தொடர்கிறது.
// NaN - பிழை இல்லை, தவறான தரவு மட்டுமே
const result = parseInt("abc");மேலும் NaN உருவாக்கும் எடுத்துக்காட்டுகள்:
// வெற்று சரத்திலிருந்து எண்ணாக மாற்றுதல்
let num1 = Number(""); // 0 (அமைதியானது!)
let num2 = parseInt(""); // NaN
let num3 = Number(" "); // 0 (அமைதியானது!)
// வரையறுக்கப்படாத மதிப்புகளுடன் செயல்பாடுகள்
let value1 = undefined + 5; // NaN
let value2 = null * 10; // 0 (அமைதியானது!)
// தவறான கணித செயல்பாடுகள்
let calc1 = Math.sqrt(-1); // NaN
let calc2 = 0 / 0; // NaN
let calc3 = Infinity / Infinity; // NaNNaN சோதனை:
NaN சிறப்பு மதிப்பு, எப்போதும் தனக்குத் தானே சமமாக இல்லை. NaN ஐ சோதிக்க isNaN() அல்லது Number.isNaN() பயன்படுத்தவும்:
let result = parseInt("abc");
console.log(isNaN(result)); // true
console.log(Number.isNaN(result)); // true
console.log(result === NaN); // false (எப்போதும் false!)இல்லாத பண்புகளை அணுகுதல்
இல்லாத பண்புகளை அணுகுவது அமைதியாக undefined ஐ வழங்குகிறது.
const user = {};
let result = user.name;மேலும் எடுத்துக்காட்டுகள்:
// பல அடுக்கு பண்பு அணுகல்
const data = { user: { profile: {} } };
let name = data.user.profile.name; // undefined
let age = data.user.profile?.age; // optional chaining: undefined
// வரிசை அணுகல்
const arr = [1, 2, 3];
let item = arr[10]; // undefined
let length = arr.length; // 3
let nonexistent = arr.nonexistentProperty; // undefined
// செயல்பாட்டு அளவுருக்கள்
function greet(name) {
console.log("Hello, " + name); // name undefined ஆக இருக்கலாம்
}
greet(); // "Hello, undefined"பாதுகாப்பான பண்பு அணுகல்:
Optional chaining (?.) மற்றும் nullish coalescing (??) ஆபரேட்டர்களைப் பயன்படுத்தி அமைதியான பிழைகளைத் தவிர்க்கவும்:
// Optional chaining
let userName = user?.profile?.name; // undefined if any property is missing
// Nullish coalescing
let displayName = user?.name ?? "Guest"; // "Guest" if user.name is null/undefined
// Default parameters
function getUser(id = 0) {
return users.find(u => u.id === id) ?? {name: "Unknown"};
}வகை மாற்றம் அமைதியான பிழைகள்
JavaScript ஆபரேட்டருக்கு ஏற்ப வெவ்வேறாக வகைகளை மாற்றுகிறது.
வகை மாற்றம் பிழைகளை மறைக்கிறது. நிரல் தொடர்கிறது, ஆனால் லாஜிக் தவறானது.
let result1 = ('5' + '2');
let result2 = ('5' - '2');விளக்கம்:
console.log('5' + '2'); // "52" (சரம் இணைப்பு)
console.log('5' - '2'); // 3 (எண் கழித்தல்)
console.log('5' * '2'); // 10 (எண் பெருக்கல்)
console.log('5' / '2'); // 2.5 (எண் வகுத்தல்)
console.log('5' == 5); // true (சமத்தன்மை மாற்றம்)
console.log('5' === 5); // false (கண்டிப்பான சமத்தன்மை)ஆபத்தான வகை மாற்றம் எடுத்துக்காட்டுகள்:
// எதிர்பாராத சரம் இணைப்பு
let sum = 5 + "2"; // "52" (சரம்)
let diff = 5 - "2"; // 3 (எண்)
// Boolean மாற்றம்
let truthy1 = Boolean("false"); // true (காலியற்ற சரம்)
let truthy2 = Boolean(0); // false
let truthy3 = Boolean("0"); // true
// எதிர்பாராத ஒப்பீடுகள்
console.log(0 == false); // true
console.log('' == false); // true
console.log(null == undefined); // true
console.log([] == false); // true
console.log([0] == false); // trueசிறந்த நடைமுறைகள்:
வகை மாற்றம் அமைதியான பிழைகளைத் தவிர்க்க:
// எப்போதும் கண்டிப்பான சமத்தன்மையைப் பயன்படுத்தவும் (===, !==)
if (value === 5) { /* ... */ }
// வெளிப்படையான வகை மாற்றம்
let num = Number(input);
let str = String(value);
let bool = Boolean(data);
// parseInt/parseFloat க்கு இரண்டாவது அளவுருவைப் பயன்படுத்தவும்
let int = parseInt("123abc", 10); // 123
let float = parseFloat("12.34px"); // 12.34மேலும் அமைதியான பிழை எடுத்துக்காட்டுகள்
Infinity செயல்பாடுகள்
let x = 1 / 0; // Infinity
let y = -1 / 0; // -Infinity
let z = Infinity * 0; // NaNInfinity உடன் கணிதம் பிழைகளை வீசாது, ஆனால் NaN அல்லது Infinity தருகிறது.
தவறான வரிசை செயல்பாடுகள்
let arr = [1, 2, 3];
let item = arr[10]; // undefined
arr[5] = 6; // Creates sparse array
arr.length; // 6வரம்பிற்கு வெளியே வரிசை அணுகல் undefined ஐ வழங்குகிறது, பிழை அல்ல.
செயல்பாடு அழைப்புகள்
function greet(name) {
return "Hello, " + name;
}
greet(); // "Hello, undefined"
greet(undefined); // "Hello, undefined"செயல்பாடுகள் வாதங்கள் இல்லாதபோது அமைதியாக undefined ஐப் பயன்படுத்துகின்றன.
அமைதியான பிழைகளைத் தடுப்பது
மேலும் பார்க்க:
JavaScript Errors
விதிவிலக்குகளை வீசும் JavaScript பிழைகள் பற்றி அறியவும்
JavaScript Error Statements
பிழை அறிக்கைகள் மற்றும் அவற்றின் தொடரியல் பற்றி அறியவும்
JavaScript Error Object
JavaScript பிழை பொருள் மற்றும் அதன் பண்புகள் பற்றி அறியவும்
JavaScript Debugging
JavaScript பிழைகளைக் கண்டறிந்து சரிசெய்வது பற்றி அறியவும்
JavaScript Silent Errors பயிற்சி
அமைதியான பிழைகள் பற்றிய உங்கள் அறிவைச் சோதிக்க இந்தப் பயிற்சியை முயற்சிக்கவும்.