Coercion JS Part 2

Type Conversion

ToPrimitive(input,PreffredType )

• PreffredType is optional argument

  In case where input can be converted into multiple type, we take the decesion using this.

• Convert the input into non-object type.

  Type Conversion discusses the conversion of input into non-object types, highlighting the optional PreferredType argument used to decide the type when multiple conversions are possible.

  • Assert: input is an ECMAScript language value: This means the code is expecting something that JavaScript understands.

  • Check if input is an object: If the input is an object (like an array, function, or custom object), the code continues; otherwise, it's already a primitive and can be returned.

  • Determine the hint: Based on a preference (called PreferredType), the code decides whether to try converting the object to a string or a number. If no preference is given, it defaults to number.

  • Look for a custom conversion method: Some objects might have a special method to convert themselves to primitive values. If found, use that method.

  • Check the result: If the result of the conversion is not an object, it's a primitive and can be returned. Otherwise, an error occurs.

  • Default to number conversion: If the original hint was "default", try to convert the object to a number.

  • Try a standard conversion: If the above steps fail, use a standard method to convert the object to a primitive based on the hint.

  • If all else fails: Return the original input as it is.

      let myObject = { value: 42 };
    
      // Trying to add myObject to a number directly would cause an error
      let result = myObject + 10; // This will throw an error
    
      // The code above would try to convert myObject to a number using the steps outlined above.
      // If     successful, result would be 52.
    

OridinaryToPrimitive (input,hint)

When the abstract operator OrdinaryToPrimitive is called with argumwnt 0 and hint.

Type hint either "String" or "Number"

"String" --> ["tostring","valueof"] --> if the string method give it primitive return if give it primitive return then call valueof if it give primitive type return if not return type error.

let obj={}
console.log(obj.toString());
// [object Object]

"Number" -->["valueof","tostrring"] (method)

let obj1 = {x:9,y:9};
console.log(100-obj1) // NaN

let obj2 = {x:7,valueOf() {return 99}};
console.log(100-obj2) // 1

let obj3 = {x:7,valueOf() {return "99"}};
console.log(100-obj3) // 11

let obj4 = {x:7,valueOf() {return {}};
console.log(100-obj12) // type error

1. ToNumber(10): The number 10 is already a number, so no conversion is needed. It remains 10.

2. ToNumber(obj): This is where the conversion of the object obj to a number begins.

3. ToPrimitive(obj, hint Number): The object obj is passed to the ToPrimitive function with a hint of "Number." This indicates that the system prefers a numeric conversion if possible.

4. OrdinaryToPrimitive(obj, hint Number): Since obj doesn't have a custom @@toPrimitive method, the standard OrdinaryToPrimitive function is used.

5. Hint Number: The hint remains "Number" as the initial preference.

6. [value of, "toString"]: The OrdinaryToPrimitive function attempts to call the valueOf() method on the object.

7. obj.valueOf(): This returns the object itself, as it's not a primitive value.

8. Object (Non-object type): The result of valueOf() is still an object, not a primitive.

9. obj.toString(): Since valueOf() didn't produce a primitive, the toString() method is called on the object.

10. [object Object] type is String: The toString() method typically returns a string representation of the object, which is "[object Object]" in this case.

11. Return String: The toString() method returns the string "[object Object]."

12. ToNumber(String): The returned string "[object Object]" is then passed to the ToNumber function for conversion to a number.

13. NaN: The conversion of "[object Object]" to a number results in NaN (Not a Number).

14. 10 + NaN: Finally, the original operation 10 + obj becomes 10 + NaN, which results in NaN.

Conclusion:

The summary demonstrates that when an object is added to a number in JavaScript, the object is first converted to a primitive value using ToPrimitive and then to a number using ToNumber. If these conversions fail to produce a valid number, the result is NaN.

Addition Operator (+)

let obj1 = { value: 10 }; let obj2 = { value: 20 };

let result = obj1 + obj2; // Output: "[object Object][object Object]"

Abstract Equality (==) and Strict Equality (===)

The Myth

"Myth: In Internet, == (Not check type, only check value)"

This is not entirely accurate. Both == and === perform type checks. The difference lies in what happens when the types are different.

Abstract Equality (==)

1. Type Check: If the types of the operands are the same, the comparison proceeds directly.

2. Type Conversion (if necessary): If the types are different, JavaScript attempts to convert one or both operands to a common type before comparing their values.

3. Value Comparison: Once the types are compatible, the values are compared.

Example:

JavaScript

console.log(5 == "5"); // Output: true

In this case, the number 5 is converted to the string "5" before comparison, resulting in true.

Strict Equality (===)

1. Type Check: If the types of the operands are different, the comparison immediately returns false.

2. Value Comparison: Only if the types are identical does JavaScript proceed to compare the values.

Example:

console.log(5 === "5"); // Output: false

Here, since the types are different (number and string), the comparison is false without any value conversion.

Key Points to Remember

• Use === whenever possible to avoid unexpected type coercion and potential errors.

• Use == cautiously, understanding that it might perform type conversions.

• Be aware of the common type conversions that JavaScript performs (e.g., null and undefined are equal with ==, numbers and strings can be compared after conversion).