(+,-,*,/,==)

JavaScript automatically performs implicit type conversions before performing an operation or comparison. Let’s take a closer look at what happens to the + – * / == operator.

Type conversion

The ECMAScript runtime system does automatic type conversions when needed. To clarify the semantics of some structures, it is useful to define a set of transformation operators. These operators are not part of the language; They are defined here to assist in the specification of language semantics.

• ToPrimitive
• ToNumber
• ToString
• ToBoolean
• ToInteger
• ToInt32 :(32-bit signed integer)
• ToUint32 :(32-bit unsigned integer)
• ToUint16 :(16-bit unsigned integer)
• ToObject

The first three are detailed below

ToPrimitive

Convert to original type.

ToPrimitive(input, PreferredType)
Copy the code

Input type	The results of
Undefined	The result is equal to the input parameter (no conversion).
Null	The result is equal to the input parameter (no conversion).
Boolean	The result is equal to the input parameter (no conversion).
Number	The result is equal to the input parameter (no conversion).
String	The result is equal to the input parameter (no conversion).
Object	Returns the default value for this object. The DefaultValue of the object is obtained by calling the internal method [[DefaultValue]] of the object, passing the PreferredType as the hint parameter

Object internal method [[DefaultValue]] (hint)

When a String hint calls O’s [[DefaultValue]] inner method, do the following:

1. str = O.toString();
2. If STR is the original value, return STR;
3. val = O.valueOf();
4. Return val if val is the original value;
5. Raises a TypeError exception.

When the Number hint calls O’s [[DefaultValue]] inner method, do the following:

1. val = O.valueOf();
2. Return val if val is the original value;
3. str = O.toString();
4. If STR is the original value, return STR;
5. Raises a TypeError exception.

When no hint calls O’s [[DefaultValue]] inner method, hint=String if O is Date, and hit=Number otherwise.

Example:

ToPrimitive({})ObjectIf [[DefaultValue]] does not invoke hint, hint isNumberval = O.valueOf(); STR = o.tostring (); STR is'[object Object]', is the original value and returns'[object Object]'Results:'[object Object]'
Copy the code

ToNumber

Convert to a Number type.

Input Type	Result
Undefined	NaN
Null	+ 0
Boolean	true: 1, false: +0
Number	The result is equal to the input parameter (no conversion).
String	Converts strings to numbers.
Object	Apply the following steps: 1. Call ToPrimitive(input argument, hint Number). 2. Call ToNumber(Result(1)). 3. Return Result(2).

ToString

Convert to a String.

Input type	The results of
Undefined	“undefined”
Null	“null”
Boolean	If the argument is true, the result is “true”. If the argument is false, the result is “false”.
Number	Converts numbers to strings.
String	The result is equal to the input parameter (no conversion).
Object	Apply the following steps: 1. Call ToPrimitive(input argument, hint String). 2. Call ToString(Result(1)). 3. Return Result(2).

Example:

var obj = {
    valueOf: function () {
        return 1;
    },
    toString: function () {
        return 2; }}Number(obj) parse: obj typeObject, the call ToPrimitive (obj,Number) withNumberHint calls obj's [[DefaultValue]] inner method and calls obj's valueOf method1Return ToNumber (1Results:1

String(obj) parse: obj typeObject, the call ToPrimitive (obj,String) withStringHint calls obj's [[DefaultValue]] inner method to call obj's toString method2Returns the ToString (2Results:'2'
Copy the code

A practical use of type conversions

The plus operator +

Lval + rval

1. Make lprim ToPrimitive (lval).
2. Make rprim ToPrimitive (rval).
3. If Type(lprim) is String or Type(rprim) is String, then: returns the concatenated String of ToString(lprim) and ToString(rprim).
4. Returns the result of applying addition to ToNumber(lprim) and ToNumber(rprim).

Example:

([] + {})1. lprim = ToPrimitive([]); / /"
    2. rprim = ToPrimitive({}); // '[object Object]'
    3.Lprim and rprim are both strings and return ToString(' ') + ToString('[object Object]') // '[object Object]'Results:'[object Object]'

(undefined+ {});1. lprim = ToPrimitive([]); // undefined;
    2. rprim = ToPrimitive({}); // '[object Object]';
    3.Type (rprim)StringTo return to ToString (undefined) + ToString('[object Object]') // 'undefined[object Object]'Results:'undefined[object Object]'

(undefined + 1Resolution:1. lprim = ToPrimitive([]); // undefined;
    2. rprim = ToPrimitive(1); / / 1.
    3.Type(lprim) Type(rprim) neitherString;
    4.Return ToNumber (undefined) + ToNumber(1) // NaNResults:NaN
Copy the code

Other operators – * /

The – * / operators for lval and rval flow as follows:

1. Make lnum is ToNumber (lval).
2. Make rnum ToNumber (rval).
3. Returns the results of ToNumber(lprim) and ToNumber(rprim) operations.

Non-strict equality comparison

	The compared value B
		Undefined	Null	Number	String	Boolean	Object
The value being compared is A	Undefined	true	true	false	false	false	IsFalsy(B)
	Null	true	true	false	false	false	IsFalsy(B)
	Number	false	false	A === B	A === ToNumber(B)	A=== ToNumber(B)	A== ToPrimitive(B)
	String	false	false	ToNumber(A) === B	A === B	ToNumber(A) === ToNumber(B)	ToPrimitive(B) == A
	Boolean	false	false	ToNumber(A) === B	ToNumber(A) === ToNumber(B)	A === B	ToNumber(A) == ToPrimitive(B)
	Object	false	false	ToPrimitive(A) == B	ToPrimitive(A) == B	ToPrimitive(A) == ToNumber(B)	A === B

Example:

[] == {}
-> this == this
-> false

[] == 0
-> ToPrimitive([]) == 0
-> ' ' == 0
-> ToNumber(' '== 0 -> 0 == 0 ->true

[0] == 0
-> ToPrimitive([0]) == 0
-> '0' == 0
-> ToNumber('0'== 0 -> 0 == 0 ->true[11] = = 11 - >true

['0'] = =false
-> ToPrimitive(['0']) == ToNumber(false) - >'0' == 0
-> 0 == 0
-> true(= = {}'[object Object]')
-> ToPrimitive({}) == '[object Object]'
-> '[object Object]'= ='[object Object]'
-> true
Copy the code

 

reference

• ECMAScript5.1 Chinese version
• Equality judgment in JavaScript