Java challengers #2: сравнение строк

Строка как объект

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

var stringObject = new string(«This string is object»); //Определение строки как объектный тип данных
stringObject.name = «newString»; //Определение свойства name со значением newString

1 2	varstringObject=newstring(«This string is object»);//Определение строки как объектный тип данных stringObject.name=»newString»;//Определение свойства name со значением newString

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

Методы String

Метод	Описание
charAt()	Возвращает символ строки с указанным индексом (позицией).
charCodeAt()	Возвращает числовое значение Unicode символа, индекс которого был передан методу в качестве аргумента.
concat()	Возвращает строку, содержащую результат объединения двух и более предоставленных строк.
fromCharCode()	Возвращает строку, созданную с помощью указанной последовательности значений символов Unicode.
indexOf()	Возвращает позицию первого символа первого вхождения указанной подстроки в строке.
lastIndexOf()	Возвращает позицию последнего найденного вхождения подстроки или -1, если подстрока не найдена.
localeCompare()	Возвращает значение, указывающее, эквивалентны ли две строки в текущем языковом стандарте.
match()	Ищет строку, используя предоставленный шаблон регулярного выражения, и возвращает результат в виде массива. Если совпадений не найдено, метод возвращает значение null.
replace()	Ищет строку для указанного значения или регулярного выражения и возвращает новую строку, где указанные значения будут заменены. Метод не изменяет строку, для которой он вызывается.
search()	Возвращает позицию первого соответствия указанной подстроки или регулярного выражения в строке.
slice()	Позволяет извлечь подстроку из строки. Первый аргумент указывает индекс с которого нужно начать извлечение. Второй необязательный аргумент указывает позицию, на которой должно остановиться извлечение. Если второй аргумент не указан, то извлечено будет все с той позиции, которую указывает первый аргумент, и до конца строки.
split()	Разбивает строку на подстроки, возвращая массив подстрок. В качестве аргумента можно передать символ разделитель (например запятую), используемый для разбора строки на подстроки.
substr()	Позволяет извлечь подстроку из строки. Первый аргумент указывает индекс с которого нужно начать извлечение. Второй аргумент указывает количество символов, которое нужно извлечь.
substring()	Извлекает символы из строки между двух указанных индексов, если указан только один аргумент, то извлекаются символы от первого индекса и до конца строки.
toLocaleLowerCase()	Преобразует символы строки в нижний регистр с учетом текущего языкового стандарта.
toLocaleUpperCase()	Преобразует символы строки в верхний регистр с учетом текущего языкового стандарта.
toLowerCase()	Конвертирует все символы строки в нижний регистр и возвращает измененную строку.
toString()	Возвращает строковое представление объекта.
toUpperCase()	Конвертирует все символы строки в верхний регистр и возвращает измененную строку.
trim()	Удаляет пробелы в начале и конце строки и возвращает измененную строку.
valueOf()	Возвращает примитивное значение объекта.

Бонус: оператор switch-case

Не забывайте, что оператор switch-case производит проверку на строгое равенство (===), поэтому могут возникнуть казусы, например, если вы берете значение для проверки из формы — оно вам вернется строкового типа, его нельзя сравнивать с числами в case:

var select = document.getElementById(‘answer’); // где-то в html есть select с id=»answer»
var answer = select.value;
switch (answer) {
case 1:
alert(«Верно!»);
break;
case 2:
alert(«Неверно!»);
break;
}

1 2 3 4 5 6 7 8 9 10

varselect=document.getElementById(‘answer’);// где-то в html есть select с id=»answer» varanswer=select.value; switch(answer){ case1 alert(«Верно!»); break; case2 alert(«Неверно!»); break; }

В данном примере ничего не произойдет, потому что в переменной answer значение типа string, а в разделах case — значения типа number.

Доступ к символам

Продемонстрируем, как получить доступ к символам и индексам строки How are you?

"How are you?";

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

"How are you?";

Вывод

r

