Проверить равенство строк в JavaScript

  1. Когда использовать оператор для равенства строк в JavaScript
  2. Понимание строкового равенства в JavaScript с примерами

В JavaScript есть четыре оператора, которые вы можете использовать для проверки равенства строк. Эти операторы называются операторами сравнения.

  1. Строгое равенство (===): Строгое равенство (также известное как оператор тройного равенства) проверяет значение переменной и ее тип данных. Если обе эти вещи равны, тогда возвращается только true, иначе она возвращает false.
  2. Строгое не равно (!==): это противоположность Строгое равно. Если значение или тип данных не совпадают, возвращается true; в противном случае false.
  3. Равно (==): двойной знак равенства проверяет только значение переменной. Если значение совпадает, возвращается true, иначе возвращается false. Его не волнует тип переменной.
  4. Not Equal (!=): Это противоположность Equal (==). Он возвращает true, только если значения внутри переменных не совпадают, независимо от их типа данных. Если значения совпадают, возвращается false.

Эти операторы используются не только для проверки равенства строк, но и для проверки равенства других типов данных. Давайте выясним, какой из этих четырех операторов лучше всего подходит для проверки равенства строк в зависимости от вариантов использования.

Возможно, вы уже видели 3-й и 4-й операторы, то есть == и !=, Которые также довольно распространены в других языках программирования. Но то, как это работает в JavaScript, немного отличается от других языков.

Когда использовать оператор для равенства строк в JavaScript

В связи с JavaScript ниже приведены некоторые варианты использования, в которых вы можете использовать любой из операторов === или ==.

  • Если сравниваемое значение может быть либо true, либо ложным, используйте ===, а не ==.
  • Если сравниваемое значение может быть любым из этих конкретных значений (0, "" или [] - пустой массив), используйте === вместо ==.
  • В остальных случаях можно использовать ==. Это не только безопасно, но также упрощает ваш код и улучшает читаемость.

Те же правила применимы и при использовании операторов Строгое не равно (!==) и Не равно (!=). Чтобы узнать больше о конкретных правилах, вы можете прочитать раздел 11.9.3 спецификации ES5.

Понимание строкового равенства в JavaScript с примерами

Давайте возьмем несколько примеров и подробно разберемся в этих вещах.

В этом примере мы взяли две переменные: name_1 и name_2. Оба они принимают "adam" в качестве строкового значения. Теперь давайте применим каждый из перечисленных выше операторов и посмотрим, что мы получим.

Здесь мы использовали четыре оператора if и else, каждый из которых представляет разные операторы сравнения. Поскольку и значение, и тип данных одинаковы для переменных name_1 и name_2, оператор тройного равенства или Строгое равенства (===) напечатает True в качестве вывода. И двойное равенство == также выведет True, поскольку обе переменные имеют одинаковые значения.

let name_1 = "adam";
let name_2 = "adam";

// Strict Equal
if(name_1 === name_2) console.log("True");
else console.log("False");

// Equal
if(name_1 == name_2) console.log("True");
else console.log("False");

// Strict not equal
if(name_1 !== name_2) console.log("True");
else console.log("False");

// Not equal
if(name_1 != name_2) console.log("True");
else console.log("False");

Выход:

True
True
False
False

При использовании оператора Строго не равно (!==) и оператора не равно (!=) Они оба будут выводить False в качестве вывода, поскольку само значение одинаково в обеих переменных.

Ниже приведен еще один пример, в котором мы сравним строку с целым числом. Здесь у нас есть переменная str со значением "80", строковое значение. У нас есть еще одна переменная num, которая содержит целочисленное значение "80". Поскольку обе эти переменные имеют одинаковые значения с разными типами данных, давайте посмотрим, что произойдет при использовании с ними различных операторов сравнения.

let str = "80";
let num = 80;

// Strict Equal
if(str === num) console.log("True");
else console.log("False")

// Equal
if(str == num) console.log("True");
else console.log("False")

// Strict not equal
if(str !== num) console.log("True");
else console.log("False")

// Not equal
if(str != num) console.log("True");
else console.log("False")

Выход:

False
True
True
False

Как и в первом примере, у нас также есть четыре оператора if и else, каждый из которых представляет разные операторы сравнения.

Когда мы используем Строгое равенство или тройное равенство (===), мы получаем False в качестве вывода. Причина в том, что тип данных отличается, хотя значения совпадают. Но когда мы используем double equals (==), мы получаем True на выходе, потому что double equals проверяет только значение, а не тип.

И когда мы используем Strict not equal (!==), мы получаем True на выходе, потому что строковое значение "80" не равно целочисленному значению 80; следовательно, он возвращает True.

Наконец, оператор не равно (!=) Сравнивает только значения двух переменных. Для вывода True значения должны быть разными. Поскольку в этом случае значения совпадают, возвращается False.

Сопутствующая статья - JavaScript String

  • Удалить последний символ из строки в JavaScript
  • Добавить символ в строку в JavaScript
  • Добавление в строку JavaScript