Type Coercion

Question 1

What are abstract operations in javascript?

Answer 1

abstract operations are internal operations of javascript that are performed during execution of code.

It is called “abstract” because they just give information as to what needs to happen during execution, how it is done is left to implementations of ECMAScript.

Question 2

Info

Answer 2

implicit type coercion in javascript also uses some abstract operations such as:

1. ToPrimitive
2. ToNumber
3. ToString
4. ToBoolean

Basic idea is anytime we dont have certain type required for an operation, we invoke one of the abstract operations.
For eg: “5” - 2 is a mathematical operation which requires its operands to be numbers. So it gets converted to ToNumber(“5”) - 2 which results in 5-2=3.

Understanding how these abstract operations work is the base of understanding how type coercion works in javascript

Question 3

How does ToPrimitive abstract operation work?

Answer 3

ToPrimitive abstract operation has following definition ToPrimitive(hint).

hint is by default NUMBER and can be either NUMBER or STRING.

Basic Algorithm of ToPrimitive is as follows:
1. If primitive, return input
2. if an object has explicit ToPrimitive internal method (eg: Date object). It executes that, else
3. If hint is NUMBER, it executes valueOf() method of input object first, if result is not primitive, it executes toString() method. If toString() also doesnt give primitive, it throws TypeError.
4. If hint is STRING, it executes in the order of toString() first and then valueOf(). If none of them return primitive, it throws TypeError.

Question 4

How does ToString abstract operation work?

Answer 4

1. If input is primitive, it will just execute ToString algorithm which defines some rules based on primitive type.
2. If input is object, it will do the following ToString(ToPrimitive(input, STRING)).

We know that ToPrimitive with hint as STRING executes toString() and then valueOf()

Question 5

Answer ToString abstract operation values for the following:

1. ToString(null):
2. ToString(undefined)
3. ToString(true)
4. ToString(false)

// Number primitive: You can find exhaustive list of rules for conversion here https://tc39.es/ecma262/#sec-numeric-types-number-tostring

5. ToString(NaN)
6. ToString(0)
7. ToString(-0)
8. ToString(-1)
9. ToString(3.124)

// If input is object,

10. ToString([])
11. ToString([null])
12. ToString([undefined])
13. ToString([null, undefined])
14. ToString([1,2,3])
15. ToString([[[],[],[]], []])
16. ToString({})
17. ToString({a: 2})

Answer 5

1. “null”
2. “undefined”
3. “true”
4. “false”
5. “NaN”
6. “0”
7. “0”
8. “-1”
9. “3.124”

// For object inputs, following steps is how it gets resolved
// ToString(ToPrimitive(input, STRING))
// ToPrimitive(input, STRING) -> input.toString() else input.valueOf()

10. ToString(ToPrimitive([], STRING)) => ToString(toString([])) => ToString(“”) => “”
11. ToString(ToPrimitive([null], STRING)) => ToString(toString([null])) => ToString(“”) => “”
12. ToString(ToPrimitive([undefined], STRING)) => ToString(toString([undefined])) => ToString(“”) => “”
13. ToString(ToPrimitive([null, undefined], STRING)) => ToString(toString([null, undefined])) => ToString(“,”) => “,”
14. ToString(ToPrimitive([1,2,3], STRING)) => ToString(toString([1,2,3])) => ToString(“1,2,3”) => “1,2,3”
15. ”,,,”
16. ToString(ToPrimitive({}, STRING)) => ToString(toString({})) => ToString(“[object Object]”) => “[object Object]”
17. “[object Object]”

Question 6

How does ToNumber abstract operation work?

Answer 6

1. If input is primitive, it will just execute ToNumber algorithm which defines some rules based on primitive type.
2. If input is object, it will do the following ToNumber(ToPrimitive(input, NUMBER)).

We know that ToPrimitive with hint as NUMBER executes valueOf() and then toString()

Question 7

Answer ToNumber abstract operation values for the following:

1. undefined
2. null
3. false
4. true

// If input is string,
5. “”
6. “0”
7. “-0”
8. “ 009 “
9. “3.145”
10. “0.”
11. “.0”
12. “.”
13. “0x9f”

