Comparisons
We know many comparison operators from maths.
In JavaScript they are written like this:
 Greater/less than: a > b , a < b .
 Greater/less than or equals: a >= b , a <= b .
 Equals: a == b , please note the double equality sign == means the equality test, while a single one a = b means an assignment.
 Not equals: In maths the notation is â , but in JavaScript itâs written as a != b .
In this article weâll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities.
At the end youâll find a good recipe to avoid âJavaScript quirksârelated issues.
Boolean is the result
All comparison operators return a boolean value:
 true â means âyesâ, âcorrectâ or âthe truthâ.
 false â means ânoâ, âwrongâ or ânot the truthâ.
For example:
A comparison result can be assigned to a variable, just like any value:
String comparison
To see whether a string is greater than another, JavaScript uses the socalled âdictionaryâ or âlexicographicalâ order.
In other words, strings are compared letterbyletter.
The algorithm to compare two strings is simple:
 Compare the first character of both strings.
 If the first character from the first string is greater (or less) than the other stringâs, then the first string is greater (or less) than the second. Weâre done.
 Otherwise, if both stringsâ first characters are the same, compare the second characters the same way.
 Repeat until the end of either string.
 If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
In the first example above, the comparison 'Z' > 'A' gets to a result at the first step.
The second comparison 'Glow' and 'Glee' needs more steps as strings are compared characterbycharacter:
 G is the same as G .
 l is the same as l .
 o is greater than e . Stop here. The first string is greater.
The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but itâs not exactly the same.
For instance, case matters. A capital letter "A" is not equal to the lowercase "a" . Which one is greater? The lowercase "a" . Why? Because the lowercase character has a greater index in the internal encoding table JavaScript uses (Unicode). Weâll get back to specific details and consequences of this in the chapter Strings .
Comparison of different types
When comparing values of different types, JavaScript converts the values to numbers.
For boolean values, true becomes 1 and false becomes 0 .
It is possible that at the same time:
 Two values are equal.
 One of them is true as a boolean and the other one is false as a boolean.
From JavaScriptâs standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence "0" becomes 0 ), while the explicit Boolean conversion uses another set of rules.
Strict equality
A regular equality check == has a problem. It cannot differentiate 0 from false :
The same thing happens with an empty string:
This happens because operands of different types are converted to numbers by the equality operator == . An empty string, just like false , becomes a zero.
What to do if weâd like to differentiate 0 from false ?
A strict equality operator === checks the equality without type conversion.
In other words, if a and b are of different types, then a === b immediately returns false without an attempt to convert them.
Letâs try it:
There is also a âstrict nonequalityâ operator !== analogous to != .
The strict equality operator is a bit longer to write, but makes it obvious whatâs going on and leaves less room for errors.
Comparison with null and undefined
Thereâs a nonintuitive behavior when null or undefined are compared to other values.
These values are different, because each of them is a different type.
Thereâs a special rule. These two are a âsweet coupleâ: they equal each other (in the sense of == ), but not any other value.
null/undefined are converted to numbers: null becomes 0 , while undefined becomes NaN .
Now letâs see some funny things that happen when we apply these rules. And, whatâs more important, how to not fall into a trap with them.
Strange result: null vs 0
Letâs compare null with a zero:
Mathematically, thatâs strange. The last result states that " null is greater than or equal to zero", so in one of the comparisons above it must be true , but they are both false.
The reason is that an equality check == and comparisons > < >= <= work differently. Comparisons convert null to a number, treating it as 0 . Thatâs why (3) null >= 0 is true and (1) null > 0 is false.
On the other hand, the equality check == for undefined and null is defined such that, without any conversions, they equal each other and donât equal anything else. Thatâs why (2) null == 0 is false.
An incomparable undefined
The value undefined shouldnât be compared to other values:
Why does it dislike zero so much? Always false!
We get these results because:
 Comparisons (1) and (2) return false because undefined gets converted to NaN and NaN is a special numeric value which returns false for all comparisons.
 The equality check (3) returns false because undefined only equals null , undefined , and no other value.
Avoid problems
Why did we go over these examples? Should we remember these peculiarities all the time? Well, not really. Actually, these tricky things will gradually become familiar over time, but thereâs a solid way to avoid problems with them:
 Treat any comparison with undefined/null except the strict equality === with exceptional care.
 Donât use comparisons >= > < <= with a variable which may be null/undefined , unless youâre really sure of what youâre doing. If a variable can have these values, check for them separately.
 Comparison operators return a boolean value.
 Strings are compared letterbyletter in the âdictionaryâ order.
 When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
 The values null and undefined equal == each other and do not equal any other value.
 Be careful when using comparisons like > or < with variables that can occasionally be null/undefined . Checking for null/undefined separately is a good idea.
What will be the result for these expressions?
Some of the reasons:
 Obviously, true.
 Dictionary comparison, hence false. "a" is smaller than "p" .
 Again, dictionary comparison, first char "2" is greater than the first char "1" .
 Values null and undefined equal each other only.
 Strict equality is strict. Different types from both sides lead to false.
 Similar to (4) , null only equals undefined .
 Strict equality of different types.
 If you have suggestions what to improve  please submit a GitHub issue or a pull request instead of commenting.
 If you can't understand something in the article â please elaborate.
 To insert few words of code, use the <code> tag, for several lines â wrap them in <pre> tag, for more than 10 lines â use a sandbox ( plnkr , jsbin , codepen âŠ)
Lesson navigation
 Â© 2007â2024 Ilya Kantor
 about the project
 terms of usage
 privacy policy
 Skip to main content
 Select language
 Skip to search
 Expressions and operators
 Operator precedence
Lefthandside expressions
Â« Previous Next Â»
This chapter describes JavaScript'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 reference .
JavaScript 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 operator
JavaScript has both binary and unary operators, and one special ternary operator, the conditional operator. A binary operator requires two operands, one before the operator and one after the operator:
For example, 3+4 or x*y .
A unary operator requires a single operand, either before or after the operator:
For example, x++ or ++x .
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:
Name  Shorthand operator  Meaning 

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.
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 === 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:
Operator  Description  Examples returning true 

( )  Returns if the operands are equal. 

( )  Returns if the operands are not equal.  
( )  Returns if the operands are equal and of the same type. See also and .  
( )  Returns if the operands are of the same type but not equal, or are of different type.  
( )  Returns if the left operand is greater than the right operand.  
( )  Returns if the left operand is greater than or equal to the right operand.  
( )  Returns if the left operand is less than the right operand.  
( )  Returns if the left operand is less than or equal to the right operand. 
Note:Â ( => )Â is not an operator, but the notation for Arrow functions .
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:
In addition to the standard arithmetic operations (+, , * /), JavaScript provides the arithmetic operators listed in the following table:
Operator  Description  Example 

( )  Binary operator. Returns the integer remainder of dividing the two operands.  12 % 5 returns 2. 
( )  Unary operator. Adds one to its operand. If used as a prefix operator ( ), returns the value of its operand after adding one; if used as a postfix operator ( ), returns the value of its operand before adding one.  If is 3, then sets to 4 and returns 4, whereas returns 3 and, only then, sets to 4. 
( )  Unary operator. Subtracts one from its operand. The return value is analogous to that for the increment operator.  If is 3, then sets to 2 and returns 2, whereas returns 3 and, only then, sets to 2. 
( )  Unary operator. Returns the negation of its operand.  If is 3, then returns 3. 
( )  Unary operator. Attempts to convert the operand to a number, if it is not already.  returns . returns 
( )  Calculates the to theÂ power, that is,  returns . returns . 
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.
Operator  Usage  Description 

Returns a one in each bit position for which the corresponding bits of both operands are ones.  
Returns a zero in each bit position for which the corresponding bits of both operands are zeros.  
Returns a zero in each bit position for which the corresponding bits are the same. [Returns a one in each bit position for which the corresponding bits are different.]  
Inverts the bits of its operand.  
Shifts in binary representation bits to the left, shifting in zeros from the right.  
Shifts in binary representation bits to the right, discarding bits shifted off.  
Shifts in binary representation bits to the right, discarding bits shifted off, and shifting in zeros from the left. 
Bitwise logical operators
Conceptually, the bitwise logical operators work as follows:
 The operands are converted to thirtytwobit 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: Before: 11100110111110100000000000000110000000000001 After: 10100000000000000110000000000001
 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:
Expression  Result  Binary Description 

Note that all 32 bits are inverted using the Bitwise NOT operator, and that values with the most significant (leftmost) bit set to 1 represent negative numbers (two'scomplement representation).
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 thirtytwobit integers and return a result of the same type as the left operand.
The shift operators are listed in the following table.
Operator  Description  Example 

( )  This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right.  yields 36, because 1001 shifted 2 bits to the left becomes 100100, which is 36. 
( )  This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left.  yields 2, because 1001 shifted 2 bits to the right becomes 10, which is 2. Likewise, yields 3, because the sign is preserved. 
( )  This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left.  yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For nonnegative numbers, zerofill right shift and signpropagating right shift yield the same result. 
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 nonBoolean values, they may return a nonBoolean value. The logical operators are described in the following table.
Operator  Usage  Description 

( )  Returns if it can be converted to ; otherwise, returns . Thus, when used with Boolean values, returns if both operands are true; otherwise, returns .  
( )  Returns if it can be converted to ; otherwise, returns . Thus, when used with Boolean values, returns if either operand is true; if both are false, returns .  
( )  Returns if its single operand can be converted to ; otherwise, returns . 
Examples of expressions that can be converted to false are those that evaluate to null, 0, NaN, the empty string (""), or undefined.
The following code shows examples of the && (logical AND) operator.
The following code shows examples of the  (logical OR) operator.
The following code shows examples of the ! (logical NOT) operator.
Shortcircuit evaluation
As logical expressions are evaluated left to right, they are tested for possible "shortcircuit" evaluation using the following rules:
 false && anything is shortcircuit evaluated to false.
 true  anything is shortcircuit 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.
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,
The shorthand assignment operator += can also be used to concatenate strings.
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:
If condition is true, the operator has the value of val1 . Otherwise it has the value of val2 . You can use the conditional operator anywhere you would use a standard operator.
This statement assigns the value "adult" to the variable status if age is eighteen or more. Otherwise, it assigns the value "minor" to status .
The comma operator ( , ) simply evaluates both of its operands and returns the value of the last operand. This operator is primarily used inside a for loop, to allow multiple variables to be updated each time through the loop.
For example, if a is a 2dimensional array with 10 elements on a side, the following code uses the comma operator to updateÂ two variables at once. The code prints the values of the diagonal elements in the array:
A unary operation is an operation with only one operand.
The delete operator deletes an object, an object's property, or an element at a specified index in an array. The syntax is:
where objectName is the name of an object, property is an existing property, and index is an integer representing the location of an element in an array.
The fourth form is legal only within a with statement, to delete a property from an object.
You can use the delete operator to delete variables declared implicitly but not those declared with the var statement.
If the delete operator succeeds, it sets the property or element to undefined . The delete operator returns true if the operation is possible; it returns false if the operation is not possible.
Deleting array elements
When you delete an array element, the array length is not affected. For example, if you delete a[3] , a[4] is still a[4] and a[3] is undefined.
When the delete operator removes an array element, that element is no longer in the array. In the following example, trees[3] is removed with delete . However, trees[3] is still addressable and returns undefined .
If you want an array element to exist but have an undefined value, use the undefined keyword instead of the delete operator. In the following example, trees[3] is assigned the value undefined , but the array element still exists:
The typeof operator is used in either of the following ways:
The typeof operator returns a string indicating the type of the unevaluated operand. operand is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.
Suppose you define the following variables:
The typeof operator returns the following results for these variables:
For the keywords true and null , the typeof operator returns the following results:
For a number or string, the typeof operator returns the following results:
For property values, the typeof operator returns the type of value the property contains:
For methods and functions, the typeof operator returns results as follows:
For predefined objects, the typeof operator returns results as follows:
The void operator is used in either of the following ways:
The void operator specifies an expression to be evaluated without returning a value. expression is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them.
You can use the void operator to specify an expression as a hypertext link. The expression is evaluated but is not loaded in place of the current document.
The following code creates a hypertext link that does nothing when the user clicks it. When the user clicks the link, void(0) evaluates to undefined , which has no effect in JavaScript.
The following code creates a hypertext link that submits a form when the user clicks it.
Relational operators
A relational operator compares its operands and returns a Boolean value based on whether the comparison is true.
The in operator returns true if the specified property is in the specified object. The syntax is:
where propNameOrNumber is a string or numeric expression representing a property name or array index, and objectName is the name of an object.
The following examples show some uses of the in operator.
The instanceof operator returns true if the specified object is of the specified object type. The syntax is:
where objectName is the name of the object to compare to objectType , and objectType is an object type, such as Date or Array .
Use instanceof when you need to confirm the type of an object at runtime. For example, when catching exceptions, you can branch to different exceptionhandling code depending on the type of exception thrown.
For example, the following code uses instanceof to determine whether theDay is a Date object. Because theDay is a Date object, the statements in the if statement execute.
The precedence of operators determines the order they are applied when evaluating an expression. You can override operator precedence by using parentheses.
The following table describes the precedence of operators, from highest to lowest.
Operator type  Individual operators 

member  
call / create instance  
negation/increment  
multiply/divide  
addition/subtraction  
bitwise shift  
relational  
equality  
bitwiseand  
bitwisexor  
bitwiseor  
logicaland  
logicalor  
conditional  
assignment  
comma 
A more detailed version of this table, complete with links to additional details about each operator, may be found in JavaScript Reference .
 Expressions
An expression is any valid unit of code that resolves to a value.
Every syntactically valid expression resolves to some value but conceptually, there are two types of expressions: with side effects (for example: those that assign value to a variable) and those that in some sense evaluates and therefore resolves to value.
The expression x = 7 is an example of the first type. This expression uses the = operator to assign the value seven to the variable x . The expression itself evaluates to seven.
The code 3 + 4 is an example of the second expression type. This expression uses the + operator to add three and four together without assigning the result, seven, to a variable. JavaScript has the following expression categories:
 Arithmetic: evaluates to a number, for example 3.14159. (Generally uses arithmetic operators .)
 String: evaluates to a character string, for example, "Fred" or "234". (Generally uses string operators .)
 Logical: evaluates to true or false. (Often involves logical operators .)
 Primary expressions: Basic keywords and general expressions in JavaScript.
 Lefthandside expressions: Left values are the destination of an assignment.
Primary expressions
Basic keywords and general expressions in JavaScript.
Use the this keyword to refer to the current object. In general, this refers to the calling object in a method. Use this either with the dot or the bracket notation:
Suppose a function called validate validates an object's value property, given the object and the high and low values:
You could call validate in each form element's onChange event handler, using this to pass it the form element, as in the following example:
 Grouping operator
The grouping operator ( ) controls the precedence of evaluation in expressions. For example, you can override multiplication and division first, then addition and subtraction to evaluate addition first.
Comprehensions
Comprehensions are an experimental JavaScript feature, targeted to be included in a future ECMAScript version. There are two versions of comprehensions:
Comprehensions exist in many programming languages and allow you to quickly assemble a new array based on an existing one, for example.
Left values are the destination of an assignment.
You can use the new operator to create an instance of a userdefined object type or of one of the builtin object types. Use new as follows:
The super keyword is used to call functions on an object's parent. It is useful with classes to call the parent constructor, forÂ example.
Spread operator
The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.
Example: Today if you have an array and want to create a new array with the existing one being part of it, the array literal syntax is no longer sufficient and you have to fall back to imperative code, using a combination of push , splice , concat , etc. With spread syntax this becomes much more succinct:
Similarly, the spread operator works with function calls:
Document Tags and Contributors
 l10n:priority
 JavaScript basics
 JavaScript first steps
 JavaScript building blocks
 Introducing JavaScript objects
 Introduction
 Grammar and types
 Control flow and error handling
 Loops and iteration
 Numbers and dates
 Text formatting
 Regular expressions
 Indexed collections
 Keyed collections
 Working with objects
 Details of the object model
 Iterators and generators
 Meta programming
 A reintroduction to JavaScript
 JavaScript data structures
 Equality comparisons and sameness
 Inheritance and the prototype chain
 Strict mode
 JavaScript typed arrays
 Memory Management
 Concurrency model and Event Loop
 References:
 ArrayBuffer
 AsyncFunction
 Float32Array
 Float64Array
 GeneratorFunction
 InternalError
 Intl.Collator
 Intl.DateTimeFormat
 Intl.NumberFormat
 ParallelArray
 ReferenceError
 SIMD.Bool16x8
 SIMD.Bool32x4
 SIMD.Bool64x2
 SIMD.Bool8x16
 SIMD.Float32x4
 SIMD.Float64x2
 SIMD.Int16x8
 SIMD.Int32x4
 SIMD.Int8x16
 SIMD.Uint16x8
 SIMD.Uint32x4
 SIMD.Uint8x16
 SharedArrayBuffer
 StopIteration
 SyntaxError
 Uint16Array
 Uint32Array
 Uint8ClampedArray
 WebAssembly
 decodeURI()
 decodeURIComponent()
 encodeURI()
 encodeURIComponent()
 parseFloat()
 Array comprehensions
 Conditional (ternary) Operator
 Destructuring assignment
 Expression closures
 Generator comprehensions
 Legacy generator function expression
 Logical Operators
 Object initializer
 Property accessors
 Spread syntax
 async function expression
 class expression
 delete operator
 function expression
 function* expression
 in operator
 new operator
 void operator
 Legacy generator function
 async function
 for each...in
 function declaration
 try...catch
 Arguments object
 Arrow functions
 Default parameters
 Method definitions
 Rest parameters
 constructor
 element loaded from a different domain for which you violated the sameorigin policy.">Error: Permission denied to access property "x"
 InternalError: too much recursion
 RangeError: argument is not a valid code point
 RangeError: invalid array length
 RangeError: invalid date
 RangeError: precision is out of range
 RangeError: radix must be an integer
 RangeError: repeat count must be less than infinity
 RangeError: repeat count must be nonnegative
 ReferenceError: "x" is not defined
 ReferenceError: assignment to undeclared variable "x"
 ReferenceError: can't access lexical declaration`X' before initialization
 ReferenceError: deprecated caller or arguments usage
 ReferenceError: invalid assignment lefthand side
 ReferenceError: reference to undefined property "x"
 SyntaxError: "0"prefixed octal literals and octal escape seq. are deprecated
 SyntaxError: "use strict" not allowed in function with nonsimple parameters
 SyntaxError: "x" is a reserved identifier
 SyntaxError: JSON.parse: bad parsing
 SyntaxError: Malformed formal parameter
 SyntaxError: Unexpected token
 SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
 SyntaxError: a declaration in the head of a forof loop can't have an initializer
 SyntaxError: applying the 'delete' operator to an unqualified name is deprecated
 SyntaxError: forin loop head declarations may not have initializers
 SyntaxError: function statement requires a name
 SyntaxError: identifier starts immediately after numeric literal
 SyntaxError: illegal character
 SyntaxError: invalid regular expression flag "x"
 SyntaxError: missing ) after argument list
 SyntaxError: missing ) after condition
 SyntaxError: missing : after property id
 SyntaxError: missing ; before statement
 SyntaxError: missing = in const declaration
 SyntaxError: missing ] after element list
 SyntaxError: missing formal parameter
 SyntaxError: missing name after . operator
 SyntaxError: missing variable name
 SyntaxError: missing } after function body
 SyntaxError: missing } after property list
 SyntaxError: redeclaration of formal parameter "x"
 SyntaxError: return not in function
 SyntaxError: test for equality (==) mistyped as assignment (=)?
 SyntaxError: unterminated string literal
 TypeError: "x" has no properties
 TypeError: "x" is (not) "y"
 TypeError: "x" is not a constructor
 TypeError: "x" is not a function
 TypeError: "x" is not a nonnull object
 TypeError: "x" is readonly
 TypeError: More arguments needed
 TypeError: can't access dead object
 TypeError: can't define property "x": "obj" is not extensible
 TypeError: can't delete nonconfigurable array element
 TypeError: can't redefine nonconfigurable property "x"
 TypeError: cyclic object value
 TypeError: invalid 'in' operand "x"
 TypeError: invalid Array.prototype.sort argument
 TypeError: invalid arguments
 TypeError: invalid assignment to const "x"
 TypeError: property "x" is nonconfigurable and can't be deleted
 TypeError: setting getteronly property "x"
 TypeError: variable "x" redeclares argument
 URIError: malformed URI sequence
 Warning: file is being assigned a //# sourceMappingURL, but already has one
 Warning: 08/09 is not a legal ECMA262 octal constant
 Warning: Date.prototype.toLocaleFormat is deprecated
 Warning: JavaScript 1.6's foreachin loops are deprecated
 Warning: String.x is deprecated; use String.prototype.x instead
 Warning: expression closures are deprecated
 Warning: unreachable code after return statement
 JavaScript technologies overview
 Lexical grammar
 Enumerability and ownership of properties
 Iteration protocols
 Transitioning to strict mode
 Template literals
 Deprecated features
 ECMAScript 2015 support in Mozilla
 ECMAScript 5 support in Mozilla
 ECMAScript Next support in Mozilla
 Firefox JavaScript changelog
 New in JavaScript 1.1
 New in JavaScript 1.2
 New in JavaScript 1.3
 New in JavaScript 1.4
 New in JavaScript 1.5
 New in JavaScript 1.6
 New in JavaScript 1.7
 New in JavaScript 1.8
 New in JavaScript 1.8.1
 New in JavaScript 1.8.5
 Documentation:
 All pages index
 Methods index
 Properties index
 Pages tagged "JavaScript"
 JavaScript doc status
 The MDN project
Difference Between =, ==, and === in JavaScript [Examples]
What is = in JavaScript?
Equal to (=) is an assignment operator, which sets the variable on the left of the = to the value of the expression that is on its right. This operator assigns lvalue to rvalue.
For example, Writing a=10 is fine. If we write 10=10, ‘a’ = 10 or ‘a’ = ‘a’, it will result in a reference error.
What is == in JavaScript?
Double equals (==) is a comparison operator, which transforms the operands having the same type before comparison.
So, when you compare string with a number, JavaScript converts any string to a number. An empty string is always converts to zero. A string with no numeric value is converts to NaN (Not a Number), which returns false.
What is === in JavaScript?
=== (Triple equals) is a strict equality comparison operator in JavaScript, which returns false for the values which are not of a similar type. This operator performs type casting for equality. If we compare 2 with “2” using ===, then it will return a false value.
Why use = in JavaScript?
The basic assignment operator is =, that assigns the value of one operand to another. That is, a = b assigns the value of b to a.
Why use == in JavaScript?
Here are the important uses of == in JavaScript:
The == operator is an equality operator. It checks whether its two operands are the same or not by changing expression from one data type to others. You can use == operator in order to compare the identity of two operands even though, they are not of a similar type.
How === Works Exactly?
 Strict equality === checks that two values are the same or not.
 Value are not implicitly converted to some other value before comparison.
 If the variable values are of different types, then the values are considered as unequal.
 If the variable are of the same type, are not numeric, and have the same value, they are considered as equal.
 Lastly, If both variable values are numbers, they are considered equal if both are not NaN (Not a Number) and are the same value.
Example of =
In the below program, there are two variables “a” and “b”. We are adding and printing their values using a third variable, “c”. The sum of the value of variable “a” and “b” is 7. Therefore, the output is 7.
a = 2, b = 5, calculate c = a + b, and display c:
Example of ==
In the below program, we have declared one variable “a” having value 10. Lastly, the statement a == 20 returns false as the value of a is 10.
Example of ===
In the below program, the value of variable x is 10. It is compared to 10 written in doublequotes, which is considered as a string , and therefore, the values are not strictly the same. The output of the program is false.
= Vs == VS === in JavaScript
=  ==  === 

= in JavaScript is used for assigning values to a variable.  == in JavaScript is used for comparing two variables, but it ignores the datatype of variable.  === is used for comparing two variables, but this operator also checks datatype and compares two values. 
It is called as assignment operator  It is called as comparison operator  It is also called as comparison operator 
The assignment operator can evaluate to the assigned value  Checks the equality of two operands without considering their type.  Compares equality of two operands with their types. 
It does not return true or false  Return true if the two operands are equal. It will return false if the two operands are not equal.  It returns true only if both values and data types are the same for the two variables. 
= simply assign one value of variable to another one.  == make type correction based upon values of .  === takes type of variable in consideration. 
== will not compare the value of variables at all.  The == checks for equality only after doing necessary conversations.  If two variable values are not similar, then === will not perform any conversion. 
KEY DIFFERENCES
 = is used for assigning values to a variable, == is used for comparing two variables, but it ignores the datatype of variable whereas === is used for comparing two variables, but this operator also checks datatype and compares two values.
 = is called as assignment operator, == is called as comparison operator whereas It is also called as comparison operator.
 = does not return true or false, == Return true only if the two operands are equal while === returns true only if both values and data types are the same for the two variables.
 Execute JavaScript Online
 TypeScript vs JavaScript â Difference Between Them
 QuickSort Algorithm in JavaScript
 15 Best FREE JavaScript Certification Courses Online (2024)
 Java vs JavaScript – Difference Between Them
 13 BEST JavaScript Books for Beginners (2024 Update)
 19 Best FREE JavaScript IDE & Editor (2024 Update)
 JavaScript String Format: Methods with EXAMPLES
Learn JavaScript Operators â Logical, Comparison, Ternary, and More JS Operators With Examples
JavaScript has many operators that you can use to perform operations on values and variables (also called operands)
Based on the types of operations these JS operators perform, we can divide them up into seven groups:
Arithmetic Operators
Assignment operators, comparison operators, logical operators.
 Ternary Operators
The typeof Operator
Bitwise operators.
In this handbook, you're going to learn how these operators work with examples. Let's start with arithmetic operators.
The arithmetic operators are used to perform mathematical operations like addition and subtraction.
These operators are frequently used with number data types, so they are similar to a calculator. The following example shows how you can use the + operator to add two variables together:
Here, the two variables x and y are added together using the plus + operator. We also used the console.log() method to print the result of the operation to the screen.
You can use operators directly on values without assigning them to any variable too:
In JavaScript, we have 8 arithmetic operators in total. They are:
 Subtraction 
 Multiplication *
 Remainder %
 Exponentiation **
 Increment ++
 Decrement 
