Was bedeuted ffs

Assignment operators

An assignment operator assigns a value to its left operand based on the value of its right operand. The simple assignment operator is equal (const val = 0; val.x = 3; console.log(val.x); // Prints undefined. console.log(val); // Prints 0. 9), which assigns the value of its right operand to its left operand. That is, let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 7 is an assignment expression that assigns the value of let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8 to const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0.

There are also compound assignment operators that are shorthand for the operations listed in the following table:

Assigning to properties

If an expression evaluates to an object, then the left-hand side of an assignment expression may make assignments to properties of that expression. For example:

const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }.

For more information about objects, read Working with Objects.

If an expression does not evaluate to an object, then assignments to properties of that expression do not assign:

const val = 0; val.x = 3; console.log(val.x); // Prints undefined. console.log(val); // Prints 0.

In strict mode, the code above throws, because one cannot assign properties to primitives.

It is an error to assign values to unmodifiable properties or to properties of an expression without properties (operand1 operator operand2 12 or operand1 operator operand2 13).

Destructuring

For more complex assignments, the destructuring assignment syntax is a JavaScript expression that makes it possible to extract data from arrays or objects using a syntax that mirrors the construction of array and object literals.

const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo;

Evaluation and nesting

In general, assignments are used within a variable declaration (i.e., with operand1 operator operand2 14, operand1 operator operand2 15, or operand1 operator operand2 16) or as standalone statements).

// Declares a variable x and initializes it to the result of f(). // The result of the x = f() assignment expression is discarded. let x = f(); x = g(); // Reassigns the variable x to the result of g().

However, like other expressions, assignment expressions like let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 7 evaluate into a result value. Although this result value is usually not used, it can then be used by another expression.

Chaining assignments or nesting assignments in other expressions can result in surprising behavior. For this reason, some JavaScript style guides discourage chaining or nesting assignments). Nevertheless, assignment chaining and nesting may occur sometimes, so it is important to be able to understand how they work.

By chaining or nesting an assignment expression, its result can itself be assigned to another variable. It can be logged, it can be put inside an array literal or function call, and so on.

let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0));

The evaluation result matches the expression to the right of the const val = 0; val.x = 3; console.log(val.x); // Prints undefined. console.log(val); // Prints 0. 9 sign in the "Meaning" column of the table above. That means that let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 7 evaluates into whatever let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8's result is, function f () { console.log('F!'); return 2; } function g () { console.log('G!'); return 3; } let x, y; 2 evaluates into the resulting sum operand1 operator operand2 22, y = x = f() y = [ f(), x = g() ] x[f()] = g() 2 evaluates into the resulting power operand1 operator operand2 24, and so on.

In the case of logical assignments, operand1 operator operand2 06, operand1 operator operand2 08, and operand1 operator operand2 10, the return value is that of the logical operation without the assignment, so operand1 operator operand2 28, operand1 operator operand2 29, and operand1 operator operand2 30, respectively.

When chaining these expressions without parentheses or other grouping operators like array literals, the assignment expressions are grouped right to left (they are right-associative), but they are evaluated left to right.

Note that, for all assignment operators other than const val = 0; val.x = 3; console.log(val.x); // Prints undefined. console.log(val); // Prints 0. 9 itself, the resulting values are always based on the operands' values before the operation.

For example, assume that the following functions operand1 operator operand2 32 and operand1 operator operand2 33 and the variables const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 and operand1 operator operand2 35 have been declared:

function f () { console.log('F!'); return 2; } function g () { console.log('G!'); return 3; } let x, y;

Consider these three examples:

y = x = f() y = [ f(), x = g() ] x[f()] = g()

Evaluation example 1

operand1 operator operand2 36 is equivalent to operand1 operator operand2 37, because the assignment operator const val = 0; val.x = 3; console.log(val.x); // Prints undefined. console.log(val); // Prints 0. 9 is right-associative. However, it evaluates from left to right:

1. The assignment expression operand1 operator operand2 36 starts to evaluate.
   1. The operand1 operator operand2 35 on this assignment's left-hand side evaluates into a reference to the variable named operand1 operator operand2 35.
   2. The assignment expression let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 7 starts to evaluate.
      1. The const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 on this assignment's left-hand side evaluates into a reference to the variable named const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0.
      2. The function call let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8 prints "F!" to the console and then evaluates to the number operand1 operator operand2 46.
      3. That operand1 operator operand2 46 result from let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8 is assigned to const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0.
   3. The assignment expression let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 7 has now finished evaluating; its result is the new value of const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0, which is operand1 operator operand2 46.
   4. That operand1 operator operand2 46 result in turn is also assigned to operand1 operator operand2 35.
2. The assignment expression operand1 operator operand2 36 has now finished evaluating; its result is the new value of operand1 operator operand2 35 – which happens to be operand1 operator operand2 46. const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 and operand1 operator operand2 35 are assigned to operand1 operator operand2 46, and the console has printed "F!".

Evaluation example 2

operand1 operator operand2 61 also evaluates from left to right:

1. The assignment expression operand1 operator operand2 61 starts to evaluate.
   1. The operand1 operator operand2 35 on this assignment's left-hand evaluates into a reference to the variable named operand1 operator operand2 35.
   2. The inner array literal operand1 operator operand2 65 starts to evaluate.
      1. The function call let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8 prints "F!" to the console and then evaluates to the number operand1 operator operand2 46.
      2. The assignment expression operand1 operator operand2 68 starts to evaluate.
         1. The const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 on this assignment's left-hand side evaluates into a reference to the variable named const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0.
         2. The function call operand1 operator operand2 71 prints "G!" to the console and then evaluates to the number const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4.
         3. That const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4 result from operand1 operator operand2 71 is assigned to const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0.
      3. The assignment expression operand1 operator operand2 68 has now finished evaluating; its result is the new value of const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0, which is const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4. That const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4 result becomes the next element in the inner array literal (after the operand1 operator operand2 46 from the let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8).
   3. The inner array literal operand1 operator operand2 65 has now finished evaluating; its result is an array with two values: operand1 operator operand2 83.
   4. That operand1 operator operand2 83 array is now assigned to operand1 operator operand2 35.
2. The assignment expression operand1 operator operand2 61 has now finished evaluating; its result is the new value of operand1 operator operand2 35 – which happens to be operand1 operator operand2 83. const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 is now assigned to const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4, operand1 operator operand2 35 is now assigned to operand1 operator operand2 83, and the console has printed "F!" then "G!".

Evaluation example 3

operand1 operator operand2 93 also evaluates from left to right. (This example assumes that const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 is already assigned to some object. For more information about objects, read Working with Objects.)

1. The assignment expression operand1 operator operand2 93 starts to evaluate.
   1. The operand1 operator operand2 96 property access on this assignment's left-hand starts to evaluate.
      1. The const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 in this property access evaluates into a reference to the variable named const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0.
      2. Then the function call let x; const y = (x = f()); // Or equivalently: const y = x = f(); console.log(y); // Logs the return value of the assignment x = f(). console.log(x = f()); // Logs the return value directly. // An assignment expression can be nested in any place // where expressions are generally allowed, // such as array literals' elements or as function calls' arguments. console.log([ 0, x = f(), 0 ]); console.log(f(0, x = f(), 0)); 8 prints "F!" to the console and then evaluates to the number operand1 operator operand2 46.
   2. The operand1 operator operand2 96 property access on this assignment has now finished evaluating; its result is a variable property reference: operator operand operand operator 02.
   3. Then the function call operand1 operator operand2 71 prints "G!" to the console and then evaluates to the number const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4.
   4. That const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4 is now assigned to operator operand operand operator 02. (This step will succeed only if const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 is assigned to an object.)
2. The assignment expression operand1 operator operand2 93 has now finished evaluating; its result is the new value of operator operand operand operator 02 – which happens to be const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4. operator operand operand operator 02 is now assigned to const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4, and the console has printed "F!" then "G!".

Avoid assignment chains

Chaining assignments or nesting assignments in other expressions can result in surprising behavior. For this reason, chaining assignments in the same statement is discouraged).

In particular, putting a variable chain in a operand1 operator operand2 14, operand1 operator operand2 15, or operand1 operator operand2 16 statement often does not work. Only the outermost/leftmost variable would get declared; other variables within the assignment chain are not declared by the operand1 operator operand2 14/operand1 operator operand2 15/operand1 operator operand2 16 statement. For example:

operand1 operator operand2 0

This statement seemingly declares the variables const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0, operand1 operator operand2 35, and operator operand operand operator 21. However, it only actually declares the variable operator operand operand operator 21. operand1 operator operand2 35 and const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 are either invalid references to nonexistent variables (in strict mode) or, worse, would implicitly create global variables for const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 0 and operand1 operator operand2 35 in sloppy mode.

Comparison operators

A comparison operator compares its operands and returns a logical value based on whether the comparison is true. The operands can be numerical, string, logical, or object values. Strings are compared based on standard lexicographical ordering, using Unicode values. In most cases, if the two operands are not of the same type, JavaScript attempts to convert them to an appropriate type for the comparison. This behavior generally results in comparing the operands numerically. The sole exceptions to type conversion within comparisons involve the operator operand operand operator 27 and operator operand operand operator 28 operators, which perform strict equality and inequality comparisons. These operators do not attempt to convert the operands to compatible types before checking equality. The following table describes the comparison operators in terms of this sample code:

operand1 operator operand2 1

operator operand operand operator 32

Note: operator operand operand operator 56 is not a comparison operator but rather is the notation for Arrow functions.

Arithmetic operators