Мы также можем использовать метод charAt(), чтобы вернуть символ, передавая индекс в качестве параметра.

"Howareyou?".charAt(5);

Вывод

r

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

"How are you?".indexOf("o");

Вывод

1

Несмотря на то, что символ «o» появляется в строке How are you? дважды, indexOf() вернёт позицию первого вхождения.

lastIndexOf() используется, чтобы найти последнее вхождение.

"How are you?".lastIndexOf("o");

Вывод

9

Оба метода также можно использовать для поиска нескольких символов в строке. Они вернут индекс первого символа.

"How are you?".indexOf("are");

Вывод

4

А вот метод slice() вернёт символы между двумя индексами.

"How are you?".slice(8, 11);

Вывод

you

Обратите внимание на то, что 11– это ?, но? не входит в результирующую строку. slice() вернёт всё, что между указанными значениями индекса

Если второй параметр опускается, slice() вернёт всё, начиная от первого параметра до конца строки.

"How are you?".slice(8);

Вывод

you?

Методы charAt() и slice() помогут получить строковые значения на основании индекса. А indexOf() и lastIndexOf() делают противоположное, возвращая индексы на основании переданной им строки.

Определение строки

Строкой считается любая последовательность символов в пределах двойных или одинарных кавычек.

var someString = «This is a string»;
var anotherString = ‘This is another string’;

1 2	varsomeString=»This is a string»; varanotherString=’This is another string’;

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

var string = «String with \»quoted\» word»;
var string = ‘String with \’quoted\’ word’;
var string = ‘String with «quoted» word’;
var string = «String with ‘quoted’ word»;
var string = «It’s single quote string»; //Апостроф внутри строки
var string = ‘<div id=»block»>This is block</div>’; //В строке может содержаться код HTML

1 2 3 4 5 6

varstring=»String with \»quoted\» word»; varstring=’String with \’quoted\’ word’; varstring=’String with «quoted» word’; varstring=»String with ‘quoted’ word»; varstring=»It’s single quote string»;//Апостроф внутри строки varstring='<div id=»block»>This is block</div>’;//В строке может содержаться код HTML

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