Let's see how these operators work one by one.
1. Addition operator
The addition operator + is used to add two or more numbers together. You've seen how this operator works previously, but here's another example:
You can use the addition operator on both integer and floating numbers.
2. Subtraction operator
The subtraction operator is marked by the minus sign â and you can use it to subtract the right operand from the left operand.
For example, here's how to subtract 3 from 5:
3. Multiplication operator
The multiplication operator is marked by the asterisk * symbol, and you use it to multiply the value on the left by the value on the right of the operator.
4. Division operator
The division operator / is used to divide the left operand by the right operand. Here are some examples of using the operator:
5. Remainder operator
The remainder operator % is also known as the modulo or modulus operator. This operator is used to calculate the remainder after a division has been performed.
A practical example should make this operator easier to understand, so let's see one:
The number 10 can't be divided by 3 perfectly. The result of the division is 3 with a remainder of 1. The remainder operator simply returns that remainder number.
If the left operand can be divided with no remainder, then the operator returns 0.
This operator is commonly used when you want to check if a number is even or odd. If a number is even, dividing it by 2 will result in a remainder of 0, and if it's odd, the remainder will be 1.
6. Exponentiation operator
The exponentiation operator is marked by two asterisks ** . It's one of the newer JavaScript operators and you can use it to calculate the power of a number (based on its exponent).
For example, here's how to calculate 10 to the power of 3:
Here, the number 10 is multiplied by itself 3 times (10 _ 10 _ 10)
The exponentiation operator gives you an easy way to find the power of a specific number.
7. Increment operator
The increment ++ operator is used to increase the value of a number by one. For example:
This operator gives you a faster way to increase a variable value by one. Without the operator, here's how you increment a variable:
Using the increment operator allows you to shorten the second line. You can place this operator before or next to the variable you want to increment:
Both placements shown above are valid. The difference between prefix (before) and postfix (after) placements is that the prefix position will execute the operator after that line of code has been executed.
Consider the following example:
Here, you can see that placing the increment operator next to the variable will print the variable as if it has not been incremented.
When you place the operator before the variable, then the number will be incremented before calling the console.log() method.
8. Decrement operator
The decrement  operator is used to decrease the value of a number by one. It's the opposite of the increment operator:
Please note that you can only use increment and decrement operators on a variable. An error occurs when you try to use these operators directly on a number value:
You can't use increment or decrement operator on a number directly.
Arithmetic operators summary
Now you've learned the 8 types of arithmetic operators. Excellent! Keep in mind that you can mix these operators to perform complex mathematical equations.
For example, you can perform an addition and multiplication on a set of numbers:
The order of operations in JavaScript is the same as in mathematics. Multiplication, division, and exponentiation take a higher priority than addition or subtraction (remember that acronym PEMDAS? Parentheses, exponents, multiplication and division, addition and subtraction â there's your order of operations).
You can use parentheses () to change the order of the operations. Wrap the operation you want to execute first as follows:
When using increment or decrement operators together with other operators, you need to place the operators in a prefix position as follows:
This is because a postfix increment or decrement operator will not be executed together with other operations in the same line, as I have explained previously.
Let's try some exercises. Can you guess the result of these operations?
And that's all for arithmetic operators. You've done a wonderful job learning about these operators.
Let's take a short fiveminute break before proceeding to the next type of operators.
The second group of operators we're going to explore is the assignment operators.
Assignment operators are used to assign a specific value to a variable. The basic assignment operator is marked by the equal = symbol, and you've already seen this operator in action before:
After the basic assignment operator, there are 5 more assignment operators that combine mathematical operations with the assignment. These operators are useful to make your code clean and short.
For example, suppose you want to increment the x variable by 2. Here's how you do it with the basic assignment operator:
There's nothing wrong with the code above, but you can use the addition assignment += to rewrite the second line as follows:
There are 7 kinds of assignment operators that you can use in JavaScript:
Name  Operation example  Meaning 

Assignment  
Addition assignment  
Subtraction assignment  
Multiplication assignment  
Division assignment  
Remainder assignment  
Exponentiation assignment 
The arithmetic operators you've learned in the previous section can be combined with the assignment operator except the increment and decrement operators.
Let's have a quick exercise. Can you guess the results of these assignments?
Now you've learned about assignment operators. Let's continue and learn about comparison operators.
As the name implies, comparison operators are used to compare one value or variable with something else. The operators in this category always return a boolean value: either true or false .
For example, suppose you want to compare if a variable's value is greater than 1. Here's how you do it:
The greater than > operator checks if the value on the left operand is greater than the value on the right operand.
There are 8 kinds of comparison operators available in JavaScript:
Name  Operation example  Meaning 

Equal  Returns if the operands are equal  
Not equal  Returns if the operands are not equal  
Strict equal  Returns if the operands are equal and have the same type  
Strict not equal  Returns if the operands are not equal, or have different types  
Greater than  Returns if the left operand is greater than the right operand  
Greater than or equal  Returns if the left operand is greater than or equal to the right operand  
Less than  Returns if the left operand is less than the right operand  
Less than or equal  Returns if the left operand is less than or equal to the right operand 
Here are some examples of using comparison operators:
The comparison operators are further divided in two types: relational and equality operators.
The relational operators compare the value of one operand relative to the second operand (greater than, less than)
The equality operators check if the value on the left is equal to the value on the right. They can also be used to compare strings like this:
String comparisons are casesensitive, as shown in the example above.
JavaScript also has two versions of the equality operators: loose and strict.
In strict mode, JavaScript will compare the values without performing a type coercion. To enable strict mode, you need to add one more equal = symbol to the operation as follows:
Since type coercion might result in unwanted behavior, you should use the strict equality operators anytime you do an equality comparison.
Logical operators are used to check whether one or more expressions result in either true or false .
There are three logical operators available in JavaScript:
Name  Operation example  Meaning 

Logical AND  Returns if all operands are , else returns  
Logical OR  Returns if one of the operands is , else returns  
Logical NOT  Reverse the result: returns if and vice versa 
These operators can only return Boolean values. For example, you can determine whether '7 is greater than 2' and '5 is greater than 4':
These logical operators follow the laws of mathematical logic:
 && AND operator â if any expression returns false , the result is false
  OR operator â if any expression returns true , the result is true
 ! NOT operator â negates the expression, returning the opposite.
Let's do a little exercise. Try to run these statements on your computer. Can you guess the results?
These logical operators will come in handy when you need to assert that a specific requirement is fulfilled in your code.
Let's say a happyLife requires a job with highIncome and supportiveTeam :
Based on the requirements, you can use the logical AND operator to check whether you have both requirements. When one of the requirements is false , then happyLife equals false as well.
Ternary Operator
The ternary operator (also called the conditional operator) is the only JavaScipt operator that requires 3 operands to run.
Let's imagine you need to implement some specific logic in your code. Suppose you're opening a shop to sell fruit. You give a $3 discount when the total purchase is $20 or more. Otherwise, you give a $1 discount.
You can implement the logic using an if..else statement as follows:
The code above works fine, but you can use the ternary operator to make the code shorter and more concise as follows:
The syntax for the ternary operator is condition ? expression1 : expression2 .
You need to write the condition to evaluate followed by a question ? mark.
Next to the question mark, you write the expression to execute when the condition evaluates to true , followed by a colon : symbol. You can call this expression1 .
Next to the colon symbol, you write the expression to execute when the condition evaluates to false . This is expression2 .
As the example above shows, the ternary operator can be used as an alternative to the if..else statement.
The typeof operator is the only operator that's not represented by symbols. This operator is used to check the data type of the value you placed on the right side of the operator.
Here are some examples of using the operator:
The typeof operator returns the type of the data as a string. The 'number' type represents both integer and float types, the string and boolean represent their respective types.
Arrays, objects, and the null value are of object type, while undefined has its own type.
Bitwise operators are operators that treat their operands as a set of binary digits, but return the result of the operation as a decimal value.
These operators are rarely used in web development, so you can skip this part if you only want to learn practical stuff. But if you're interested to know how they work, then let me show you an example.
A computer uses a binary number system to store decimal numbers in memory. The binary system only uses two numbers, 0 and 1, to represent the whole range of decimal numbers we humans know.
For example, the decimal number 1 is represented as binary number 00000001, and the decimal number 2 is represented as 00000010.
I won't go into detail on how to convert a decimal number into a binary number as that's too much to include in this guide. The main point is that the bitwise operators operate on these binary numbers.
If you want to find the binary number from a specific decimal number, you can Google for the "decimal to binary calculator".
There are 7 types of bitwise operators in JavaScript:
 Left Shift <<
 Right Shift >>
 Zerofill Right Shift >>>
Let's see how they work.
1. Bitwise AND operator
The bitwise operator AND & returns a 1 when the number 1 overlaps in both operands. The decimal numbers 1 and 2 have no overlapping 1, so using this operator on the numbers return 0:
2. Bitwise OR operator
On the other hand, the bitwise operator OR  returns all 1s in both decimal numbers.
The binary number 00000011 represents the decimal number 3, so the OR operator above returns 3.
Bitwise XOR operator
The Bitwise XOR ^ looks for the differences between two binary numbers. When the corresponding bits are the same, it returns 0:
5 = 00000101
Bitwise NOT operator
Bitwise NOT ~ operator inverts the bits of a decimal number so 0 becomes 1 and 1 becomes 0:
Bitwise Left Shift operator
Bitwise Left Shift << shifts the position of the bit by adding zeroes from the right.
The excess bits are then discarded, changing the decimal number represented by the bits. See the following example:
The right operand is the number of zeroes you will add to the left operand.
Bitwise Right Shift operator
Bitwise Right Shift >> shifts the position of the bits by adding zeroes from the left. It's the opposite of the Left Shift operator:
Bitwise Zerofill Right Shift operator
Also known as Unsigned Right Shift operator, the Zerofill Right Shift >>> operator is used to shift the position of the bits to the right, while also changing the sign bit to 0 .
This operator transforms any negative number into a positive number, so you can see how it works when passing a negative number as the left operand:
In the above example, you can see that the >> and >>> operators return different results. The Zerofill Right Shift operator has no effect when you use it on a positive number.
Now you've learned how the bitwise operators work. If you think they are confusing, then you're not alone! Fortunately, these operators are scarcely used when developing web applications.
You don't need to learn them in depth. It's enough to know what they are.
In this tutorial, you've learned the 7 types of JavaScript operators: Arithmetic, assignment, comparison, logical, ternary, typeof, and bitwise operators.
These operators can be used to manipulate values and variables to achieve a desired outcome.
Congratulations on finishing this guide!
If you enjoyed this article and want to take your JavaScript skills to the next level, I recommend you check out my new book Beginning Modern JavaScript here .
The book is designed to be easy to understand and accessible to anyone looking to learn JavaScript. It provides a stepbystep gentle guide that will help you understand how to use JavaScript to create a dynamic application.
Here's my promise: You will actually feel like you understand what you're doing with JavaScript.
Until next time!
JavaScript Full Stack Developer currently working with fullstack JS using React and Express. Nathan loves to write about his experience in programming to help other people.
If you read this far, thank the author to show them you care. Say Thanks
Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started
đ Assignment, Comparison, and Equality Operators
JavaScript has many operators for many different situations. We've already learned about a two types of operators:
 Arithmetic operators: + ,  , * , and / .
 The assignment operator: =
Let's now take the time to learn about more JavaScript operators used for assignment and comparison. For a list of all JavaScript operators, visit the MDN reference page on Expressions and Operators . We'll be linking to specific sections within the MDN "Expressions and Operators" page throughout this lesson.
Assignment Operators â
We've already seen how we can use the = assignment operator to set a variable equal to a value.
The = is called an assignment operator because it assigns the value on the right of the operator to the variable on the left. In the above example, favoriteNumber is assigned the value 42.
Another assignment operator is the += operator, because it also assigns a new value to the variable on the left based on the value to the right.
There is an assignment operator for each of the mathematical functions: addition, subtraction, multiplication and division.
When you use any of these assignment operators, the value of the variable on the left side is changed by the math operation and value on the right. Let's do one of each:
Documentation on Assignment Operators â
Visit this link for the MDN reference page on assignment operators:
 Assignment Operators
Comparison Operators â
Assignment operators change the value of the variable on the left of the operator. Comparison operators do not change any values, but return the booleans true or false depending on whether the JavaScript expression evaluates as true or false.
Comparison operators are also called relational operators , because they help find the relationship between two operands, asking questions like "is 10 bigger than 5?".
Greater Than Operator > â
> means "greaterthan (and not equal to)":
 3 > 4 evaluates to false .
 3 > 3 also evaluates to false , because 3 is equal to 3 and not greater.
 3 > 2 evaluates to true .
Less Than Operator < â
< is the opposite of > . It means "lessthan (and not equal to)":
 3 < 5 evaluates to true .
 3 < 3 evaluates to false because they are equal.
Greater Than or Equal Operator >= â
>= is the same as > , except it evaluates to true if the two sides are equal:
 3 >= 3 evaluates to true
 3 >= 2 also evaluates to true .
Less Than or Equal Operator <= â
<= is the opposite of >= . It means "lessthanorequalto":
 3 <= 3 evaluates to true because 3 is equal to 3.
 3 <= 1 evaluates to false
 3 <= 5 evaluates to true .
In the above examples, notice that the comparison operators return one of two values: true or false . Notice that there are no quotes around these values. true and false aren't strings â they're called booleans . They simply represent being true or false.
Documentation on Comparison/Relational Operators â
Visit this link for the MDN reference page on relational operators:
 Relational Operators
Equality Operators â
We can also compare the equality of two operands with equality operators . This means we can check to see whether or not two operands have the same value. Equality operators return a boolean ; true or false .
Notice the triple equal signs syntax: === . This is a type of equality operator called strict equality . We use 3 equal signs === when we are asking if two operands are equal to each other. When we're assigning a variable to a value, such as const myNumber = 5 we use a single equal sign = . Mixing these up is one of the easiest syntax errors to make.
JavaScript also has an equal operator with 2 equal signs, == , but it is almost never used and you should generally avoid it. Try out this example in the DevTools Console:
The double equals operator returns true when comparing 5 == "5" , indicating that a number and a string are the same. Whereas the strict equality operator with 3 equal signs returns false when comparing 5 === "5" , because a number and a string are not the same data type. With the double equals operator, JavaScript will make the assumption that you want the two different data types to be evaluated the same. As a developer you may not be expecting that assumption and this can lead to confusing bugs in your code.
Take some time to play around more with the double equals operator and the strict equality operator by visiting the MDN documentation:
 Strict Equality Operator
 Double Equals Operator
We can also check the opposite of equality â not being equal â with the inequality operator !== .
Equality operators work for strings as well.
Notice that if you type greeting after using the equality operators, you will see that the variable greeting still contains the string "hello world" . Comparison and equality operators do not change the value of the variable. Let's look at another example to illustrate that important difference between assignment operators and comparison/equality operators.
Notice that we use let instead of const here because we reassign the value of myNumber to 10. We wouldn't be able to do that if myNumber were a constant variable declared with const .
Here are some more examples of equality operators.
Equality Operator === â
=== means "equalto".
 5 === 5 or "cat" === "cat" evaluate to true
 3 === 5 or "cat" === "dog" evaluate to false .
Inequality Operator !== â
!== means "notequalto". It is the opposite of === .
 "cat" !== "dog" evaluates to true
 5 !== 5 evaluates to false , because saying that 5 is not equal to 5 is not true.
Documentation on Equality Operators â
Visit this link for the MDN reference page on equality operators:
 Equality Operators
Popular Tutorials
Popular examples, reference materials, learn python interactively, js introduction.
 Getting Started
 JS Variables & Constants
 JS console.log
 JavaScript Data types
JavaScript Operators
 JavaScript Comments
 JS Type Conversions
JS Control Flow
 JS Comparison Operators
 JavaScript if else Statement
 JavaScript for loop
 JavaScript while loop
 JavaScript break Statement
 JavaScript continue Statement
 JavaScript switch Statement
JS Functions
 JavaScript Function
 Variable Scope
 JavaScript Hoisting
 JavaScript Recursion
 JavaScript Objects
 JavaScript Methods & this
 JavaScript Constructor
 JavaScript Getter and Setter
 JavaScript Prototype
 JavaScript Array
 JS Multidimensional Array
 JavaScript String
 JavaScript for...in loop
 JavaScript Number
 JavaScript Symbol
Exceptions and Modules
 JavaScript try...catch...finally
 JavaScript throw Statement
 JavaScript Modules
 JavaScript ES6
 JavaScript Arrow Function
 JavaScript Default Parameters
 JavaScript Template Literals
 JavaScript Spread Operator
 JavaScript Map
 JavaScript Set
 Destructuring Assignment
 JavaScript Classes
 JavaScript Inheritance
 JavaScript for...of
 JavaScript Proxies
JavaScript Asynchronous
 JavaScript setTimeout()
 JavaScript CallBack Function
 JavaScript Promise
 Javascript async/await
 JavaScript setInterval()
Miscellaneous
 JavaScript JSON
 JavaScript Date and Time
 JavaScript Closure
 JavaScript this
 JavaScript use strict
 Iterators and Iterables
 JavaScript Generators
 JavaScript Regular Expressions
 JavaScript Browser Debugging
 Uses of JavaScript
JavaScript Tutorials
JavaScript Comparison and Logical Operators
JavaScript Ternary Operator
JavaScript Booleans
JavaScript Bitwise Operators
 JavaScript Object.is()
 JavaScript typeof Operator
JavaScript operators are special symbols that perform operations on one or more operands (values). For example,
Here, we used the + operator to add the operands 2 and 3 .
JavaScript Operator Types
Here is a list of different JavaScript operators you will learn in this tutorial:
 Arithmetic Operators
 Assignment Operators
 Comparison Operators
 Logical Operators
 Bitwise Operators
 String Operators
 Miscellaneous Operators
1. JavaScript Arithmetic Operators
We use arithmetic operators to perform arithmetic calculations like addition, subtraction, etc. For example,
Here, we used the  operator to subtract 3 from 5 .
Commonly Used Arithmetic Operators
Operator  Name  Example 

Addition  
Subtraction  
Multiplication  
Division  
Remainder  
Increment (increments by )  or  
Decrement (decrements by )  or  
Exponentiation (Power) 
Example 1: Arithmetic Operators in JavaScript
Note: The increment operator ++ adds 1 to the operand. And, the decrement operator  decreases the value of the operand by 1 .
To learn more, visit Increment ++ and Decrement  Operators .
2. JavaScript Assignment Operators
We use assignment operators to assign values to variables. For example,
Here, we used the = operator to assign the value 5 to the variable x .
Commonly Used Assignment Operators
Operator  Name  Example 

Assignment Operator  
Addition Assignment  
Subtraction Assignment  
Multiplication Assignment  
Division Assignment  
Remainder Assignment  
Exponentiation Assignment 
Example 2: Assignment Operators in JavaScript
3. javascript comparison operators.
We use comparison operators to compare two values and return a boolean value ( true or false ). For example,
Here, we have used the > comparison operator to check whether a (whose value is 3 ) is greater than b (whose value is 2 ).
Since 3 is greater than 2 , we get true as output.
Note: In the above example, a > b is called a boolean expression since evaluating it results in a boolean value.
Commonly Used Comparison Operators
Operator  Meaning  Example 

Equal to  gives us  
Not equal to  gives us  
Greater than  gives us  
Less than  gives us  
Greater than or equal to  gives us  
Less than or equal to  gives us  
Strictly equal to  gives us  
Strictly not equal to  gives us 
Example 3: Comparison Operators in JavaScript
The equality operators ( == and != ) convert both operands to the same type before comparing their values. For example,
Here, we used the == operator to compare the number 3 and the string 3 .
By default, JavaScript converts string 3 to number 3 and compares the values.
However, the strict equality operators ( === and !== ) do not convert operand types before comparing their values. For example,
Here, JavaScript didn't convert string 4 to number 4 before comparing their values.
Thus, the result is false , as number 4 isn't equal to string 4 .
4. JavaScript Logical Operators
We use logical operators to perform logical operations on boolean expressions. For example,
Here, && is the logical operator AND . Since both x < 6 and y < 5 are true , the combined result is true .
Commonly Used Logical Operators
Operator  Syntax  Description 

(Logical AND)  only if both and are  
(Logical OR)  if either or is  
(Logical NOT)  if is and vice versa 
Example 4: Logical Operators in JavaScript
Note: We use comparison and logical operators in decisionmaking and loops. You will learn about them in detail in later tutorials.
More on JavaScript Operators
We use bitwise operators to perform binary operations on integers.
Operator  Description  Example 

&  Bitwise AND  
  Bitwise OR  
^  Bitwise XOR  
~  Bitwise NOT  
<<  Left shift  
>>  Signpropagating right shift  
>>>  Zerofill right shift 
Note: We rarely use bitwise operators in everyday programming. If you are interested, visit JavaScript Bitwise Operators to learn more.
In JavaScript, you can also use the + operator to concatenate (join) two strings. For example,
Here, we used the + operator to concatenate str1 and str2 .
JavaScript has many more operators besides the ones we listed above. You will learn about them in detail in later tutorials.
Operator  Description  Example 

: Evaluates multiple operands and returns the value of the last operand.  
: Returns value based on the condition.  
Returns the data type of the variable.  
Returns t if the specified object is a valid object of the specified class.  
Discards any expression's return value. 
Table of Contents
 Introduction
 JavaScript Arithmetic Operators
 JavaScript Assignment Operators
 JavaScript Comparison Operators
 JavaScript Logical Operators
Video: JavaScript Operators
Sorry about that.
Related Tutorials
JavaScript Tutorial
JS Tutorial
Js versions, js functions, js html dom, js browser bom, js web apis, js vs jquery, js graphics, js examples, js references, javascript assignment, javascript assignment operators.
Assignment operators assign values to JavaScript variables.
Operator  Example  Same As 

=  x = y  x = y 
+=  x += y  x = x + y 
=  x = y  x = x  y 
*=  x *= y  x = x * y 
/=  x /= y  x = x / y 
%=  x %= y  x = x % y 
**=  x **= y  x = x ** y 
Shift Assignment Operators
Operator  Example  Same As 

<<=  x <<= y  x = x << y 
>>=  x >>= y  x = x >> y 
>>>=  x >>>= y  x = x >>> y 
Bitwise Assignment Operators
Operator  Example  Same As 

&=  x &= y  x = x & y 
^=  x ^= y  x = x ^ y 
=  x = y  x = x  y 
Logical Assignment Operators
Operator  Example  Same As 

&&=  x &&= y  x = x && (x = y) 
=  x = y  x = x  (x = y) 
??=  x ??= y  x = x ?? (x = y) 
The = Operator
The Simple Assignment Operator assigns a value to a variable.
Simple Assignment Examples
The += operator.
The Addition Assignment Operator adds a value to a variable.
Addition Assignment Examples
The = operator.
The Subtraction Assignment Operator subtracts a value from a variable.
Subtraction Assignment Example
The *= operator.
The Multiplication Assignment Operator multiplies a variable.
Multiplication Assignment Example
The **= operator.
The Exponentiation Assignment Operator raises a variable to the power of the operand.
Exponentiation Assignment Example
The /= operator.
The Division Assignment Operator divides a variable.
Division Assignment Example
The %= operator.
The Remainder Assignment Operator assigns a remainder to a variable.
Remainder Assignment Example
Advertisement
The <<= Operator
The Left Shift Assignment Operator left shifts a variable.
Left Shift Assignment Example
The >>= operator.
The Right Shift Assignment Operator right shifts a variable (signed).
Right Shift Assignment Example
The >>>= operator.
The Unsigned Right Shift Assignment Operator right shifts a variable (unsigned).
Unsigned Right Shift Assignment Example
The &= operator.
The Bitwise AND Assignment Operator does a bitwise AND operation on two operands and assigns the result to the the variable.
Bitwise AND Assignment Example
The = operator.
The Bitwise OR Assignment Operator does a bitwise OR operation on two operands and assigns the result to the variable.
Bitwise OR Assignment Example
The ^= operator.
The Bitwise XOR Assignment Operator does a bitwise XOR operation on two operands and assigns the result to the variable.
Bitwise XOR Assignment Example
The &&= operator.
The Logical AND assignment operator is used between two values.
If the first value is true, the second value is assigned.
Logical AND Assignment Example
The &&= operator is an ES2020 feature .
The = Operator
The Logical OR assignment operator is used between two values.
If the first value is false, the second value is assigned.
Logical OR Assignment Example
The = operator is an ES2020 feature .
The ??= Operator
The Nullish coalescing assignment operator is used between two values.
If the first value is undefined or null, the second value is assigned.
Nullish Coalescing Assignment Example
The ??= operator is an ES2020 feature .
Test Yourself With Exercises
Use the correct assignment operator that will result in x being 15 (same as x = x + y ).
Start the Exercise
COLOR PICKER
Contact Sales
If you want to use W3Schools services as an educational institution, team or enterprise, send us an email: [email protected]
Report Error
If you want to report an error, or if you want to make a suggestion, send us an email: [email protected]
Top Tutorials
Top references, top examples, get certified.
 Stack Overflow Public questions & answers
 Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
 Talent Build your employer brand
 Advertising Reach developers & technologists worldwide
 Labs The future of collective knowledge sharing
 About the company
Collectivesâą on Stack Overflow
Find centralized, trusted content and collaborate around the technologies you use most.
Q&A for work
Connect and share knowledge within a single location that is structured and easy to search.
Get early access and see previews of new features.
Multiple Comparison / Assignment Operators on the Same Line in JavaScript
In the above, what is the line inside of the function doing and how does it work?
2 Answers 2
First it's doing the comparison input != 1 , and then assigning the result of that (which will be true or false ) the variable value . The != is a comparison , the = is an assignment .
This is exactly the same as any other assignment: The righthand side is evaluated, and assigned to the lefthand side.
See Operator Precedence .
!= has a precedence of 9 and = has a precedence of 17.
Therefore it evaluates input != 1 and then assigns the result to value .
Your Answer
Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more
Sign up or log in
Post as a guest.
Required, but never shown
By clicking âPost Your Answerâ, you agree to our terms of service and acknowledge you have read our privacy policy .
Not the answer you're looking for? Browse other questions tagged javascript or ask your own question .
 Featured on Meta
 Upcoming signup experiments related to tags
 The return of Staging Ground to Stack Overflow
 Policy: Generative AI (e.g., ChatGPT) is banned
Hot Network Questions
 Does "my grades suffered" mean "my grades became worse" or "my grades were bad"?
 What is the meaning of "Wa’al"?
 Why does c show up in Schwarzschild's equation for the horizon radius?
 if people are bred like dogs, what can be achieved?
 What's the necessary and sufficient condition for a real sequence to be written as the selfconvolution of another real sequence?
 Tiny book about a planet full of maneating sunflowers
 Is this professor being unnecessarily harsh or did I actually make a mistake?
 What is the purpose of the M1 pin on a Z80
 Would a "plug and play" prosthetic be possible?
 Is the new series for 𝜋 a Big (or even Medium) Deal?
 Do I need to staple cable for new wire run through a preexisting wall?
 Derivative of the Score Function in Fisher Information
 Is there some sort of kitchen utensil/device like a cylinder with a strainer?
 Is there an explicit construction of a Lebesguemeasurable set which is not a Borel set?
 What is a quarter in 19thcentury England converted to contemporary pints?
 Who is Maud here?
 How to make '.zshrc' to search for sourced files in the specific folder and not in the folder from which the terminal has been opened
 Short story about soldiers who are fighting against an enemy which turns out to be themselves
 Visiting every digit
 Hardtofind historical grey literature  any tips?
 My 5yearold is stealing food and lying
 A puzzle from YOU to ME ;)
 2013 Jaguar XF Shaking When Idling/Accelerating
 What is a curate in English scone culture?
