Javascript Comparison Operators

6 Key excerpts on "Javascript Comparison Operators"

• 

  eBook - ePub

  Professional JavaScript for Web Developers

  • Nicholas C. Zakas(Author)
  • 2011(Publication Date)
  • Wrox

    (Publisher)

  "3" is 51). If, however, one of the operands is changed to a number as in the following example, the result makes more sense:

  var result = "23" < 3; //false

  Here, the string "23" is converted into the number 23 and then compared to 3, giving the expected result. Whenever a number is compared to a string, the string is converted into a number and then numerically compared to the other number. This works well for cases like the previous example, but what if the string can’t be converted into a number? Consider this example:

  var result = "a" < 3; //false because "a" becomes NaN

  The letter "a" can’t be meaningfully converted into a number, so it becomes NaN . As a rule, the result of any relational operation with NaN is false , which is interesting when considering the following:

  var result1 = NaN < 3; //false var result2 = NaN >= 3; //false

  In most comparisons, if a value is not less than another, it is always greater than or equal to it. When using NaN , however, both comparisons return false .

  Equality Operators

  Determining whether two variables are equivalent is one of the most important operations in programming. This is fairly straightforward when dealing with strings, numbers, and Boolean values, but the task gets a little complicated when you take objects into account. Originally ECMAScript’s equal and not-equal operators performed conversions into like types before doing a comparison. The question of whether these conversions should, in fact, take place was then raised. The end result was for ECMAScript to provide two sets of operators: equal and not equal to perform conversion before comparison, and identically equal and not identically equal to perform comparison without conversion.

  Equal and Not Equal

  The equal operator in ECMAScript is the double equal sign (== ), and it returns true if the operands are equal. The not-equal operator is the exclamation point followed by an equal sign (!= ), and it returns true if two operands are not equal. Both operators do conversions to determine if two operands are equal (often called type coercion

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Clean Code in JavaScript

  Develop reliable, maintainable, and robust JavaScript

  • James Padolsey(Author)
  • 2020(Publication Date)
  • Packt Publishing

    (Publisher)

  Comparative operators

  Comparative operators are a collection of binary operators that always return Boolean derived from a comparison between the two operands:

  • Abstract equality (a == b)
  • Abstract inequality (a != b)
  • Strict equality (a === b)
  • Strict inequality (a !== b)
  • Greater than (a > b)
  • Greater than or equal to (a >= b)
  • Less than (a < b)
  • Less than or equal to (a <= b)
  • Instance of (a instanceof b)
  • In (a in b)

  Each of these operators has slightly different functions and coercive behavior so it's useful to go through each of them individually.

  Passage contains an image

  Abstract equality and inequality

  The abstract equality (==) and inequality (!=) operators rely on the same algorithm internally, which is responsible for determining whether two values can be considered equal. In this section, our examples will only explore ==, but rest assured that != will always simply be the opposite of whatever == is.

  In the vast majority of cases, it is not advisable to rely on abstract equality because its mechanism can create unexpected results. Most of the time, you'll want to opt for strict equality (that is, === or

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  The JavaScript Workshop

  A New, Interactive Approach to Learning JavaScript

  • Joseph Labrecque, Jahred Love, Daniel Rosenbaum, Nick Turner, Gaurav Mehla, Alonzo L. Hosford, Florian Sloot, Philip Kirkbride(Authors)
  • 2019(Publication Date)
  • Packt Publishing

    (Publisher)

  == operator is a "value comparison operator". In the example shown, the numeric value 1 and the string value "1" are considered the same value. As such, the equality operator, which is a "value comparison" operator, will compare them as equal.

  In order to determine whether values are of the same type, as well as the same value, "strict comparison operators" should be used:

  Figure 5.6: Equality operators and their descriptions

  Logical Operators

  Logical operators are often used to concatenate Boolean expressions together. For instance, when comparing the qualities of a string value, you may wish to execute code if the string is longer than one value but shorter than another. In order to do this, you need to join two comparison expressions using the && operator. In another condition, you may wish to execute the code if only one of the expressions is true , in which case, you would use the || operator.

  The following table lists each of the logical operators and what they do:

  Figure 5.7: Logical operators and their description

  Exercise 5.03: Odds and Evens

  In this exercise, we will process a series of numbers and output messages describing whether a number is either odd or even. We'll fulfill this exercise using a function so that you can experiment with different starting values. Let's get started:

  1. At the command prompt, create the odd_or_even function with a couple of parameters:function odd_or_even(counter, last) {
     The last parameter will be the ceiling value of the numerical series, while the counter parameter is both the starting value and the current index variable for each loop.
  2. Next, create your loop using the while keyword. while will process a block of code as long as the conditional expression is truthy. As the conditional in this exercise, you will simply compare counter with the last parameter:  while (counter <= last) {
     If the counter variable is ever larger than the last parameter, then the while loop will exit, which will also exit the function.
  3. With the while conditional in place, you can now begin describing the counter value with each iteration. To do this, you simply examine the value of counter and respond with an appropriate message, depending on its content:    if (counter % 2 == 0) { // is true if the remainder of 'counter / 2' is equal to zero       console.log(counter, "is an even number");

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Javascript

  Javascript Programming For Absolute Beginners: Ultimate Guide To Javascript Coding, Javascript Programs And Javascript Language

  • William Sullivan(Author)
  • 0(Publication Date)
  • PublishDrive

    (Publisher)

  Change > (greater than) to < (less than) and then change the document.write messages so they are correct. What happens now?

  The last operator to talk about is the === symbols. These are known as the identity operator and we use this when we want to check equality in a variable and that it is of the same type of variable. Look at this example:

  var identity = 27; if (identity === 27) { document.write("variable is the number 27"); } else if (identity == 27) { document.write("variable is the text 27"); }

  When you run this, the initial IF statement should evaluate true which means that the variable does contain the value of 27 and that it is of a number type. However, if you were to change the initial line to this:

  var identity = "27"; Because we have placed 27 inside quotes, we turned it into a text string so, when we run the code again, the ELSE part will now evaluate true while the first bit evaluates to false. The === symbol gives you far more precision than the == symbol. Don’t worry yourself too much about this though; unless it is absolutely necessary, we will continue to use the == symbol. In the next part, we will be looking at logical operators.

  Logical Operators

  T he best operators

  to use with conditional IF statements are logical operators. These provide you with many more options to use in your IF statements but there are only three that you really need to learn:

  ●  && - Two ampersands mean AND ●  || = Two pipe characters mean OR ●  ! - One exclamation mark/point means NOT

  Let’s create this code for a web page. Create a new page or use your template

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Beginning Java Programming

  The Object-Oriented Approach

  • Bart Baesens, Aimee Backiel, Seppe vanden Broucke(Authors)
  • 2015(Publication Date)
  • Wrox

    (Publisher)

  switch is an alternative structure that’s similar to an if-then statement, but offers a list of cases that can be defined so each is handled differently or so groups of cases can be handled the same. Finally, you’ll learn about some keywords that have specific uses in guiding the execution of a program.

  COMPARISONS USING OPERATORS AND METHODS

  You have already seen operators, such as arithmetic operators, in Chapter 2. Operators are based on mathematical concepts and many will look familiar, even to those unfamiliar with programming. This chapter discusses two types of control operators, comparative and logical, that are used frequently in control structures. The syntax for operators will differ whether the data type is primitive or composite. Recall that primitive types include char , boolean , and many numeric representations, like int , double , and float . Arrays, strings, and other defined classes are composite data types.

  Comparing Primitive Data Types with Comparison Operators

  Given the importance of operators when defining control structures, this section briefly revisits some of the underlying concepts covered in Chapter 2.

  For primitive data types, there are well-defined operators, as outlined in Table 5.1 , which can be used to compare the values of two variables. Equality and relational comparison operators compare the values of two operands for equality, inequality, greater than, or less than. The result of these expressions is a Boolean true or false . With primitive types, the following expressions are used for comparison:

  • Equal: ==
  • Not equal: !=
  • Greater than: >
  • Greater than or equal: >=
  • Less than: <
  • Less than or equal: <=

  Table 5.1

  Control Operators for Primitive Data Types

  OPERATOR	JAVA SYNTAX	ENGLISH EQUIVALENT
  Equality	x == y x != y	Is x equal to y ? Is x not equal to y ?
  Relational	x < y x <= y x > y x >= y	Is x less than y ? Is x less than or equal to y ? Is x greater than y ? Is x greater than or equal to y ?
  Logical	x && y x || y !x	Are x and y both true? Is x , y , or both true? Is x false?

  Note that the ! indicates negation. While these operators are used for most primitive data types, there is an exception; Boolean operands can only be compared with equality operators and not with relational operators. That is, true cannot be greater than or less than false ; however, true can be equal to true

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  HTML and CSS

  The Comprehensive Guide

  • Jürgen Wolf(Author)
  • 2023(Publication Date)
  • SAP PRESS

    (Publisher)

  false. var val01 ; // Empty variable is undefined and therefore false. var val02 = false ; 100 / "text" // is NaN (= Not a Number), therefore false null // null is always false. NaN // Not a Number, no number is false. Here’s another example: let mytext = "A text" ; let val01 = 100; if (val01 / mytext) { console.log('Calculation successful'); } else { console.log('NaN -> no valid value.'); } Here the statements would be executed in the alternate else block because the if condition returns false. The division of 100 / "A text" results in the symbolic value NaN (NaN = not a number) and is therefore invalid and false. 17.7.2    Using the Various Comparison Operators in JavaScript Besides the possibility to check whether a value is valid and equals true or just an invalid value and thus returns false, you can compare variables and values using the various comparison operators. Depending on whether the comparison is true or false, true or false will be returned here as well. To perform comparisons, JavaScript provides the comparison operators listed in Table 17.4. Operator Description Example (x=6; y=5) == Same as x==5; // false != Unequal to x != 5; // true === Same value and type x === y; // false x === 6; // true !== Different value or different type x !== y; // true x !== 6; // false > Greater than x > y; // true < Less than x < y; // false >= Greater than or equal to x >= y; // true x >= 6; // false <= Less than or equal to x <= y; // false x <=6; // true Table 17.4 Comparison Operators in JavaScript 17.7.3    Using the “if” Branch With the background knowledge of Boolean truth values and the comparison operators, you’ll be able to apply the if branches in practice. Let’s take a look at a simple example: let age = prompt('How old are you: '); if (age >= 18) { console.log("Access granted") } else { console.log("Access denied"); } When you run the example, the prompt() method opens a dialog in the browser window with an input field and an OK and Cancel button

  Sign up to read

  Learn more about book