// If input is object
14. [””]
15. [“0”]
16. [“-0”]
17. [null]
18. [undefined]
19. [1,2,3]
20. [[[]]]
21. {}

Answer 7

spec mentions (1-4) explicitly
1. NaN
2. 0
3. 0
4. 1
5. 0
6. 0
7. -0
8. 9
9. 3.145
10. 0
11. 0
12. NaN
13. 175

// For object inputs, following steps is how it gets resolved
// ToNumber(ToPrimitive(input, NUMBER))
// ToPrimitive(input, NUMBER) -> input.valueOf() else input.toString()

// For [] and {} valueOf returns itself.
14. ToNumber(ToPrimitive([””], NUMBER)) => ToNumber(valueOf([””])) => since valueOf returns itself and its not primitive => ToNumber(toString([””])) => ToNumber(“”) => 0
15. ToNumber(ToPrimitive([“0”], NUMBER)) => ToNumber(valueOf([“0”])) => since valueOf returns itself and its not primitive => ToNumber(toString([“0”])) => ToNumber(“0”) => 0
16. ToNumber(ToPrimitive([“-0”], NUMBER)) => ToNumber(valueOf([“-0”])) => since valueOf returns itself and its not primitive => ToNumber(toString([“-0”])) => ToNumber(“-0”) => -0
17. ToNumber(ToPrimitive([null], NUMBER)) => ToNumber(valueOf([null])) => since valueOf returns itself and its not primitive => ToNumber(toString([null])) => ToNumber(“”) => 0
18. ToNumber(ToPrimitive([undefined], NUMBER)) => ToNumber(valueOf([undefined])) => since valueOf returns itself and its not primitive => ToNumber(toString([undefined])) => ToNumber(“”) => 0
19. ToNumber(ToPrimitive([1,2,3], NUMBER)) => ToNumber(valueOf([1,2,3])) => since valueOf returns itself and its not primitive => ToNumber(toString([1,2,3])) => ToNumber(“1,2,3”) => NaN
20. 0
21. ToNumber(ToPrimitive({}, NUMBER)) => ToNumber(valueOf({})) => since valueOf returns itself and its not primitive => ToNumber(toString({})) => ToNumber(“[object Object]”) => NaN

Question 8

How does ToBoolean abstract operation work?

Answer 8

ToBoolean abstract operation is used when non-boolean is used in boolean required places.

It just checks if the input is truthy or falsy.

Question 9

What are falsy values?

Answer 9

null, undefined, 0, -0, “”, NaN, false, 0n, -0n

Question 10

What is boxing?

Answer 10

Boxing is kind of like implicit conversion where javascript sees that we want to use primitive values like an object due to usage of dot notation on them and converts them into object.

Each primitive type has its corresponding object constructor. Boxing uses that to add respective properties required for an object of particular primitive type.

Eg: When “a”.length is used. Javascript converts “a” into object using new String(“a”)

Question 11

As a definition what is the difference between == and === ?

Answer 11

People mostly say == doesnt consider types and === considers types strictly. Which isnt actually true. Rather the actual scenario is,

== allows type coercion and === doesnt allow it

Question 12

Write basic algorithm of == operator?

Answer 12

IsLooselyEqual(x, y):

1. If x and y are of same type, return x === y
2. null and undefined are equal
3. If x or y is any other primitive than number, convert them to number and compare again.
4. If x or y is object, convert them to primitive and compare again.

NOTE: This isnt an in-depth algorithm since it doesnt consider BigInt, symbol, etc since iam only trying to remember things that provide most value. If in-depth algo is required check spec.

Question 13

Write basic algorithm of === operator?

Answer 13

IsStrictlyEqual(x, y):

1. If not same type return false.
2. All primitives are compared by their values, except
3. 0 === -0 returns true and NaN === NaN returns false.
4. All other values are compared by identity rather than by value.

NOTE: This isnt an in-depth algorithm since it doesnt consider BigInt, symbol, etc since iam only trying to remember things that provide most value. If in-depth algo is required check spec.