Top things to know about Copilot+ PCs from Microsoft Surface, available today at Microsoft.com
 Microsoft Store Team
Available today, the allnew Copilot+ PCs from Microsoft Surface â Surface Laptop and Surface Pro â are thin, light and beautiful devices that help you do more of what you love. Whether itâs starting a new creative project, connecting with friends and family or pursuing a new business venture, these devices are designed to support your journey.
The new Surface Laptop and Surface Pro are Copilot+ PCs, which are the fastest, most intelligent Windows PCs on the market. They are available in four color options at an incredible value, beginning at $999 Estimated Retail Price (ERP) USD on Microsoft.com or at a Microsoft Experience Center .
Exclusively on Microsoft.com, customers can purchase Copilot+ PCs from Microsoft Surface with 64GB memory (RAM) configurations which offer more performance and multitasking:
 Surface Laptop (7 th Edition) , starting at $2,399.99 ERP USD in Black with a 13.8inch Display, SnapdragonÂź X Elite (12 Core) Processor and 1TB SSD Storage.
 Surface Laptop (7 th Edition) , starting at $2,499.99 ERP in Black with a 15inch Display, SnapdragonÂź X Elite (12 Core) Processor and 1TB SSD Storage.
 Surface Pro Essentials Bundle , starting at $1,144 ERP, get the most out of your Surface Pro with this bundle, saving on a Microsoft 365 subscription and Microsoft Complete Protection Plan. Plus, when purchasing the Essential Bundle, customers can take advantage of 20% off accessories including the new Surface Pro Flex Keyboard.
