Three pillars of JS
- Types
- Scopes
- Objects System (Objects Oriented)
Types
- Primitive types are types which are not object and which do not behave like object. Also, primitive types are immutable. They are:
- number
- string
- undefined
- null
- Boolean
- Symbol
- BigInt
- Following are subtypes of object i.e. they are object with unique/specific behaviors.
- function
- array
- typeof operator - returns the type of the value passed. Has some caveats. value can be checked with invocation of typeof and passing value as arg. also, typeof === null → ‘object’ & typeof () ⇒ {} → ‘function’ but typeof [] → ‘object’.
- undefined, undeclared, unintialized → undefined is a specific value. accessing var variables before its declaration is is undeclared and accessing it returns undefined. unintialized are let & const variables which are being accessed before declaration. This is called temporal dead zone, where this variables if accessed throws reference error.
- NaN - Represents not a valid number. Full form is Not a Number. Only value in Js where NaN = NaN is false(or its inverse ie NaN ! NaN is true). typeof NaN is ‘number’. Dependable utility to check this is Number.isNaN
- -0: A valid number. Nuance is 0 === -0 which is not technically true but thats how it works in JS. Can use Object.is(x,y) to check if -0 is the value.
- Fundamental Objects: These objects represent fundamental language constructs.
Coercion
Abstract Operation ( Stolen from here, not notes from lecture)
Every time a value conversion happens, it is handled by one or more abstract operation with some rules defined in the spec. Here we will look into three abstract operations: ToString, ToNumber and ToPrimitive.
Abstract operations are used to aid the specification of the semantics of JavaScript language.
ToString
Whenever we coerce a non-string value to a string value, ToString handles the conversion as in section 7.1.12 of the specification. Primitive types have natural stringification. The table looks like:
// ToString abstract operation (string conversion)
null -> 'null'
undefined -> 'undefined'
true -> 'true'
false -> 'false'
52 -> '52'
For regular object and array, the default toString() is invoked which is defined on the Object.prototype
var a = {language: 'JavaScript'};
a.toString(); // "[object Object]"
[].toString(); // ""
You can also specify your own toString method to override the default return value:
var a = { language: 'JavaScript', toString(){return 'I love JavaScript'} };
a.toString(); // "I love JavaScript"
ToNumber
Whenever a non-number value is supplied in an operation where a number was expected, such as a mathematical operation, ES2020 defines a ToNumber abstract operation in section 7.1.3. For example
// ToNumber abstract operation (number conversion)
true -> 1
false -> 0
undefined -> NaN (not a valid number)
null -> 0
For object and array, values are first converted to their primitive value equivalent (via ToPrimitive operation) and the resulting value is then coerced into number according to the ToNumber abstract operation.
ToBoolean
ToBoolean is a little simpler than ToString and ToNumber operation as it doesn’t do any internal conversion. It only performs a table lookup as mentioned in section 7.1.2.
| Argument type | Result |
|---|---|
| undefined | false |
| null | false |
| boolean | return argument |
| number | if argument is +0, -0 or NaN, return false; otherwise true |
| string | if argument is empty string, return false; otherwise true |
| symbol | true |
| object | true |
ToPrimitive
If we have non-primitive type (like function, object, array) and we need a primitive equivalent, ES2020 defines ToPrimitive in section 7.1.1.
ToPrimitve operation takes two arguments: input and hint(optional). If you are performing a numeric operation, the hint will be a ‘number’ type. And for string operation (like concatenation), the hint passed will be a string. Note that ToPrimitive is a recursive operation which means that if the result of invoking ToPrimitive is not a primitive, it will invoke again until we can get a primitive value or an error in some cases.
Now let’s look at the algorithm behind the ToPrimitive operations.
Every non-primitive can have two methods available: toString and valueOf. If ‘number’ hint is sent, valueOf() method is invoked first. And if we get a primitive type from the result then we are done. But if the result is again a non-primitive, toString() gets invoked. Similarly, in the case of ‘string’ hint type, the order of these operations is reversed. If the invocation of these two operations doesn’t return a primitive, generally it’s a TypeError.
Visually, The order can be seen as follows:
// ToPrimitive Abstract Operation
// hint: "number"
valueOf()
toString()
// hint: "string"
toString()
valueOf()
To make it more clear here’s the flow chart diagram of the algorithm we discussed above:
