Summary of the usage of typeof function in js

1. Function:

The typeof operator returns a string that represents the data type of the expression.

Possible strings are: "number", "string", "boolean", "object", "function" and "undefined".

2. Description of commonly used return value

Note: The return values of the type are all strings, and they are all lowercase headers.

3. Regular application:

1). Check whether a variable exists and has a value.

Typeof will return "undefined" in two cases: when a variable is not declared, and when the value of a variable is undefined. For example:

> typeof undeclaredVariable === "undefined" true

> var declaredVariable;

> typeof declaredVariable 'undefined'

> typeof undefined 'undefined'

There are other ways to detect whether a value is undefined:

> var value = undefined;

> value === undefined true

However, if this method is used on an undeclared variable, an exception will be thrown, because only typeof can detect undeclared variables normally without reporting an error:

> undeclaredVariable === undefined ReferenceError: undeclaredVariable is not defined

Note: Uninitialized variables, formal parameters that are not passed in parameters, and non-existent properties will not have the above problems, because they are always accessible and the values are always undefined:

> var declaredVariable;

> declaredVariable === undefined true

> (function (x) { return x === undefined }()) true

> ({}).foo === undefined true

Note: Therefore, if(window.maybeUndeclaredVariable){}

Question: Typeof seems complicated when completing such tasks.

Solution: This kind of operation is not very common, so some people think there is no need to find a better solution. However, someone may propose a special operator:

> defined undeclaredVariable false

> var declaredVariable;

> defined declaredVariable false

Or maybe someone needs an operator that detects whether a variable is declared:

> declared undeclaredVariable false

> var declaredVariable;

> declared declaredVariable true

Translator's note: In perl, the defined operator above is equivalent to defined(), and the declared operator above is equivalent to exists(),

2. Determine that a value is not equal to undefined and not equal to null

Question: If you want to detect whether a value has been defined (the value is not undefined or null), then you have encountered a weird manifestation of typeof (that is considered a bug): typeof null returns "object":

> typeof null 'object'

Note: This can only be said to be a bug in the original JavaScript implementation, and the standard is now standardized. V8 once corrected and implemented typeof null === "null", but it finally proved unfeasible. http://wiki.ecmascript.org/doku.php?id=harmony:typeof_null

Solution: Do not use typeof to do this task, use the following method instead: However, the variable x must be declared in advance, otherwise an error will be reported.

function isDefined(x) { return x !== null && x !== undefined; }

Another possibility is to introduce a "default value operator". If myValue is not defined, the following expression will return defaultValue:

myValue || defaultValue

The above expression is equivalent to:

(myValue !== undefined && myValue !== null) ? myValue : defaultValue

In fact, it is a simplification of the following statement:

myValue = myValue || defaultValue

3. Distinguish between object values and original values

The following function is used to detect whether x is an object value:

function isObject(x) { return (typeof x === "function" || (typeof x === "object" && x !== null)); }

Problem: The above detection is more complicated because typeof treats functions and objects as different types, and typeof null returns "object".

Solution: The following methods are also often used to detect object values:

function isObject2(x) { return x === Object(x); }

Warning: You may think that instanceof Object can be used to detect it here, but instanceof is used to judge the instance relationship by using a prototype using an object. So what should I do if an object without a prototype:

> var obj = Object.create(null);

> Object.getPrototypeOf(obj) null

obj is indeed an object, but it is not an instance of any value:

> typeof obj 'object'

> obj instanceof Object false

In practice, you may rarely encounter such an object, but it does exist and has its purpose.

Translator's note: Object.prototype is an object that exists by default and has no prototype.

>Object.getPrototypeOf(Object.prototype) null

>typeof Object.prototype 'object'

>Object.prototype instanceof Object false

4. What is the type of the original value?

typeof is the best way to view a type of a certain original value.

> typeof "abc" 'string'

> typeof undefined 'undefined'

Question: You must know the weird behavior of typeof null.

> typeof null // Be careful! 'object'

Solution: The following function can fix this problem (for this use case only).

function getPrimitiveTypeName(x) {

var typeName = typeof x;

switch(typeName) {

case "undefined": case "boolean": case "number": case "string": return typeName;

case "object": if (x === null) { return "null"; }

default: // The previous judgment failed to pass throw new TypeError("The parameter is not a primitive value: "+x);

} }

A better solution: implement a function getTypeName(), which can not only return the type of the original value, but also return the internal [[Class]] attribute of the object value. Here we talk about how to implement this function (Translator's note: $.type in jQuery is the implementation like this)

5. Whether a value is a function

typeof can be used to detect whether a value is a function.

> typeof function () {} 'function'

> typeof Object.prototype.toString 'function'

In principle, instanceof Function can also perform this kind of requirement detection. At first glance, it seems that the writing is more elegant. However, the browser has a quirk: each framework and window has its own global variable. Therefore, if you pass an object in a certain framework into another framework, instanceof does not work properly because the two frameworks have different constructors. This is why there is an Array.isArray() method in ECMAScript5. It would be nice if there is a method that crosses the framework to check if an object is an instance of a given constructor. The above getTypeName() is a workaround, but maybe there is a more fundamental solution.

6. Overview

The following mentioned should be the most urgent need in JavaScript at present, and it can replace some functional features of the current responsibilities of typeof:

isDefined() (such as Object.isDefined()): It can be used as a function or an operator

isObject()

getTypeName()

A mechanism that can detect whether an object is an instance of a specified constructor across frameworks

To check whether a variable has been declared for such a requirement, it may not be necessary to have its own operator.

The above summary of the usage of typeof in JS is the entire content shared by the editor. I hope it can give you a reference and I hope you can support Wulin.com more.