This page is a work in progress.You can help improve it. →

Operators

This section describes TypeScript's expressions and operators, including assignment, comparison, arithmetic, bitwise, logical, string, ternary and more.

A complete and detailed list of operators and expressions is also available in the MDN reference

TypeScript has the following types of operators. This section describes the operators and contains information about operator precedence.

• Assignment operators
• Comparison operators
• Arithmetic operators
• Bitwise operators
• Logical operators
• String operators
• Conditional (ternary) operator
• Comma operator
• Unary operators
• Relational operators

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 (=), which assigns the value of its right operand to its left operand. That is, x = y assigns the value of y to x.

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

NameShorthand operatorMeaning
Assignment`x = y``x = y`
Addition assignment`x += y``x = x + y`
Subtraction assignment`x -= y``x = x - y`
Multiplication assignment`x *= y``x = x * y`
Division assignment`x /= y``x = x / y`
Remainder assignment`x %= y``x = x % y`
Exponentiation assignment`x **= y``x = x ** y`
Left shift assignment`x <<= y``x = x << y`
Right shift assignment`x >>= y``x = x >> y`
Unsigned right shift assignment`x >>>= y``x = x >>> y`
Bitwise AND assignment`x &= y``x = x & y`
Bitwise XOR assignment`x ^= y``x = x ^ y`
Bitwise OR assignment`x= y``x = xy`

Destructuring Assignment

For more complex assignments, the destructuring assignment syntax is a TypeScript 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 numbers = ['one', 'two', 'three']// without destructuringconst one = numbers[0]const two = numbers[1]const three = numbers[2]// with destructuringconst [one, two, three] = numbers``

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 ordering. In most cases, if the two operands are not of the same type, TypeScript 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 === and !== 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:

``const var1 = 3const var2 = 4``
OperatorDescriptionExamples returning true
Equal (`==`)Returns true if the operands are equal.`3 == var1`
`"3" == var1`
`3 == '3'`
Not equal (`!=`)Returns true if the operands are not equal.`var1 != 4`
`var2 != "3"`
Strict equal (`===`)Returns true if the operands are equal and of the same type. See also Object.is and sameness in JS.`3 === var1`
Strict not equal (`!==`)Returns true if the operands are of the same type but not equal, or are of different type.`var1 !== "3"`
`3 !== '3'`
Greater than (`>`)Returns true if the left operand is greater than the right operand.`var2 > var1`
`"12" > 2`
Greater than or equal (`>=`)Returns true if the left operand is greater than or equal to the right operand.`var2 >= var1`
`var1 >= 3`
Less than (`<`)Returns true if the left operand is less than the right operand.`var1 < var2`
`"2" < 12`
Less than or equal (`<=`)Returns true if the left operand is less than or equal to the right operand.`var1 <= var2`
`var2 <= 5`

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 (+), subtraction (-), multiplication (*), and division (/). 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 Infinity). For example:

``1 / 2 // 0.51 / 2 == 1.0 / 2.0 // this is true``

In addition to the standard arithmetic operations (+, -, * /), TypeScript provides the arithmetic operators listed in the following table:

OperatorDescriptionExample
Remainder (`%`)Binary operator. Returns the integer remainder of dividing the two operands.`12 % 5` returns `2`.
Increment (++)Unary operator. Adds one to its operand. If used as a prefix operator (`++x`), returns the value of its operand after adding one; if used as a postfix operator (`x++`), returns the value of its operand before adding one.If `x` is `3`, then `++x` sets `x` to `4` and returns `4`, whereas `x++` returns `3` and, only then, sets `x` to `4`.
Decrement (`--`)Unary operator. Subtracts one from its operand. The return value is analogous to that for the increment operator.If `x` is `3, then`--x`sets`x`to`2`and returns`2`, whereas`x--`returns`3`and, only then, sets`x`to`2`.
Unary negation (`-`)Unary operator. Returns the negation of its operand.If `x` is `3`, then `-x` returns `-3`.
Unary plus (`+`)Unary operator. Attempts to convert the operand to a number, if it is not already.`+"3"` returns `3`.
`+true` returns `1`.
Exponentiation operator (`**`)Calculates the base to the exponent power, that is, baseexponent`2 ** 3` returns `8`.
`10 ** -1` returns `0.1`.

Bitwise operators

Bitwise operators aren't used very often, but they are useful to understand

Logical operators

Logical operators are typically used with Boolean (logical) values; when they are, they return a Boolean value. However, the && and || 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.

OperatorUsageDescription
Logical AND
`&&`
`expr1 && expr2`
Returns `expr1` if it can be converted to `false`; otherwise, returns `expr2`. Thus, when used with Boolean values, `&&` returns `true` if both operands are `true`; otherwise, returns `false`.
Logical OR
`||`
`expr1 || expr2`
Returns expr1 if it can be converted to true; otherwise, returns expr2. Thus, when used with Boolean values,returns true if either operand is true; if both are false, returns false.
Logical NOT
`!`
`!expr`
Returns false if its single operand that can be converted to true; otherwise, returns true.

© 2017 - 2021; Built with ♥ in St. Petersburg, Florida.