refactor: datatype

Author: brijeshkumar-chavda

01_comment/01_comment.js 1_comment/comment.js

@@ -28,7 +28,7 @@ let myBoolean2 = false;
 const mySymbol = Symbol();
 
 // Traditional Datatype: numbers, string & boolean
-// Standalone value: undefined, null, empty string `""`
+// Standalone value: undefined, null, empty string `""`, NaN
 
 // Undefined
 let myUndefined1 = undefined;

02_output/console_log.js 2_output/console_log.js

@@ -1,32 +1,42 @@
 // NaN (Not a Number)
 
 // What
-// - `NaN` stands for "Not-a-Number." It's a special value in JavaScript that shows up when you do something that doesn't make sense with numbers.
+// - `NaN` stands for Not-a-Number.
+// - It's a standalone value in JavaScript that shows up when you do something that doesn't make sense with numbers.
 
 // Why
-// - JavaScript uses NaN to tell you when a math operation can't give a proper number answer, like dividing zero by zero.
+// -  NaN is for when a math operation can't give a proper number answer, for example dividing zero by zero. At that time JavaScript will return NaN.
 
 // How
 // - When you try to do math with things that aren't numbers, like dividing text by a number, you get NaN. It's like JavaScript's way of saying "I can't give you a real number because this doesn't work."
 
-// Note
-// - Be careful with NaN. If you use it in a calculation, the final result will also be NaN. Also, comparing NaN with other NaN values using === won't work as expected.
-
 // Example
 let division = 0 / 0; // This division results in NaN
 console.log(division); // Output: NaN
 
+// Note
+
+// NaN is Number (But Short Of)
+// - In JavaScript, typeof NaN returns "number" even though it represents "Not a Number."
+// - This is because NaN is a special numeric value used to indicate an invalid result.
+// - It occupies a space within the number system but doesn't represent a valid mathematical value.
+// - Be careful with NaN. If you use it in a calculation, the final result will also be NaN.
+
 // NaN in Comparisons
-// - For example, NaN === NaN returns false, and NaN !== NaN returns true. To check if a value is NaN, use the isNaN() function or the Number.isNaN() static method.
+// - Interestingly, even NaN compared to itself using comparison operators like === or !== returns false.
+// - This is because NaN is not equal to anything, including itself.
+// - For example, NaN === NaN returns false, and NaN !== NaN returns true.
+// - To check if a value is NaN, use the isNaN() method or the Number.isNaN() static method.
 
 let result = 0 / 0; // This division results in NaN
 console.log(result); // Output: NaN
 console.log(typeof result); // Output: "number"
 
-console.log(isNaN(result)); // Output: true
 console.log(result === NaN); // Output: false
 console.log(result !== NaN); // Output: true
 
+// How to Handle NaN (Recommended)
+console.log(isNaN(result)); // Output: true
 console.log(Number.isNaN(result)); // Output: true
 
 // - It's important to handle NaN in your code, especially when dealing with user input or calculations, to ensure that your program behaves as expected and doesn't produce unexpected results due to the presence of NaN.

02_output/console_table.js 2_output/console_table.js

@@ -7,10 +7,10 @@
 // - Symbols are used to create unique identifiers, which can be used as property keys for object properties. They help prevent naming collisions and enable the creation of private object members.
 
 // How
-// - Symbols are created using the Symbol() function, optionally with a description as an argument. Each symbol value returned by Symbol() is guaranteed to be unique.
+// - Symbols are created using the Symbol() construction, optionally with a description as an argument. Each symbol value returned by Symbol() is guaranteed to be unique.
 
 // Syntax
-const symbolName = Symbol("Identifier value");
+const symbolName = Symbol("description argument");
 
 // Example
 // Create a car object