Operator typeof returns a string indicating the type of the operand.

Syntax

The operand follows the typeof operator:

Typeof operand

Options

operand is an expression that represents an object or primitive whose type is to be returned.

Description

The following table lists the possible return values of typeof. More information about types and primitives is on the page.

Examples of

// Numbers typeof 37 === "number"; typeof 3.14 === "number"; typeof (42) === "number"; typeof Math.LN2 === "number"; typeof Infinity === "number"; typeof NaN === "number"; // even though it is "Not-A-Number" typeof Number (1) === "number"; // never use this entry! // Strings typeof "" === "string"; typeof "bla" === "string"; typeof "1" === "string"; // note that the number inside the string is still of type string typeof (typeof 1) === "string"; // typeof will always return a string in this case typeof String ("abc") === "string"; // never use this entry! // Booleans typeof true === "boolean"; typeof false === "boolean"; typeof Boolean (true) === "boolean"; // never use this entry! // Symbols typeof Symbol () === "symbol" typeof Symbol ("foo") === "symbol" typeof Symbol.iterator === "symbol" // Undefined typeof undefined === "undefined"; typeof declaredButUndefinedVariable === "undefined"; typeof undeclaredVariable === "undefined"; // Objects typeof (a: 1) === "object"; // use Array.isArray or Object.prototype.toString.call // to distinguish between regular objects and arrays typeof === "object"; typeof new Date () === "object"; // What is below leads to errors and problems. Do not use! typeof new Boolean (true) === "object"; typeof new Number (1) === "object"; typeof new String ("abc") === "object"; // Functions typeof function () () === "function"; typeof class C () === "function"; typeof Math.sin === "function";

null

// This has been defined since birth JavaScript typeof null === "object";

In the first implementation JavaScript values were represented by a pair of tag type and value. The tag type for objects was 0. null was represented as a null pointer (0x00 on most platforms). Hence the tag type for null was zero, so the return value of typeof is bogus. ()

A fix was suggested in ECMAScript (via disable) but was rejected. This would result in typeof null === "null".

Using the new operator

// All constructor functions created with "new" will be of type "object" var str = new String ("String"); var num = new Number (100); typeof str; // Returns "object" typeof num; // Returns "object" // But there is an exception for the Function constructor var func = new Function (); typeof func; // Returns "function"

Regular Expressions

Called regular expressions were a non-standard add-on in some browsers.

Typeof / s / === "function"; // Chrome 1-12 Not ECMAScript 5.1 compliant typeof / s / === "object"; // Firefox 5+ ECMAScript 5.1 Compliant

Errors related to temporary dead zones

Prior to ECMAScript 2015, the typeof operator was guaranteed to return a string for whatever operand it was called with. This changed with the addition of block-scoped non-hoisting let and const declarations. Now, if variables are declared with let and const, and typeof is called for them in the variable declaration block, but before the declaration, then a ReferenceError is thrown. The behavior differs from undeclared variables, for which typeof will return "undefined". Block-scoped variables are in a "temporary dead zone" that lasts from the beginning of the block until the variable is declared. In this zone, an attempt to access variables throws an exception.

Typeof undeclaredVariable === "undefined"; typeof newLetVariable; let newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "hello"; // ReferenceError

Exceptions

In all current browsers there is a non-standard host object document.all, which is of type Undefined.

Typeof document.all === "undefined";

Although the specification allows custom type names for non-standard exotic objects, it is required that these names differ from the predefined ones. A situation where document.all is undefined should be considered an exceptional violation of the rules.

Specifications (edit)

Specification	Status	Comments (1)
ECMAScript Latest Draft (ECMA-262)	Draft
ECMAScript 2015 (6th Edition, ECMA-262) The definition of "The typeof Operator" in this specification.	Standard
ECMAScript 5.1 (ECMA-262) The definition of "The typeof Operator" in this specification.	Standard
ECMAScript 3rd Edition (ECMA-262) The definition of "The typeof Operator" in this specification.	Standard
ECMAScript 1st Edition (ECMA-262) The definition of "The typeof Operator" in this specification.	Standard	Original definition. Implemented in JavaScript 1.1

Browser Compatibility

Update compatibility data on GitHub

	Computers						Mobile						Server
	Chrome	Edge	Firefox	Internet Explorer	Opera	Safari	Android webview	Chrome for Android	Firefox for Android	Opera for Android	Safari on iOS	Samsung Internet	Node.js
typeof	Chrome Full support 1	Edge Full support 12	Firefox Full support 1	IE Full support 3	Opera Full support Yes	Safari Full support Yes	WebView Android Full support 1	Chrome Android Full support 18	Firefox Android Full support 4	Opera Android Full support Yes	Safari iOS Full support Yes	Samsung Internet Android Full support 1.0	nodejs Full support Yes

Legend

Full support Full support