Read on for everything you need to know about the new Copilot+ PCs from Microsoft Surface.
Our three favorite things about the new Copilot+ PCs from Microsoft Surface: 1 â Designed for your everyday work and play
 Power through your day without a worry. The new Surface Laptop and Surface Pro are more powerful than ever with Snapdragon X Series Processors, providing faster performance and allday battery life with a powerful Neural Processing Unit (NPU) for allnew AI experiences.
 Sleek design and colors that match your aesthetic. Thoughtfully designed with your everyday in mind, the thin, lightweight and ultraportable devices feature premium finishes. They come in four stunning colors â perfect for any style: classic Black, timeless Platinum, bold Sapphire, and the new and refreshing Dune [i] .
 Brighter, more immersive displays for ultimate viewing. Weâre introducing a new OLED with HDR [ii] display to the new Surface Pro for a cinematic experience, and the Surface Laptop has a new HDR touchscreen display with razorthin bezels. No matter what you watch or view, your content is going to look stunning.
 Everyday AI companion with the Copilot key. The Copilot app is just a click away with the Copilot key â one of the newest additions to Windows 11 keyboards on Copilot+ PCs.
2 â Exclusive AI experiences designed to empower creativity and productivity Â
 Express your creativity with Cocreator [iii] . Whether a seasoned artist or new to design, Cocreator simplifies image creation and photo editing with easy text prompts and natural inking using a Slim Pen [iv] on Surface Pro or touch on Surface Laptop. Exclusive to Copilot+ PCs, Cocreator lets you bring your ideas to life, and it works alongside you to iteratively update the image in real time. Cocreator is available in Paint â the app youâve grown to know and love.
 No matter where you are, Live Captions keeps you better connected [v] . Available on Windows, Live Captions can quickly translate any live or prerecorded audio into English â and in real time. Connecting with friends, family and colleagues just got easier, and youâll never miss a beat when watching your favorite international movies or TV shows.
 New and enhanced audio and video effects bring new meaning to âcamera ready.â Both device cameras are powered by new features to Windows Studio Effects. Powered by an industryleading NPU, they help improve lighting, ensure you appear clear and crisp on video, reduce background noise and offer creative filters so you can express yourself on camera. Built to automatically improve video calls, it’s like having a studio ring light and microphone right on your Windows PC! And the Surface Proâs ultrawide fieldofview camera keeps you, or theÂ whole family, in focus, even as youÂ move around your space.
 Recall (preview) coming soon: For the solopreneur who has too many working files and emails to maintain organization, Recall helps you quickly find things you have seen on your PC, keeping all documents, images, websites, instant messages, emails and apps right at your fingertips. This experience comes with builtin privacy and security controls.
