How to perform type coercion in javascript

Force conversion method: 1. Use the String(), Number() or toString() function to convert the display type between strings and numbers; 2. Use the Boolean() function to convert the value to a Boolean value ;3. Use " " and "-" operators to perform implicit type conversion between strings and numbers.

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer.

1. Display forced type conversion between strings and numbers

Conversion between strings and numbers is through String(..) and Number(..) These two built-in functions.
In addition to String(..) and Number(..), there are other methods to achieve explicit conversion between strings and numbers:

let a = 42;
let b = a.toString();
let c = "3.14";
let d = +c;
b; // "42"
d; // 3.14

a.toString() is explicit , but there is an implicit conversion involved. Because toString() doesn't work with primitive values ​​like 42, the JavaScript engine automatically creates a wrapper object for 42 and then calls toString() on that object. This explicit conversion contains implicit conversion.

2. Explicit conversion to Boolean value

let a = "0";
let b = [];
let c = {};
let d = "";
let e = 0;
let f = null;
let g;
Boolean( a ); // true
Boolean( b ); // true
Boolean( c ); // true
Boolean( d ); // false
Boolean( e ); // false
Boolean( f ); // false
Boolean( g ); // false

Although Boolean(..) is explicit, it is not commonly used. The most common way to explicitly cast to boolean is!!

let a = "0";
let b = [];
let c = {};
let d = "";
let e = 0;
let f = null;
let g;
!!a; // true
!!b; // true
!!c; // true
!!d; // false
!!e; // false
!!f; // false
!!g; // false

3. Implicit cast between string and number

(1) Operator

can be used for number addition and string concatenation

If one of the operands is a string (or a string is obtained by calling the ToPrimitive abstract operation on it), then string concatenation is performed; otherwise, numeric addition is performed. Because the array's valueOf() operation cannot get a simple primitive value, it calls toString() instead. So the two arrays in the example below become "1,2" and "3,4". Concatenating them returns "1,23,4".

let a = "42";
let b = "0";
a + b; // "420"

let c = 42;
let d = 0;
c + d; // 42

let x = [1,2];
let y = [3,4];
x + y; // "1,23,4"

You can use operators for string conversion, and compare numbers with the empty string "" to convert it into a string

let a = 42;
let b = a + "";
b; // "42"

a " There is a subtle difference to note between "(implicit) and the previous String(a) (explicit).

According to the ToPrimitive abstract operation rules, a "" will call the valueOf() method on a, and then convert the return value into a string through the ToString abstract operation. String(a) calls ToString() directly. What they finally return are strings, but if a is an object rather than a number, the result may be different

let a = {
    valueOf: function() { return 42; },
    toString: function() { return 4; }
};
a + "";         // "42"
String( a );    // "4"

(2) Case of cast from string to number

- is the numeric subtraction operator, so a - 0 will cast a to a number. You can also use a * 1 and a /1, because these two operators only apply to numbers, but such usage is less common

let a = [3];
let b = [1];
a - b; // 2

[Recommended learning: javascript advanced tutorial】

The above is the detailed content of How to perform type coercion in javascript. For more information, please follow other related articles on the PHP Chinese website!