Detailed explanation of typeof and type judgment in javascript

This article mainly brings you an article based on typeof and type judgment in JavaScript (detailed explanation). The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor to take a look, I hope it can help everyone.

typeof

ECMAScript has 5 primitive types, namely Undefined, Null, Boolean, Number and String. We all know that you can use the typeof operator to find the type of a variable, but for reference type variables, it will only return object, which means that typeof can only correctly identify basic type value variables.

var a = "abc";
console.log(typeof a); // "string"
var b = 123;
console.log(typeof b); // "number"
var c = true;
console.log(typeof c); // "boolean"
var d = null;
console.log(typeof d); // "object"
var f = undefined;
console.log(typeof f); // "undefined"
var g;
console.log(typeof g); // "undefined"

console.log(typeof x); // "undefined"

You may ask why the typeof operator returns "object" for null values. This was actually a bug in the original implementation of JavaScript that was then adopted by ECMAScript. Now, null is considered a placeholder for an object, thus explaining the contradiction, but technically it's still a primitive value.

The last one is strange, typeof a non-existent variable x actually returns "object" instead of "undefined".

We are coming to the following code:

var a = function() { };
console.log(typeof a); // "function"
var b = [1,2,3]; 
console.log(typeof b); // "object"
var c = { };
console.log(typeof c); // "object"

Returns "object" for both arrays and objects, so a common need in our daily development is how to determine whether a variable is an array or an object.

Type judgment

Type judgment is generally to judge whether it is an array or an empty object. This is the judgment method I have used or seen daily for this requirement

Judge whether it is an array

There is an array: var a = [1,2,3,4,5];

Method one:

toString.call(a); // "[object Array]"Method two:

a instanceof Array; //true method Three:

a.constructor == Array; //true The first method is more general, which is the abbreviation of Object.prototype.toString.call(a).

The variables judged by instanceof and constructor must be declared on the current page. For example, a page (parent page) has a frame, a page (child page) is referenced in the frame, and a page is declared in the child page. a, and assign it to a variable of the parent page. When judging the variable, Array == object.constructor will return false;

var a = [1,2,3,4,5];
console.log(toString.call(a)); // "[object Array]"      
console.log(a instanceof Array); //true
console.log(a.constructor == Array); //true

Judge whether it is an empty object

There are variables: var obj = {};

Method 1:

JSON.stringify(obj); // "{}" is converted into a JSON object to determine whether it is an empty brace

Method 2:

if(obj.id){ //If the attribute id exists...} This method is relatively simple and most people can think of it. The premise is that there is a certain object in the object. Attributes.

Method 3:

function isEmptyObject(e) { 
var t; for (t in e) return !1; return !0 } //trueisEmptyObject(obj);
//falseisEmptyObject({ "a":1, "b":2});

This method is the implementation of jQuery’s isEmptyObject() method.

Related recommendations:

Introduction to the use of typeof in JavaScript

Detailed examples of comparative usage of typeof and instanceof in JavaScript

Summary of the usage of typeof in js

The above is the detailed content of Detailed explanation of typeof and type judgment in javascript. For more information, please follow other related articles on the PHP Chinese website!