Learn how to unlock the best of the new AIpowered features on your Copilot+ PC .
3 â The allnew Surface Pro Flex Keyboard [vi] unlocks new levels of flexibility Â
Alongside the new Surface Pro, we are introducing the Surface Pro Flex Keyboard , unlocking powerful new levels of flexibility to effortlessly adapt to your work and play routines. Ready to attach to your Pro for the ultimate laptop setup or detach for more flexibility and to support your creative workflows. It is built with extra carbon fiber layers for stability and has a larger, customizable haptic touchpad. With integrated pen storage, your Slim Pen is secure, charged and ready to go. Accessibility remains core to our approach, so we designed the new Surface Pro Flex Keyboard with a bold keyset option to reduce eye strain and assist people with low vision.
Discover, learn and buy with Microsoft Store
Shopping at Microsoft Store is all about ease and convenience. Whether the new Copilot+ PCs from Microsoft Surface, Copilot Pro, Xbox consoles and games, apps, movies and TV shows, weâve got you covered. Donât miss our top deals on your favorite TV shows like Rick & Morty: Seasons 17, Buffy The Vampire Slayer Complete Series, Sons of Anarchy: The Complete Box Set and so much more â available for up to 50% off for a limited time .
 Flexible payment options : Find a payment plan that works for you with options like PayPal Pay Later and Citizens Pay Line of Credit [vii] . It’s budgeting made easy.
 Online Tradein Program : For a limited time, buy a new Copilot+ PC from Microsoft Surface and get extra cash back when you trade in an eligible device.
 Free and fast shipping with 60day returns : Get your items quickly with 2â3day shipping at no extra cost or minimum purchase required and enjoy the flexibility of 60day returns on almost any physical product.
 60day price protection : Shop with confidence knowing you have 60 days of price protection from your delivery date. If the price drops or you find a lower price elsewhere, weâll honor a onetime price adjustment.
You can also bet on Microsoft Store offering lots of great deals throughout the upcoming backtoschool season. Be sure to keep an eye on the deals page !
Available alongside Microsoft Surface today, are brand new Copilot+ PCs from the biggest brands: Acer , ASUS , Dell , HP , Lenovo and Samsung . Learn more from major PC manufacturers or visit leading retailers, including Best Buy .
[i] Colors available on selected models only. Available colors, sizes, finishes and processors may vary by store, market and configuration.Â
[ii] HDR requires HDR content and enabling HDR in device settings.
[iii] Microsoft account required.
[iv] Surface Slim Pen sold separately.
[v] Currently supports translation for video and audio subtitles into English from 40+ languages. SeeÂ https://aka.ms/copilotpluspcs .Â
[vi] Surface Pro Flex Keyboard sold separately.
[vii] With approval of Citizens Pay Line of Credit at 0% APR and 12 or 18month term. Subject to individual credit approval. See the Citizens Pay Line of Credit Agreement âŻfor full terms and conditions. Citizens Pay Line of Credit Account offered by Citizens Bank, N.A. â
 DSA with JS  Self Paced
 JS Tutorial
 JS Exercise
 JS Interview Questions
 JS Operator
 JS Projects
 JS Examples
 JS Free JS Course
 JS A to Z Guide
 JS Formatter
 JavaScript Tutorial
JavaScript Basics
 Introduction to JavaScript
 JavaScript Versions
 How to Add JavaScript in HTML Document?
 JavaScript Statements
 JavaScript Syntax
 JavaScript Output
 JavaScript Comments
JS Variables & Datatypes
 Variables and Datatypes in JavaScript
 Global and Local variables in JavaScript
 JavaScript Let
 JavaScript Const
 JavaScript var
JS Operators
 JavaScript Operators
 Operator precedence in JavaScript
 JavaScript Arithmetic Operators
JavaScript Assignment Operators
 JavaScript Comparison Operators
 JavaScript Logical Operators
 JavaScript Bitwise Operators
 JavaScript Ternary Operator
 JavaScript Comma Operator
 JavaScript Unary Operators
 JavaScript Relational operators
 JavaScript String Operators
 JavaScript Loops
 7 Loops of JavaScript
 JavaScript For Loop
 JavaScript While Loop
 JavaScript forin Loop
 JavaScript for...of Loop
 JavaScript do...while Loop
JS Perfomance & Debugging
 JavaScript  Performance
 Debugging in JavaScript
 JavaScript Errors Throw and Try to Catch
 Objects in Javascript
 Introduction to Object Oriented Programming in JavaScript
 JavaScript Objects
 Creating objects in JavaScript
 JavaScript JSON Objects
 JavaScript Object Reference
