Как сравнить строки в javascript

Операторы сравнения JavaScript

В этом разделе мы познакомимся с операторами сравнения и с логическими значениями, которые такие операторы возвращают.

• больше
• меньше
• больше или равно
• меньше или равно
• равно
• неравно

Операторы сравнения возвращают логическое значение. Таких значений может быть только два:

• — да, верно, истина
• — нет, неверно, ложь

Логические значения можно присваивать переменным явно:

Можно присвоить переменной логическое значение как результат операции (сравнения):

Сравнение строк

Строки сравниваются побуквенно, слева-направо. Берутся две строки и начинается сравнение. Берется первый символ первой строки и сравнивается с первым символом второй строки. Если они равны, то берутся второй символ первой строки и сравнивается со вторым символом второй строки.

И так последовательно производится сравнение строк до того момента, пока не случится так, что определенный символ первой строки неравен соответствующему символу второй строки.

На этом дальнейшее сравнение строк прекращается и делается вывод, какая строка больше или меньше другой на основании того, больше или меньше соответствующие символы этой строки.

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

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

Ниже приведены примеры (как же без них?), иллюстрирующие сравнение строк.

Первый символ первой строки больше первого символа второй строки, дальнейшее сравнение прекращается и делается вывод, что первая строка больше второй строки:

В этом примере сравнение идет последовательно (символ в символ) вплоть до третьего по порядку символа, на котором сравнение прерывается, так как символ “c” по числовому значению больше символа “н”. На основании этого делается вывод, что первая строка “Вася” больше второй строки “Ваня”:

Любая буква (символ) больше отсутствия буквы. Например, первая строка больше второй, так как буква “е” в первой строке больше отсутствия таковой во второй строке:

Интересный пример сравнения связан обработкой введенных пользователем данных. Все данные, вводимые пользователем на странице, являются строковым типом. Поэтому сравнивать их, не выполнив предварительное преобразование типов, нельзя. Например:

… с точки зрения JavaScript будет верным , так как строка “4” больше строки “15” (первый символ “4” больше первого символа “1”). Однако, в данном случае пользователем введены два числа 4 и 15, а не строки. Поэтому их необходимо привести к числовому типу и уже тогда сравнивать:

Сравнение разных типов

Если производится сравнение данных различного типа, то JavaScript производит автоматическое (правильно такое преобразование называется неявным преобразованием) преобразование всех данных к числовому типу. И тогда производится сравнение чисел.

Строковый тип “34” приводится к числовому типу (числу) 34 и производится сравнение между числом 34 и числом 33:

Булев тип приводится к числовому типу 0 ( , ) и производится сравнение двух (одинаковых в данном случае) чисел 0:

Может понадобиться ситуация, когда нужно производить сравнение данных без автоматического преобразования типов. Другими словами, если в операции сравнения присутствует строка, то она должна оставаться строкой; если булев тип, то он должен оставаться булевым типом.

Для этой цели используется оператор строгого равенства ( ) и строгого неравенства ( ). То есть, к обычным операторам равенства ( ) и неравентсва ( ) добавляется еще один символ ( ).

Если тип разный, то операция сравнения всегда возвращает значение :

Строгое сравнение предпочтительно, если мы хотим быть уверены, что «сюрпризов» не будет.

Вывод: любые сравнения с , кроме точного , следует делать с осторожностью. Желательно не использовать сравнения с ними, во избежание ошибок в коде.

• В JavaScript есть логические значения (истина) и (ложь). Операторы сравнения возвращают их.
• Строки сравниваются побуквенно.
• Значения разных типов приводятся к числу при сравнении, за исключением строгого равенства ( ).
• Значения и равны друг другу и не равны ничему другому. В других сравнениях (с участием ) их лучше не использовать, так как они ведут себя не как 0.

Данная статья является пересказом соответствующего материала с ресурса learn.javascript.ru и не претендует на оригинальность.

Красивая функция trackBy

