Javascript typeof and instanceof Operators

When writing comprespt code, the typeof and instanceof operators are used from time to time and are mandatory. But! Using them is always hard to get the desired results directly, and it is very tangled. It is widely said that "these two operators may be the biggest design defect in javascript, because it is almost impossible to get the desired results from them"

Typeof

Description: typeof returns a string of the expression data type. The returned result is a basic js data type, including number, boolean, string, object, undefined, and function.

From the description, it seems that there is no problem.

The following code writes a numeric variable. The result of typeof is "number ".

The Code is as follows:

Var a = 1;

Console. log (typeof (a); // => number

If the Number Type constructor is used to create a new variable, the result after typeof is "object ".

Copy the Code as follows:

Var a = new Number (1 );

Console. log (typeof (a); // => object

The above two output results seem to have no problem, which seems to be a matter of course in the book, because javascript is designed in this way.

But! The problem is that if typeof is called, the type of a variable should be returned accurately, whether directly created with a value or created with a Type constructor, otherwise! What else do I do with you!

For:

The Code is as follows:

Var a = 1;

Var B = new Number (1 );

The type of variables a and B should be exactly the Number that is the expected result.

The accurate type information is stored in the value of the variable's internal attribute [[Class], which is obtained by using the toString defined on Object. prototype.

Obtain type information:

The Code is as follows:

Var a = 1;

Var B = new Number (1 );

Console. log (Object. prototype. toString. call ());

Console. log (Object. prototype. toString. call (B ));

Output:

The Code is as follows:

[Object Number]

[Object Number]

Is it already very straightforward? Let's take a look and get the direct result:

The Code is as follows:

Var a = 1;

Var B = new Number (1 );

Console. log (Object. prototype. toString. call (a). slice (8,-1 ));

Console. log (Object. prototype. toString. call (B). slice (8,-1 ));

Output:

Number

Number

This is the expected result.

For better use, we encapsulate a method to determine whether a variable is of a certain type:

The Code is as follows:

Function is (obj, type ){

Var clas = Object. prototype. toString. call (obj). slice (8,-1 );

Return obj! = Undefined & obj! = Null & clas = type;

}

Some variables have been tested. Let's take a look at their typeof output:

The Code is as follows:

Var a1 = 1;

Var a2 = Number (1 );

Var b1 = "hello ";

Var b2 = new String ("hello ");

Var c1 = [1, 2, 3];

Var c2 = new Array (1, 2, 3 );

Console. log ("a1's typeof:" + typeof (a1 ));

Console. log ("a2's typeof:" + typeof (a2 ));

Console. log ("b1's typeof:" + typeof (b1 ));

Console. log ("b2's typeof:" + typeof (b2 ));

Console. log ("c1's typeof:" + typeof (c1 ));

Console. log ("c2's typeof:" + typeof (c2 ));

Output:

A1's typeof: number

A2's typeof: object

B1's typeof: string

B2's typeof: object

C1's typeof: object

C2's typeof: object

Let's use the new functions as follows:

The Code is as follows:

Console. log ("a1 is Number:" + is (a1, "Number "));

Console. log ("a2 is Number:" + is (a2, "Number "));

Console. log ("b1 is String:" + is (b1, "String "));

Console. log ("b2 is String:" + is (b2, "String "));

Console. log ("c1 is Array:" + is (c1, "Array "));

Console. log ("c2 is Array:" + is (c2, "Array "));

Output:

A1 is Number: true

A2 is Number: true

B1 is String: true

B2 is String: true

C1 is Array: true

C2 is Array: true

Note: typeof is not useless. It is used to detect whether a variable has been defined or assigned a value.

Instanceof

Determines whether an object is of a certain data type or whether a variable is an instance of an object.

When the instanceof operator is used to compare two built-in types of variables, it is equally inadequate and will be dissatisfied with the results.

The Code is as follows:

Console. log ("abc" instanceof String); // false

Console. log ("abc" instanceof Object); // false

Console. log (new String ("abc") instanceof String); // true

Console. log (new String ("abc") instanceof Object); // true

The relationship is accurately reflected only when custom objects are compared.

The Code is as follows:

Function Person (){}

Function Man (){}

Man. prototype = new Person ();

Console. log (new Man () instanceof Man); // true

Console. log (new Man () instanceof Person); // true