An arithmetic operator takes numerical values (either literals or variables) as their operands and returns a single numerical value. The standard arithmetic operators are addition (const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 3), subtraction (operator operand operand operator 58), multiplication (// Declares a variable x and initializes it to the result of f(). // The result of the x = f() assignment expression is discarded. let x = f(); x = g(); // Reassigns the variable x to the result of g(). 0), and division (operator operand operand operator 60). These operators work as they do in most other programming languages when used with floating point numbers (in particular, note that division by zero produces operator operand operand operator 61). For example:

operand1 operator operand2 2

In addition to the standard arithmetic operations (const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 3, operator operand operand operator 58, // Declares a variable x and initializes it to the result of f(). // The result of the x = f() assignment expression is discarded. let x = f(); x = g(); // Reassigns the variable x to the result of g(). 0, operator operand operand operator 60), JavaScript provides the arithmetic operators listed in the following table:

operator operand operand operator 85 returns const foo = ['one', 'two', 'three']; // without destructuring const one = foo[0]; const two = foo[1]; const three = foo[2]; // with destructuring const [one, two, three] = foo; 4.

operator operand operand operator 87 returns operator operand operand operator 88.

Bitwise operators

A bitwise operator treats their operands as a set of 32 bits (zeros and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the decimal number nine has a binary representation of 1001. Bitwise operators perform their operations on such binary representations, but they return standard JavaScript numerical values.

The following table summarizes JavaScript's bitwise operators.

Bitwise logical operators

Conceptually, the bitwise logical operators work as follows:

• The operands are converted to thirty-two-bit integers and expressed by a series of bits (zeros and ones). Numbers with more than 32 bits get their most significant bits discarded. For example, the following integer with more than 32 bits will be converted to a 32-bit integer:

  operand1 operator operand2 3

• Each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on.
• The operator is applied to each pair of bits, and the result is constructed bitwise.

For example, the binary representation of nine is 1001, and the binary representation of fifteen is 1111. So, when the bitwise operators are applied to these values, the results are as follows:

Note that all 32 bits are inverted using the Bitwise NOT operator, and that values with the most significant (left-most) bit set to 1 represent negative numbers (two's-complement representation). const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 25 evaluates to the same value that const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 26 evaluates to.

Bitwise shift operators

The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.

Shift operators convert their operands to thirty-two-bit integers and return a result of either type const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 27 or const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 28: specifically, if the type of the left operand is const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 28, they return const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 28; otherwise, they return const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 27.

The shift operators are listed in the following table.

Logical operators

Logical operators are typically used with Boolean (logical) values; when they are, they return a Boolean value. However, the const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 39 and const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 40 operators actually return the value of one of the specified operands, so if these operators are used with non-Boolean values, they may return a non-Boolean value. The logical operators are described in the following table.

Examples of expressions that can be converted to const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 44 are those that evaluate to null, 0, NaN, the empty string (""), or undefined.

The following code shows examples of the const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 39 (logical AND) operator.

operand1 operator operand2 4

The following code shows examples of the || (logical OR) operator.

operand1 operator operand2 5

The following code shows examples of the ! (logical NOT) operator.

operand1 operator operand2 6

Short-circuit evaluation

As logical expressions are evaluated left to right, they are tested for possible "short-circuit" evaluation using the following rules:

• const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 64 is short-circuit evaluated to false.
• const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 65 is short-circuit evaluated to true.

The rules of logic guarantee that these evaluations are always correct. Note that the anything part of the above expressions is not evaluated, so any side effects of doing so do not take effect.

Note that for the second case, in modern code you can use the Nullish coalescing operator (const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 66) that works like const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 40, but it only returns the second expression, when the first one is "nullish", i.e. operand1 operator operand2 12 or operand1 operator operand2 13. It is thus the better alternative to provide defaults, when values like const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 70 or const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 71 are valid values for the first expression, too.

BigInt operators

Most operators that can be used between numbers can be used between const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 28 values as well.

operand1 operator operand2 7

One exception is unsigned right shift (const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 37), which is not defined for BigInt values. This is because a BigInt does not have a fixed width, so technically it does not have a "highest bit".

operand1 operator operand2 8

BigInts and numbers are not mutually replaceable — you cannot mix them in calculations.

operand1 operator operand2 9

This is because BigInt is neither a subset nor a superset of numbers. BigInts have higher precision than numbers when representing large integers, but cannot represent decimals, so implicit conversion on either side might lose precision. Use explicit conversion to signal whether you wish the operation to be a number operation or a BigInt one.

operator operand operand operator 0

You can compare BigInts with numbers.

operator operand operand operator 1

String operators

In addition to the comparison operators, which can be used on string values, the concatenation operator (+) concatenates two string values together, returning another string that is the union of the two operand strings.

For example,

operator operand operand operator 2

The shorthand assignment operator const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 74 can also be used to concatenate strings.

For example,

operator operand operand operator 3

Conditional (ternary) operator

The conditional operator is the only JavaScript operator that takes three operands. The operator can have one of two values based on a condition. The syntax is:

operator operand operand operator 4

If const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 75 is true, the operator has the value of const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 76. Otherwise it has the value of const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 77. You can use the conditional operator anywhere you would use a standard operator.

For example,

operator operand operand operator 5

This statement assigns the value "adult" to the variable const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 78 if const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 79 is eighteen or more. Otherwise, it assigns the value "minor" to const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 78.

Comma operator

The comma operator (const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 81) evaluates both of its operands and returns the value of the last operand. This operator is primarily used inside a const obj = {}; obj.x = 3; console.log(obj.x); // Prints 3. console.log(obj); // Prints { x: 3 }. const key = "y"; obj[key] = 5; console.log(obj[key]); // Prints 5. console.log(obj); // Prints { x: 3, y: 5 }. 82 loop, to allow multiple variables to be updated each time through the loop. It is regarded bad style to use it elsewhere, when it is not necessary. Often two separate statements can and should be used instead.