Пример красивой функции trackBy для Angular. Функция понравилась своей лаконичностью:<% highlight typescript %>public trackByNumber = (_. … Continue reading

4 способа сравнить строки в JavaScript

В этой заметке ты узнаешь как сравнивать строки в JS с примерами использования.

Строгое равенство строк

Чтобы понять равны ли две строки, можно использовать оператор строгого сравнения === . Он вернет false если строки отличаются и true , если они равны.

Сравнение строк с помощью === всегда происходит с учетом регистра, то есть учитываются большие и маленькие буквы.

Сравнение строк без учета регистра

Если тебе неважно в каком регистре написаны буквы в строках, то ты можешь перевести обе строки в нижний регистр и после этого выполнить сравнение.

Сравнение длины строк

Если тебе нужно узнать какая из двух строк длиннее, то операторы “больше” и “меньше” не подойдут. Они сравнивают строки в алфавитном порядке и учитывают длину строк только в самую последнюю очередь.

Длина строки хранится в специальном поле length . Сравнивая значение этого поля у разных строк, мы узнаем какая из них длиннее.

Проверка вхождения строки

Для того, чтобы проверить, входит ли одна строка в другую — используется встроенная функция includes .

Операторы сравнения

Многие операторы сравнения известны нам из математики.

В JavaScript они записываются так:

• Больше/меньше: a > b , a < b .
• Больше/меньше или равно: a >= b , a <= b .
• Равно: a == b . Обратите внимание, для сравнения используется двойной знак равенства == . Один знак равенства a = b означал бы присваивание.
• Не равно. В математике обозначается символом ≠ , но в JavaScript записывается как a != b .

В этом разделе мы больше узнаем про то, какие бывают сравнения, как язык с ними работает и к каким неожиданностям мы должны быть готовы.

В конце вы найдёте хороший рецепт того, как избегать «причуд» сравнения в JavaScript.

Результат сравнения имеет логический тип

Все операторы сравнения возвращают значение логического типа:

• true – означает «да», «верно», «истина».
• false – означает «нет», «неверно», «ложь».

Результат сравнения можно присвоить переменной, как и любое значение:

Сравнение строк

Чтобы определить, что одна строка больше другой, JavaScript использует «алфавитный» или «лексикографический» порядок.

Другими словами, строки сравниваются посимвольно.

Алгоритм сравнения двух строк довольно прост:

1. Сначала сравниваются первые символы строк.
2. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй. Сравнение завершено.
3. Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
4. Сравнение продолжается, пока не закончится одна из строк.
5. Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка.

В примерах выше сравнение ‘Я’ > ‘А’ завершится на первом шаге, тогда как строки ‘Коты’ и ‘Кода’ будут сравниваться посимвольно:

1. К равна К .
2. о равна о .
3. т больше, чем д . На этом сравнение заканчивается. Первая строка больше.

Приведённый выше алгоритм сравнения похож на алгоритм, используемый в словарях и телефонных книгах, но между ними есть и различия.

Например, в JavaScript имеет значение регистр символов. Заглавная буква "A" не равна строчной "a" . Какая же из них больше? Строчная "a" . Почему? Потому что строчные буквы имеют больший код во внутренней таблице кодирования, которую использует JavaScript (Unicode). Мы ещё поговорим о внутреннем представлении строк и его влиянии в главе Строки.

Сравнение разных типов

При сравнении значений разных типов JavaScript приводит каждое из них к числу.

Операторы сравнения в JavaScript. Как сравнить строки или всё познаётся в сравнении.

В этой статье мы поговорим об операторах сравнения в языке программирования JavaScript и отдельное внимание уделим тому, как сравнивать строки. Также вы узнаете, почему строчная «a» не равна заглавной «A».

Большинство операторов сравнения, используемых в JS, нам хорошо известны ещё из математики. Впрочем, операторы знакомы всем, кто имеет даже скромный опыт программирования на любых языках: — операторы «больше» и «меньше»: a > b, a < b; — операторы «больше либо равно», «меньше либо равно»: a >= b, a <= b; — оператор «равно»: a == b. Не забудьте, что в программировании оператор «равно» — это двойной знак равенства. Одинарное равно имеет оператор присваивания: a = b; — оператор «не равно». В школьной алгебре это ≠. В JavaScript, как и других языках, при написании оператора «равно» пишут равно и восклицательный знак: a != b.

Логический тип результата сравнения

Как и другие операторы, операторы сравнения тоже возвращают значение. В нашем случае у этого значения логический тип, а именно:

• true – значит «истина». • false – значит «ложь».

Кстати, у нас есть возможность присвоить результат сравнения какой-нибудь переменной:

Сравнение строк в JavaScript

Иногда нужно определить, является ли одна строка больше, чем другая. В языке JavaScript применяется «алфавитный» либо «лексикографический» порядок. Иначе говоря, сравнение строк осуществляется посимвольно.

Простой пример сравнения строк:

А вот алгоритм сравнения 2-х строк, который является весьма простым: 1. Поначалу происходит сравнение первых символов строк. 2. В случае, если 1-й символ первой строки больше или меньше 1-го символа второй строки, 1-я строка будет больше (или, соответственно, меньше), чем вторая строка. 3. Если же 1-е символы будут равны, происходит сравнение вторых символов строк. 4. Согласно алгоритму, сравнение продолжается до тех пор, пока одна из строк не закончится. 5. В случае, когда обе строки заканчиваются одновременно, эти строки равны. Или же, большей будет считаться та строка, которая длиннее.

Рассмотрим наши примеры. Очевидно, что сравнение ‘Я’ > ‘А’ закончится на 1-м шаге. Что касается строк «Ком» и «Код», то их сравнение будет осуществляться посимвольно следующим образом: 1. «К» равна «К». 2. «о» равна «о». 3. «м» является больше чем «д». А значит, сравнение строк заканчивается. Результат — первая строка больше, чем вторая.

Почему так получается? Потому что здесь используется на классический алфавит, а кодировка Unicode, в соответствии с которой каждый символ имеет свое значение на «машинном» языке. Таблицу символов русского языка можно посмотреть, например, здесь.

Кроме того, следует учитывать, что в JavaScript регистр символов тоже имеет значение. Если вы перейдёте по ссылке выше, то увидите, что строчная «a» не равна заглавной «A». Как видно из таблицы, строчная «a» будет больше.

Пожалуй, это основное из того, что нужно знать о сравнении строк. Собственно говоря, это простейшие вещи, которые должен знать каждый. Если же вас интересуют действительно продвинутые навыки программирования на JavaScript, добро пожаловать на наш курс!