JS Function
 Functions in JavaScript
 How to write a function in JavaScript ?
 JavaScript Function Call
 Different ways of writing functions in JavaScript
 Difference between Methods and Functions in JavaScript
 Explain the Different Function States in JavaScript
 JavaScript Function Complete Reference
 JavaScript Arrays
 JavaScript Array Methods
 BestKnown JavaScript Array Methods
 What are the Important Array Methods of JavaScript ?
 JavaScript Array Reference
 JavaScript Strings
 JavaScript String Methods
 JavaScript String Reference
 JavaScript Numbers
 How numbers are stored in JavaScript ?
 How to create a Number object using JavaScript ?
 JavaScript Number Reference
 JavaScript Math Object
 What is the use of Math object in JavaScript ?
 JavaScript Math Reference
 JavaScript Map
 What is JavaScript Map and how to use it ?
 JavaScript Map Reference
 Sets in JavaScript
 How are elements ordered in a Set in JavaScript ?
 How to iterate over Set elements in JavaScript ?
 How to sort a set in JavaScript ?
 JavaScript Set Reference
 JavaScript Date
 JavaScript Promise
 JavaScript BigInt
 JavaScript Boolean
 JavaScript Proxy/Handler
 JavaScript WeakMap
 JavaScript WeakSet
 JavaScript Function Generator
 JavaScript JSON
 Arrow functions in JavaScript
 JavaScript this Keyword
 Strict mode in JavaScript
 Introduction to ES6
 JavaScript Hoisting
 Async and Await in JavaScript
JavaScript Exercises
 JavaScript Exercises, Practice Questions and Solutions
A ssignment Operators
Assignment operators are used to assign values to variables in JavaScript.
Assignment Operators List
There are so many assignment operators as shown in the table with the description.
OPERATOR NAME  SHORTHAND OPERATOR  MEANING 

a+=b  a=a+b  
a=b  a=ab  
a*=b  a=a*b  
a/=b  a=a/b  
a%=b  a=a%b  
a**=b  a=a**b  
a<<=b  a=a<<b  
a>>=b  a=a>>b  
a&=b  a=a&b  
a=b  a=a  b  
a^=b  a=a^b  
 a&&=b  x && (x = y) 
 =  x  (x = y) 
 ??=  x ?? (x = y) 
Below we have described each operator with an example code:
Addition assignment operator(+=).
The Addition assignment operator adds the value to the right operand to a variable and assigns the result to the variable. Addition or concatenation is possible. In case of concatenation then we use the string as an operand.
Subtraction Assignment Operator(=)
The Substraction Assignment Operator subtracts the value of the right operand from a variable and assigns the result to the variable.
Multiplication Assignment Operator(*=)
The Multiplication Assignment operator multiplies a variable by the value of the right operand and assigns the result to the variable.
Division Assignment Operator(/=)
The Division Assignment operator divides a variable by the value of the right operand and assigns the result to the variable.
Remainder Assignment Operator(%=)
The Remainder Assignment Operator divides a variable by the value of the right operand and assigns the remainder to the variable.
Exponentiation Assignment Operator
The Exponentiation Assignment Operator raises the value of a variable to the power of the right operand.
Left Shift Assignment Operator(<<=)
This Left Shift Assignment O perator moves the specified amount of bits to the left and assigns the result to the variable.
Right Shift Assignment O perator(>>=)
The Right Shift Assignment Operator moves the specified amount of bits to the right and assigns the result to the variable.
Bitwise AND Assignment Operator(&=)
The Bitwise AND Assignment Operator uses the binary representation of both operands, does a bitwise AND operation on them, and assigns the result to the variable.
Btwise OR Assignment Operator(=)
The Btwise OR Assignment Operator uses the binary representation of both operands, does a bitwise OR operation on them, and assigns the result to the variable.
Bitwise XOR Assignment Operator(^=)
The Bitwise XOR Assignment Operator uses the binary representation of both operands, does a bitwise XOR operation on them, and assigns the result to the variable.
Logical AND Assignment Operator(&&=)
The Logical AND Assignment assigns the value of y into x only if x is a truthy value.
Logical OR Assignment Operator( = )
The Logical OR Assignment Operator is used to assign the value of y to x if the value of x is falsy.
Nullish coalescing Assignment Operator(??=)
The Nullish coalescing Assignment Operator assigns the value of y to x if the value of x is null.
Supported Browsers: The browsers supported by all JavaScript Assignment operators are listed below:
 Google Chrome
 Microsoft Edge
 Internet Explorer
Please Login to comment...
Similar reads.
 javascriptoperators
 Web Technologies
IMAGES
VIDEO
COMMENTS
= is the assignment operator. It sets a variable (the lefthand side) to a value (the righthand side). The result is the value on the righthand side. == is the comparison operator. It will only return true if both values are equivalent after coercing their types to the same type. === is a more strict comparison operator often called the ...
This chapter describes JavaScript's expressions and operators, including assignment, comparison, arithmetic, bitwise, logical, string, ternary and more. At a high level, an expression is a valid unit of code that resolves to a value. There are two types of expressions: those that have side effects (such as assigning values) and those that ...
Reference: JavaScript Tutorial: Comparison Operators. The == operator will compare for equality after doing any necessary type conversions. The === operator will not do the conversion, so if two values are not the same type === will simply return false. Both are equally quick.
When comparing a string with a number, JavaScript will convert the string to a number when doing the comparison. An empty string converts to 0. A nonnumeric string converts to NaN which is always false. When comparing two strings, "2" will be greater than "12", because (alphabetically) 1 is less than 2.
Javascript operators are used to perform different types of mathematical and logical computations. Examples: The Assignment Operator = assigns values. The Addition Operator + adds values. The Multiplication Operator * multiplies values. The Comparison Operator > compares values
Comparisons. We know many comparison operators from maths. In JavaScript they are written like this: Greater/less than: a > b, a < b. Greater/less than or equals: a >= b, a <= b. Equals: a == b, please note the double equality sign == means the equality test, while a single one a = b means an assignment.
Expressions and operators. This chapter describes JavaScript'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 reference.
Here are the important differences between =, ==, and ===. =. ==. ===. = in JavaScript is used for assigning values to a variable. == in JavaScript is used for comparing two variables, but it ignores the datatype of variable. === is used for comparing two variables, but this operator also checks datatype and compares two values.
JavaScript Comparison Operators. Comparison operators compare two values and return a boolean value ( true or false ). For example, const a = 3, b = 2; console.log(a > b); // Output: true. Run Code. Here, we have used the > comparison operator to check whether a (whose value is 3) is greater than b (whose value is 2 ).
The assignment operator is completely different from the equals (=) sign used as syntactic separators in other locations, which include:Initializers of var, let, and const declarations; Default values of destructuring; Default parameters; Initializers of class fields; All these places accept an assignment expression on the righthand side of the =, so if you have multiple equals signs chained ...
Conclusion. In this tutorial, you've learned the 7 types of JavaScript operators: Arithmetic, assignment, comparison, logical, ternary, typeof, and bitwise operators. These operators can be used to manipulate values and variables to achieve a desired outcome. Congratulations on finishing this guide!
JavaScript Operators. Operators are used to assign values, compare values, perform arithmetic operations, and more. There are different types of JavaScript operators: Arithmetic Operators. Assignment Operators. Comparison Operators. Logical Operators. Conditional Operators. Type Operators.
Basic keywords and general expressions in JavaScript. These expressions have the highest precedence (higher than operators ). The this keyword refers to a special property of an execution context. Basic null, boolean, number, and string literals. Array initializer/literal syntax. Object initializer/literal syntax.
JavaScript comparison operators are essential tools for checking conditions and making decisions in your code. They are used to evaluate whether a condition is true or false by comparing variables or values. These operators play a crucial role in logical expressions, helping to determine the equality or differences between values.
đ Assignment, Comparison, and Equality Operators. JavaScript has many operators for many different situations. We've already learned about a two types of operators: Arithmetic operators: +, , *, and /. The assignment operator: = Let's now take the time to learn about more JavaScript operators used for assignment and comparison.
JavaScript Assignment Operators. We use assignment operators to assign values to variables. For example, let x = 5; ... JavaScript Comparison Operators. We use comparison operators to compare two values and return a boolean value (true or false). For example,
JavaScript '==' operator: In Javascript, the '==' operator is also known as the loose equality operator which is mainly used to compare two values on both sides and then return true or false. This operator checks equality only after converting both the values to a common type i.e type coercion.
JavaScript operators are symbols used to perform specific mathematical, comparison, assignment, and logical computations on operands. They are fundamental elements in JavaScript programming, allowing developers to manipulate data and control program flow efficiently.
Use the correct assignment operator that will result in x being 15 (same as x = x + y ). Start the Exercise. Well organized and easy to understand Web building tutorials with lots of examples of how to use HTML, CSS, JavaScript, SQL, Python, PHP, Bootstrap, Java, XML and more.
4. First it's doing the comparison input != 1, and then assigning the result of that (which will be true or false) the variable value. The != is a comparison, the = is an assignment. This is exactly the same as any other assignment: The righthand side is evaluated, and assigned to the lefthand side. answered Dec 18, 2013 at 22:40. T.J. Crowder.
2  Exclusive AI experiences designed to empower creativity and productivity Express your creativity with Cocreator. Whether a seasoned artist or new to design, Cocreator simplifies image creation and photo editing with easy text prompts and natural inking using a Slim Pen on Surface Pro or touch on Surface Laptop. Exclusive to Copilot+ PCs, Cocreator lets you bring your ideas to life, and ...
JavaScript remainder assignment operator (%=) assigns the remainder to the variable after dividing a variable by the value of the right operand. Syntax: Operator: x %= y Meaning: x = x % y Below example illustrate the Remainder assignment(%=) Operator in JavaScript: Example 1: The following example demonstrates if the given number is divisible by 4