Символ	Обозначение
\’	одинарная кавычка
\»	двойная кавычка
\\	обратный слэш (не путать с // — знаком начала комментария)
\n	новая строка (работает как кнопка Enter)
\r	возврат каретки в начало строки (работает как кнопка Home)
\t	табуляция (работает как кнопка Tab)
\b	удаление символа (работает как кнопка Backspace)
\f	печать с новой страницы (устаревшее)
\v	вертикальная табуляция (устаревшее)
\a	звуковой сигнал (устаревшее)
\xXX	символ из Latin-1, где XX шестнадцатеричные цифры (например: \xAF — символ  ‘-‘)
\XXX	символ из Latin-1, где XXX восьмеричные цифры от 1 до 377 (например: \300 — символ ‘À’)
\ucXXXX	символ из Unicode, где XXXX шестнадцатеричные цифры (например: \uc454 — символ  ‘쑔’)

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

var longString = «Lorem ipsum dolor sit amet, consectetur adipisicing elit.\
Aliquam eligendi non ipsum autem facere repellendus doloremque, \
architecto obcaecati culpa dolores eveniet qui, beatae suscipit ab nisi ad vero, sed cum!»;

1 2 3

varlongString=»Lorem ipsum dolor sit amet, consectetur adipisicing elit.\                   Aliquam eligendi non ipsum autem facere repellendus doloremque, \                   architecto obcaecati culpa dolores eveniet qui, beatae suscipit ab nisi ad vero, sed cum!»;

Однако использование следующего приема для разбиения кода недопустимо.

var string = «Lorem ipsum dolor sit amet,» + \
«consectetur adipisicing elit.»;

1 2	varstring=»Lorem ipsum dolor sit amet,»+\ «consectetur adipisicing elit.»;

Улучшена поддержка юникода

Внутренняя кодировка строк в JavaScript – это UTF-16, то есть под каждый символ отводится ровно два байта.

Но под всевозможные символы всех языков мира 2 байт не хватает. Поэтому бывает так, что одному символу языка соответствует два юникодных символа (итого 4 байта). Такое сочетание называют «суррогатной парой».

Самый частый пример суррогатной пары, который можно встретить в литературе – это китайские иероглифы.

Заметим, однако, что не всякий китайский иероглиф – суррогатная пара. Существенная часть «основного» юникод-диапазона как раз отдана под китайский язык, поэтому некоторые иероглифы – которые в неё «влезли» – представляются одним юникод-символом, а те, которые не поместились (реже используемые) – двумя.

Например:

В тексте выше для первого иероглифа есть отдельный юникод-символ, и поэтому длина строки , а для второго используется суррогатная пара. Соответственно, длина – .

Китайскими иероглифами суррогатные пары, естественно, не ограничиваются.

Ими представлены редкие математические символы, а также некоторые символы для эмоций, к примеру:

В современный JavaScript добавлены методы String.fromCodePoint и str.codePointAt – аналоги и , корректно работающие с суррогатными парами.

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

…В то время как возвращает его Unicode-код суррогатной пары правильно:

Метод корректно создаёт строку из «длинного кода», в отличие от старого .

Например:

Более старый метод в последней строке дал неверный результат, так как он берёт только первые два байта от числа и создаёт символ из них, а остальные отбрасывает.

Есть и ещё синтаксическое улучшение для больших Unicode-кодов.

В JavaScript-строках давно можно вставлять символы по Unicode-коду, вот так:

Синтаксис: , где – четырёхзначный шестнадцатиричный код, причём он должен быть ровно четырёхзначным.

«Лишние» цифры уже не войдут в код, например:

Чтобы вводить более длинные коды символов, добавили запись , где – максимально восьмизначный (но можно и меньше цифр) код.

Например:

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

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

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

Например, если после символа идёт символ «точка сверху» (код ), то показано это будет как «S с точкой сверху» .

Если нужен ещё значок над той же буквой (или под ней) – без проблем. Просто добавляем соответствующий символ.

К примеру, если добавить символ «точка снизу» (код ), то будет «S с двумя точками сверху и снизу» .

Пример этого символа в JavaScript-строке:

Такая возможность добавить произвольной букве нужные значки, с одной стороны, необходима, а с другой стороны – возникает проблемка: можно представить одинаковый с точки зрения визуального отображения и интерпретации символ – разными сочетаниями Unicode-кодов.

Вот пример:

В первой строке после основы идёт сначала значок «верхняя точка», а потом – нижняя, во второй – наоборот. По кодам строки не равны друг другу. Но символ задают один и тот же.

С целью разрешить эту ситуацию, существует юникодная нормализация, при которой строки приводятся к единому, «нормальному», виду.

В современном JavaScript это делает метод str.normalize().

Забавно, что в данной конкретной ситуации приведёт последовательность из трёх символов к одному: \u1e68 (S с двумя точками).

Это, конечно, не всегда так, просто в данном случае оказалось, что именно такой символ в юникоде уже есть. Если добавить значков, то нормализация уже даст несколько символов.

Для большинства практических задач информации, данной выше, должно быть вполне достаточно, но если хочется более подробно ознакомиться с вариантами и правилами нормализации – они описаны в приложении к стандарту юникод Unicode Normalization Forms.

substring

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

В следующем примере мы покажем, как достичь тех же самых результатов, используя substring:

var str = 'невероятно';
var str2 = str.substring(2);
console.log( str2 ); // вероятно

var str3 = str.substring(2, 4);
console.log( str3 ); // ве

// используем str.length для указания индекса, считая с конца строки
var str4 = str.substring( str.length -4 );
console.log( str4 ); // ятно

var str5 = str.substring( str.length -4, str.length -2 );
console.log( str5 ); // ят

Мы получили те же самые результаты, используя метод substring. Но из-за того, что отрицательные числа не поддерживаются, его довольно неудобно использовать, если нужно указать индекс, начиная с конца строки.

Немного о «length»

Свойство автоматически обновляется при изменении массива. Если быть точными, это не количество элементов массива, а наибольший цифровой индекс плюс один.

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

Обратите внимание, что обычно мы не используем массивы таким образом. Ещё один интересный факт о свойстве – его можно перезаписать

Ещё один интересный факт о свойстве – его можно перезаписать.

Если мы вручную увеличим его, ничего интересного не произойдёт. Зато, если мы уменьшим его, массив станет короче. Этот процесс необратим, как мы можем понять из примера:

Таким образом, самый простой способ очистить массив – это .

Точка – это любой символ

Точка – это специальный символьный класс, который соответствует «любому символу, кроме новой строки».

Для примера:

Или в середине регулярного выражения:

Обратите внимание, что точка означает «любой символ», но не «отсутствие символа». Там должен быть какой-либо символ, чтобы соответствовать условию поиска:. Обычно точка не соответствует символу новой строки

Обычно точка не соответствует символу новой строки .

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

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

Как раз для этого нужен флаг . Если регулярное выражение имеет его, то точка соответствует буквально любому символу:

Внимание, пробелы!

Обычно мы уделяем мало внимания пробелам. Для нас строки и практически идентичны.

Но если регулярное выражение не учитывает пробелы, оно может не сработать.

Давайте попробуем найти цифры, разделённые дефисом:

Исправим это, добавив пробелы в регулярное выражение :

Пробел – это символ. Такой же важный, как любой другой.

Нельзя просто добавить или удалить пробелы из регулярного выражения, и ожидать, что оно будет также работать.

Другими словами, в регулярном выражении все символы имеют значение, даже пробелы.

Как сделать Object и простые объекты итерируемыми

Простые объекты не являются итерируемыми, как и объекты из .

Однако этот момент можно обойти, добавив @@iterator к Object.prototype с пользовательским итератором.

Переменная  содержит свойства объекта, полученного с помощью вызова . В функции next возвращается каждое значение из переменной properties и обновляется count, чтобы получить следующее значение из переменной properties, используя переменную count в качестве индекса. Когда count будет равен длине properties, устанавливаем значение true, чтобы остановить итерацию.

Тестирование с помощью Object:

Работает!!!

С простыми объектами:

Та-дам!! 

Стоить добавить этот способ в качестве полифилла, чтобы использовать for..of с любыми объектами в приложении.

Использование for…of с классами ES6

Можно использовать for..of для итерации по списку данных в экземпляре класса.

Класс Profiles обладает свойством , которое содержит массив пользователей. Возможно, потребуется отобразить эти данные в приложении с помощью for…of. Пробуем:

Очевидно, for…of не сработает

Вот несколько правил, чтобы сделать  итерируемым:

• Объект должен иметь свойство .
• Функция  должна возвращать итератор.
•  должен реализовывать функцию .

Свойство @@iterator определяется с помощью константы .

Запускаем:

Свойство profiles отображено.

Итерируемые объекты и псевдомассивы

Есть два официальных термина, которые очень похожи, но в то же время сильно различаются. Поэтому убедитесь, что вы как следует поняли их, чтобы избежать путаницы.

• Итерируемые объекты – это объекты, которые реализуют метод , как было описано выше.
• Псевдомассивы – это объекты, у которых есть индексы и свойство , то есть, они выглядят как массивы.

При использовании JavaScript в браузере или других окружениях мы можем встретить объекты, которые являются итерируемыми или псевдомассивами, или и тем, и другим.

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

Но итерируемый объект может не быть псевдомассивом. И наоборот: псевдомассив может не быть итерируемым.

Например, объект из примера выше – итерируемый, но не является псевдомассивом, потому что у него нет индексированных свойств и .

А вот объект, который является псевдомассивом, но его нельзя итерировать:

Что у них общего? И итерируемые объекты, и псевдомассивы – это обычно не массивы, у них нет методов , и т.д. Довольно неудобно, если у нас есть такой объект и мы хотим работать с ним как с массивом. Например, мы хотели бы работать с , используя методы массивов. Как этого достичь?

Поиск в строке

• Чтобы определить вхождение слова или символа в строку, используйте функцию «indexOf». Она возвращает позицию найденной подстроки или «-1», если ничего не найдено.

  let s = 'Hello world!';
  
  if (s.indexOf('world') != -1) {
      console.log('world Is found');
  } else {
      console.log('world Isn\'t found');
  }
  

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

  let s = 'Happy new 2020 year! Next year — 2021.';
  let Regex = /(\d+)/g;
  let year;
  
  if (year = s.match(Regex)) { 
      console.log(year); // 2020
      console.log(year); // 2021
  } else { 
      console.log('not found');
  }
  

  Переменная «Regex» содержит регулярное выражение, со специальным правилом для поиска. В данном примере конструкция «(\d+)» обозначает последовательность цифр. В качестве результата возвращается массив со всеми найденными элементами. Если убрать директиву «g», то в результат попадет только первый найденный элемент.

  Регулярные выражения в js — это отдельная тема. Частично можете ознакомиться с ними из статьи по валидации полей.

Приоритет операторов

В том случае, если в выражении есть несколько операторов – порядок их выполнения определяется приоритетом, или, другими словами, существует определённый порядок выполнения операторов.

Из школы мы знаем, что умножение в выражении выполнится раньше сложения. Это как раз и есть «приоритет». Говорят, что умножение имеет более высокий приоритет, чем сложение.

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

В JavaScript много операторов. Каждый оператор имеет соответствующий номер приоритета. Тот, у кого это число больше, – выполнится раньше. Если приоритет одинаковый, то порядок выполнения – слева направо.

Отрывок из таблицы приоритетов (нет необходимости всё запоминать, обратите внимание, что приоритет унарных операторов выше, чем соответствующих бинарных):

Приоритет	Название	Обозначение
…	…	…
17	унарный плюс
17	унарный минус
16	возведение в степень
15	умножение
15	деление
13	сложение
13	вычитание
…	…	…
3	присваивание
…	…	…

Так как «унарный плюс» имеет приоритет , который выше, чем у «сложения» (бинарный плюс), то в выражении сначала выполнятся унарные плюсы, а затем сложение.

Спецсимволы

Если мы применяем одинарные либо двойные кавычки, мы тоже можем создавать многострочные строки. Для этого понадобится символ перевода строки \n:

let guestList = "Guests:\n * Bob\n * Petr\n * Maria";

alert(guestList); // список гостей из нескольких строк

Две строки ниже являются эквивалентными. Разница в том, что они по-разному записаны:

// используем спецсимвол перевода строки
let str1 = "Hello\nWorld";

// используем обратные кавычки
let str2 = `Hello
World`;

alert(str1 == str2); // true

Существует и масса других спецсимволов:

Рассмотрим парочку примеров с Юникодом:

// 
alert( "\u00A9" );

// Длинные коды
// 佫, редкий китайский иероглиф
alert( "\u{20331}" );
// , улыбающийся смайлик с глазами-сердечками
alert( "\u{1F60D}" );

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

alert( 'I\'m the God!' ); // I'm the God!

Но экранировать нужно только тогда, когда внутри строки мы используем такие же кавычки, в которые эта самая строка заключена. Таким образом, можно поступать проще:

alert( `I'm the Walrus!` ); // I'm the Walrus!

Как видите, мы поместили строку в косые кавычки, а раздели I’m одинарной кавычкой. Просто и элегантно.

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

alert( `The backslash: \\` ); // The backslash: \

localeCompare()

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

Язык определяется настоящим местоположением или вы можете указать его, как второй аргумент:

Очень часто его используют для сортировки массивов:

Где бы вы обычно использовали:

Только тут мы можем это сделать с помощью localeCompare(), который позволит нам работать с алфавитами по всему миру.

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

Примитив как объект

Вот парадокс, с которым столкнулся создатель JavaScript:

• Есть много всего, что хотелось бы сделать с примитивами, такими как строка или число. Было бы замечательно, если бы мы могли работать с ними через вызовы методов.
• Примитивы должны быть лёгкими и быстрыми.

Выбранное решение, хотя выглядит оно немного неуклюже:

1. Примитивы остаются примитивами. Одно значение, как и хотелось.
2. Язык позволяет осуществлять доступ к методам и свойствам строк, чисел, булевых значений и символов.
3. Чтобы это работало, при таком доступе создаётся специальный «объект-обёртка», который предоставляет нужную функциональность, а после удаляется.

Каждый примитив имеет свой собственный «объект-обёртку», которые называются: , , и . Таким образом, они имеют разный набор методов.

К примеру, существует метод str.toUpperCase(), который возвращает строку в верхнем регистре.

Вот, как он работает:

Очень просто, не правда ли? Вот, что на самом деле происходит в :

1. Строка – примитив. В момент обращения к его свойству, создаётся специальный объект, который знает значение строки и имеет такие полезные методы, как .
2. Этот метод запускается и возвращает новую строку (показывается в ).
3. Специальный объект удаляется, оставляя только примитив .

Получается, что примитивы могут предоставлять методы, и в то же время оставаться «лёгкими».

Движок JavaScript сильно оптимизирует этот процесс. Он даже может пропустить создание специального объекта. Однако, он всё же должен придерживаться спецификаций и работать так, как будто он его создаёт.

Число имеет собственный набор методов. Например, toFixed(n) округляет число до n знаков после запятой.

Более подробно с различными свойствами и методами мы познакомимся в главах Числа и Строки.

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

Некоторые языки, такие как Java, позволяют явное создание «объектов-обёрток» для примитивов при помощи такого синтаксиса как или .

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

Например:

Объекты в всегда дают , так что в нижеприведённом примере будет показан :

С другой стороны, использование функций без оператора – вполне разумно и полезно. Они превращают значение в соответствующий примитивный тип: в строку, в число, в булевый тип.

К примеру, следующее вполне допустимо:

null/undefined не имеют методов

Особенные примитивы и являются исключениями. У них нет соответствующих «объектов-обёрток», и они не имеют никаких методов. В некотором смысле, они «самые примитивные».

Попытка доступа к свойствам такого значения возвратит ошибку:

includes, startsWith, endsWith

Следующие три
метода позволяют проверять: есть ли в строке искомая подстрока. Первый метод
имеет ожидаемый синтаксис:

str.includes(substr)

он возвращает true, если подстрока
substr была найдена в
строке str и false в противном
случае. Второй необязательный параметр pos указывает
начальный индекс для поиска. Вот примеры использования данного метода:

let str = '<span class="clock">12:34</span>';
console.log( str.includes("span") );
console.log( str.includes("<span>") );
console.log( str.includes("clock", 20) );

Следующие два
метода startsWith и endsWith проверяют, соответственно, начинается ли и
заканчивается ли строка определённой строкой:

console.log( str.startsWith("span") );      //false
console.log( str.startsWith("<span") );        //true
console.log( str.endsWith("span>") );        //true

Итого

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

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

– Происходит в математических операциях. Может быть вызвано с помощью .

Преобразование подчиняется правилам:

Значение	Становится…
	Пробельные символы по краям обрезаются. Далее, если остаётся пустая строка, то получаем , иначе из непустой строки «считывается» число. При ошибке результат .

– Происходит в логических операциях. Может быть вызвано с помощью .

Подчиняется правилам:

Значение	Становится…
, , , ,
любое другое значение

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

• при численном преобразовании становится , не .
• и строки из одних пробелов типа при логическом преобразовании всегда .

В этой главе мы не говорили об объектах. Мы вернёмся к ним позже, в главе Преобразование объектов в примитивы, посвящённой только объектам, сразу после того, как узнаем больше про основы JavaScript.