Javascript not equal function

Example 9: Logical AND Operator

const a = true, b = false; const c = 4; // logical AND console.log(a && a); // true console.log(a && b); // false console.log((c > 2) && (c < 2)); // false

Example 10: Logical OR Operator

const a = true, b = false, c = 4; // logical OR console.log(a || b); // true console.log(b || b); // false console.log((c>2) || (c<2)); // true

Example 11: Logical NOT Operator

const a = true, b = false; // logical NOT console.log(!a); // false console.log(!b); // true

Answer by Jakari Carrillo

Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers , Meta Stack Overflow , Stack Overflow help chat , Outdated Answers: accepted answer is now unpinned on Stack Overflow

The !== opererator tests whether values are not equal or not the same type. i.e.

var x = 5; var y = '5'; var 1 = y !== x; // true var 2 = y != x; // false 

Answer by Rohan Hester

!= not equal !== not equal value OR type

Answer by Juliet Clayton

Example of JavaScript Strict Not equal (!==) operator ,Example of JavaScript Strict equal (===) operator ,Example of JavaScript Not equal (!=) operator ,Example of JavaScript Equal (==) operator

2 == 2 // true 2 == 3 // false 2 == '2' // true "4" == 4 // true 

JavaScript Code:

function test_Equal(num) < if (num == 15) < return "Equal"; >return "Not equal"; > console.log(test_Equal('15')); // "Equal" console.log(test_Equal(15)); // "Equal" console.log(test_Equal(25)); // "Not equal" 

JavaScript Code:

function test_Strict(num) < if (num === 15) < return "Equal"; >return "Not equal"; > console.log(test_Strict(15)); // "Equal" console.log(test_Strict('15')); // "Not equal" console.log(test_Strict(25)); // "Not equal" 

3 != 4 // true 3 != "3" // false 3 != '3' // false 3 != true // false 0 != false // false 

JavaScript Code:

function test_NotEqual(num) < if (num != 55) < return "Not Equal"; >return "Equal"; > console.log(test_NotEqual(45)); // "Not Equal" console.log(test_NotEqual(55)); // "Equal" console.log(test_NotEqual(75)); // "Not Equal" 

2 !== 2 // false 2 !== '2' // true 3 !== 2 // true 

JavaScript Code:

function test_StrictNotEqual(num) < if (num !== 15) < return "Not equal"; >return "Equal"; > console.log(test_StrictNotEqual(15)); // "Equal" console.log(test_StrictNotEqual(20)); // "Not equal" console.log(test_StrictNotEqual(25)); // "Not equal" 

6 > 4 // true 8 > '4' // true 3 > 2 // false '2' > 5 // false 

JavaScript Code:

function test_GreaterThan(num) < if (num >50) < return "Over 50"; >if (num > 15) < return "Over 15"; >return "10 or under"; > console.log(test_GreaterThan(70)); // "Over 50" console.log(test_GreaterThan(10)); // "10 or under" console.log(test_GreaterThan(45)); // "Over 15" 

5 >= 5 // true 8 >= '4' // true 3 >= 5 // false '5' >= 7 // false 

JavaScript Code:

function test_GreaterOrEqual(num) < if (num >= 50) return "50 or Over"; if (num >= 20) return "20 or Over"; return "Less than 20"; > console.log(test_GreaterOrEqual(70)); // "50 or Over" console.log(test_GreaterOrEqual(10)); // "Less than 20" console.log(test_GreaterOrEqual(45)); // "20 or Over" 

JavaScript Code:

function test_GreaterThan(num) < if (num < 50) < return "Less than 50"; >if (num < 15) < return "Less than 15"; >return "10 or under"; > console.log(test_GreaterThan(70)); // "Less than 50" console.log(test_GreaterThan(10)); // "Less than 15" console.log(test_GreaterThan(45)); // "10 or under"

JavaScript Code:

function test_LessOrEqual(num) < if (num console.log(test_LessOrEqual(50)); // "Smaller Than or Equal to 50" console.log(test_LessOrEqual(10)); // "Smaller Than or Equal to 25" console.log(test_LessOrEqual(75)); // "More Than 50" 

Answer by Salem Hoover

A more obvious false result occurs when comparing with === (strict equality) because the type is considered:,Unexpected situations can occur when comparing truthy and falsy values using the == loose equality:,The situation is clearer when using a strict comparison because the value types must match:,Use a === strict equality (or !== strict inequality) comparisons to compare values and avoid type conversion issues:

JavaScript variables are loosely/dynamically typed and the language doesn’t care how a value is declared or changed:

let x; x = 1; // x is a number x = '1'; // x is a string x = [1]; // x is an array 

Seemingly different values equate to true when compared with == (loose or abstract equality) because JavaScript (effectively) converts each to a string representation before comparison:

A more obvious false result occurs when comparing with === (strict equality) because the type is considered:

// all true false == 0; 0 == ''; null == undefined; [] == false; !![0] == true; // all false false == null; NaN == NaN; Infinity == true; [] == true; [0] == true; 

It’s rarely necessary to compare two truthy and falsy values when a single value will always equate to true or false:

// instead of if (x == false) // . // runs if x is false, 0, '', or [] // use if (!x) // . // runs if x is false, 0, '', NaN, null or undefined 

Use a === strict equality (or !== strict inequality) comparisons to compare values and avoid type conversion issues:

// instead of if (x == y) // . // runs if x and y are both truthy or both falsy // e.g. x = null and y = undefined // use if (x === y) // . // runs if x and y are identical. // except when both are NaN 

You can convert any value to a real Boolean value in JavaScript using either the Boolean constructor, or a double-negative !! . This will allow you to be absolutely certain a false is generated only by false , 0 , "" , null , undefined and NaN :

// instead of if (x === y) // . // runs if x and y are identical. // except when both are NaN // use if (Boolean(x) === Boolean(y)) // . // or if (!!x === !!y) // . // runs if x and y are identical. // including when either or both are NaN 

The Boolean constructor returns true when passed a truthy value and returns false when passed a falsy value. This could be useful when combined with an iteration method. For example:

const truthy_values = [ false, 0, ``, '', "", null, undefined, NaN, '0', 'false', [], <>, function() <> ].filter(Boolean); // Filter out falsy values and log remaining truthy values console.log(truthy_values); 

Источник

JavaScript not equal and Comparison Operators Explained

In this tutorial, you will learn about JavaScript not equal to operator, and the other Comparison operators along with examples.

Table of Contents - JavaScript Not Equal:

What are Comparison Operators in JS?

Comparison operators in programming languages are used to compare two values. These operators return a boolean value (true or false) based on the condition. Hence these operators are used in decision making or as conditional statements for loops.

Given its vast usage, every developer should understand the functionality of each operator. This article is a good starting point for the same, however, we do emphasize more on the JavaScript not equal (!= & !==) operators.

What is “!=” in JS?

The JavaScript not equal or inequality operator (!=) checks whether two values are not equal and returns a boolean value. This operator tries to compare values irrespective of whether they are of different types.

However, the “!==” or Strict inequality operator does not attempt to do so and returns false if the values are unequal or of different types.

Both these operators solve different purposes and hence I would recommend practicing them to facilitate further understanding.

Code and Explanation:

console.log(5 != 10); // expected output: true console.log(10 != 10); // expected output: false console.log(10 != '10'); // expected output: false console.log(10 !== '10'); // expected output: true 

In the first case, it returned true as the values were different. In the second and third cases, it returned a false cause the values are the same. Do note that in the latter case even though we passed 10 as a string the operator was able to compare both the values.

In the last case, we used the strict inequality operator and it returned true as the values were of different types.

Other Comparison Operators:

Apart from the JavaScript not equal and Strict inequality operators, we have a few other operators that solve different use cases. We have added a brief about them below.

• Equal to (==) - Check if two values are equal
• Strict equal to (===) - Checks is two values are equal and of similar type
• Greater than (>) - Checks if the value on the left is greater than the value on the right
• Greater than or equal to (>=) - Checks if the value is greater than or equal to the value on the right
• Less than ( <) - Checks if the value on the left is less than the value on the right
• Less than or equal to ( <=) - Checks if the value is less than or equal to the value on the right

Code and Explanation:

console.log(5 == 10); // expected output: false console.log(10 === 10); // expected output: true console.log(10 ==='10'); // expected output: false console.log(5 > 10); // expected output: false console.log(5 >= 5); // expected output: false console.log(5 < 10); // expected output: true console.log(5