IE specific notes

In IE 6, 7, and 8, many host objects are objects, but not functions. For example.

JavaScript or Js(abbreviated) is not an easy language and novice developers do not immediately learn about it. At first they learn the basics and everything seems colorful and beautiful. Going a little deeper, there appear JavaScript arrays, objects, callbacks and the like that the brain often takes out.

In JavaScript, it is important to check the type of a variable correctly. Let's say you want to know if a variable is an array or an object? How to check it correctly? In this particular case, there are tricks during the check and that is what this entry will be about. Let's get started right away.

Checking the type of a variable

For example, you need to check if a variable is an object, array, string or number. You can use typeof for this, but it will not always give you the truth, and in the example below I will show why.

I wrote this example to illustrate why typeof is not always the right choice.

Var _comparison = (string: "string", int: 99, float: 13.555, object: (hello: "hello"), array: new Array (1, 2, 3)); // Returns an array with object keys var _objKeys = Object.keys (_comparison); for (var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

The result of executing the code:

String number number object object

Right? - Of course not. There are two problems. Each of them will be described in detail and a solution will be proposed.

First problem: float number, output as number

Comparison.float is not a number and should be a float instead of number. To fix this, you can create a function with validation as in the code below.

Var _floatNumber = 9.22; var _notFloatNumber = 9; console.log (isFloat (_floatNumber)); console.log (isFloat (_notFloatNumber)); console.log (isFloat ("")); function isFloat (n) (return Number (n) === n && n% 1! == 0;)

The isFloat () function checks all values for floating point numbers. First, it checks if the variable is equal to n number (Number (n) === n) and if so, another check is done for division with remainder, and if there is a remainder, then a boolean ( true or false) result (n% 1! == 0).

In the example above, it returns true, false and false... The first meaning is float type, the second is not - this is an ordinary number and the last is just an empty string that does not fit the rules.

Second problem: the array was defined as an object

In the very first example, the array was displayed as an object and this is not very good, because sometimes you need to use this particular type and nothing else.

There are several ways to test a variable for an array type.

First option (good option). We check if data belongs to an array using instanceof ().

Var data = new Array ("hello", "world"); var isArr = data instanceof Array;

Second option (good option). The Array.isArray () method returns a boolean value, which will depend on whether the variable is an array or not ().

Var data = new Array ("hello", "world"); var isArr = Array.isArray (data);

The third option (the best, but longest). For convenience, you can make this a function. Using Object, we do. If the result of Object.prototype.toString.call (data) is not equal then the variable is not an array ().

Var data = new Array ("hello", "world"); var isArr = Object.prototype.toString.call (data) == ""; console.log (isArr);

The last result as a convenience function:

Function isArray (data) (return Object.prototype.toString.call (data) == "")

Now you can call the isArray () function and set an array or something else as an argument and see the result.

Afterword

The recording turned out to be rather large than it was originally intended. But I'm happy with it, because it briefly and clearly describes the difficulties in checking variables in JavaScript and how to get around them.

If you still have any questions - write them below to this entry. I will be happy to help.

Dynamic type identification

Dynamic Type Identification (RTTI) allows you to determine the type of an object at runtime. It turns out to be useful for a variety of reasons. In particular, by reference to the base class, you can fairly accurately determine the type of object available from this link. Dynamic type identification also allows you to check in advance how successful the typecast will be, preventing an invalid typecast exception. In addition, dynamic type identification is a major component of reflection.

To support dynamic type identification, C # provides three keywords: is, as, and typeof. Each of these keywords is discussed below in turn.

Is operator

The specific type of an object can be determined using the is operator. Its general form is shown below:

expression is type

where expression denotes a separate expression describing the object whose type is being checked. If the expression is of a compatible type or of the same type as the type being tested, then the result of this operation is true, otherwise it is false. Thus, the result is true if the expression has a testable type in one form or another. The is operator defines both types to be compatible if they are of the same type, or if reference conversion, boxing, or unboxing is provided.

Below is an example of using the is operator:

Using System; namespace ConsoleApplication1 (class Add () class Sum: Add () class Program (static void Main () (Add a = new Add (); Sum s = new Sum (); if (a is Add) Console.WriteLine ("Variable a is of type Add "); if (s is Sum) Console.WriteLine (" The type of s is inherited from the Add class "); Console.ReadLine ();)))

As operator

Sometimes the type conversion needs to be done at runtime, but not throw an exception if the conversion fails, which is quite possible with type casting. For this purpose, the as operator serves, which has the following general form:

expression as type

where expression denotes a single expression to be converted to the specified type.

If this conversion succeeds, then a reference to the type is returned; otherwise, an empty reference. The as operator can only be used for reference conversion, identity, boxing, unboxing. In some cases, the as operator can serve as a convenient alternative to the is operator. As an example, consider the following program:

Using System; namespace ConsoleApplication1 (class Add () class Sum: Add () class Program (static void Main () (Add a = new Add (); Sum s = new Sum (); // Perform typecasting a = s as Add; if (a! = null) Console.WriteLine ("Conversion was successful"); else Console.WriteLine ("Conversion failed"); Console.ReadLine ();)))

The result of this program will be a successful conversion.

a = (b> 0) && (c + 1! = d); flag =! (status = 0);

Table 14.5. Logical operators

Operator Description

! NOT (logical inversion)

&& AND (logical multiplication)

|| OR (logical addition)

Table 14.6. Results of executing AND and OR operators

Operand 1	Operand 2

Table 14.7. Results of the NOT statement

Getter operator typeof

Get Type Operator typeof returns a string describing the data type of the operand. The operand whose type you want to know is placed after this operator and enclosed in parentheses:

s = typeof ("str");

As a result of this expression, the s variable will contain the string "string" denoting the string type.

All the values that the typeof operator can return are listed in table. 14.8.

	Table 14.8. Values returned by the typeof operator

Data type		Returned string

String

Numerical



		Table 14.8 (end)

Data type	Returned string

Logical

Data type compatibility and conversion

Now is the time to consider two more important issues: data type compatibility and conversion from one type to another.

What happens when you add two numbers together? That's right - one more numerical value. And if you add a number and a string? It's hard to say ... Here JavaScript is faced with the problem of incompatibility of data types and tries to make these types compatible by converting one of them to another. It first tries to convert the string to a number and, if successful, performs the addition. If unsuccessful, the number will be converted to a string and the two resulting strings will be concatenated. For example, executing the Web script in Listing 14.6 converts the value of b to a numeric type when added to a; thus, the variable c will contain the value 23.

Listing 14.6

var a, b, c, d, e, f; a = 11;

b = "12"; c = a + b;

d = "JavaScript"; e = 2;

But since the value of the variable d cannot be converted to a number, the value of e will be converted to a string, and the result - the value of f - will become

Boolean values are converted to either numeric or string values, as appropriate. True will be converted to the number 1 or the string "1", and false- to 0 or "0". Conversely, the number 1 will be converted to true and the number 0 is false. Also, false will be converted

the values are null and undefined.

	Part III. Behavior of web pages. Web scripts

It can be seen that JavaScript is struggling to correctly execute even incorrectly written expressions. Sometimes it works, but more often everything does not work as planned, and, in the end, the execution of the Web script is interrupted due to the discovery of an error in a completely different place, on the absolutely correct operator. Therefore, it is better to avoid such incidents.

Operator priority

The last issue we will look at here is operator precedence. As we recall, precedence affects the order in which statements are executed in an expression.

Let there be the following expression:

In this case, first the value of c will be added to the value of the variable b, and then 10 will be subtracted from the sum. The operators of this expression have the same priority and therefore are executed strictly from left to right.

Now, consider an expression like this:

Here, first, the value of c will be multiplied by 10, and only then the value b will be added to the resulting product. The multiplication operator takes precedence over the addition operator, so strict left-to-right ordering will be violated.

Assignment operators have the lowest precedence. This is why the expression itself is evaluated first, and then its result is assigned to a variable.

V In general, the basic principle of execution of all operators is as follows: the operators with a higher priority are executed first, and only then the operators with a lower priority. Operators with the same priority are executed in the order they appear (from left to right).

V tab. 14.9 lists all the operators we studied in descending order of their priority.

		Table 14.9. Operator precedence (descending order)

	Operators	Description

	++ - - ~! typeof	Increment, decrement, sign change, logical NOT, type inference

		Multiplication, division, taking the remainder

		Addition and concatenation of strings, subtraction


		Comparison Operators
		Comparison Operators


		Logical AND

Chapter 14. Introduction to Web Programming. JavaScript language

		Table 14.9 (end)

Operators	Description

	Logical OR

	Conditional operator (see below)

= <оператор>=	Assignment, simple and complex

ATTENTION!

Remember this table. Incorrect statement execution order can lead to hard-to-detect errors, in which a seemingly absolutely correct expression gives the wrong result.

But what if we need to break the normal order of execution of statements? Let's use parentheses. With this notation, statements enclosed in parentheses are executed first:

a = (b + c) * 10;

Here, the addition of the values of the variables b and c will be performed first, and then the resulting sum will be multiplied by 10.

Operators enclosed in parentheses are also subject to precedence. Therefore, multiple nested parentheses are often used:

a = ((b + c) * 10 - d) / 2 + 9;

Here the statements will be executed in the following sequence:

1. Addition b and c.

2. Multiply the resulting amount by 10.

3. Subtracting d from the product.

4. Dividing the difference by 2.

5. Add 9 to the quotient.

If you remove the brackets:

a = b + c * 10 - d / 2 + 9;