Путь к пониманию шаблонных литералов в javascript

Breaking Long Code Lines

For best readability, programmers often like to avoid code lines longer than
80 characters.

If a JavaScript statement does not fit on one line, the best place to break
it is after an operator:

document.getElementById(«demo»).innerHTML =»Hello Dolly!»;

You can also break up a code line within a text string with a single backslash:

document.getElementById(«demo»).innerHTML =
«Hello \Dolly!»;

The method is not the preferred method. It might not have universal support.Some browsers do
not allow spaces behind the character.

A safer way to break up a string, is to use string
addition:

document.getElementById(«demo»).innerHTML = «Hello » + «Dolly!»;

You cannot break up a code line with a backslash:

Replacing String Content

The method replaces a specified value with another
value in a string:

Example

let text = «Please visit Microsoft!»;
let newText = text.replace(«Microsoft», «W3Schools»);

The method does not change the string it is called on. It returns a new string.

By default, the method replaces only the first match:

Example

let text = «Please visit Microsoft and Microsoft!»;
let newText = text.replace(«Microsoft», «W3Schools»);

By default, the method is case sensitive. Writing MICROSOFT (with
upper-case) will not work:

Example

let text = «Please visit Microsoft!»;
let newText = text.replace(«MICROSOFT», «W3Schools»);

To replace case insensitive, use a regular expression with an flag (insensitive):

Example

let text = «Please visit Microsoft!»;
let newText = text.replace(/MICROSOFT/i, «W3Schools»);

Note that regular expressions are written without quotes.

To replace all matches, use a regular expression with a flag (global match):

Example

let text = «Please visit Microsoft and Microsoft!»;
let newText = text.replace(/Microsoft/g, «W3Schools»);

You will learn a lot more about regular expressions in the chapter JavaScript Regular
Expressions.

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

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

• Оператор == — сравнение по значению
• Оператор === — сравнение по значению и по типу данных

var a = «one»;
var b = «two»;
var c = «one»;
var x = new string(«one»);
// (a == b) — false Значения не равны;
// (a == c) — true Значения равны;
// (a == x) — true Значения равны;
// (a === c) — true Значения и типы переменных равны;
// (a === x) — false Значения равны, а типы переменных нет, т.к. a — строка, x — объект.

1 2 3 4 5 6 7 8 9

vara=»one»; varb=»two»; varc=»one»; varx=newstring(«one»); // (a == b) — false Значения не равны; // (a == c) — true Значения равны; // (a == x) — true Значения равны; // (a === c) — true Значения и типы переменных равны; // (a === x) — false Значения равны, а типы переменных нет, т.к. a — строка, x — объект.

Escape Character

Because strings must be written within quotes, JavaScript will misunderstand this string:

let text = «We are the so-called «Vikings» from the north.»;

The string will be chopped to «We are the so-called «.

The solution to avoid this problem, is to use the backslash escape character.

The backslash () escape character turns special characters into string characters:

Code	Result	Description
\’	‘	Single quote
\»	«	Double quote
\\	\	Backslash

The sequence   inserts a double quote in a string:

Example

let text = «We are the so-called \»Vikings\» from the north.»;

The sequence   inserts a single quote in a string:

Example

let text= ‘It\’s alright.’;

The sequence   inserts a backslash in a string:

Example

let text = «The character \\ is called backslash.»;

Six other escape sequences are valid in JavaScript:

Code	Result
\b	Backspace
\f	Form Feed
\n	New Line
\r	Carriage Return
\t	Horizontal Tabulator
\v	Vertical Tabulator

The 6 escape characters above were originally designed to control
typewriters, teletypes, and fax machines. They do not make any sense in HTML.

JavaScript

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

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

Жадность

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

Все регулярные выражения в javascript – жадные. То есть, выражение старается отхватить как можно больший кусок строки.

Например, мы хотим заменить все открывающие тэги

На что и почему – не так важно

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

Это происходит из-за того, что точка-звёздочка в «жадном» режиме пытается захватить как можно больше, в нашем случае – это как раз до последнего .

Последний символ точка-звёздочка не захватывает, т.к. иначе не будет совпадения.

Как вариант решения используют квадратные скобки: :

Это работает. Но самым удобным вариантом является переключение точки-звёздочки в нежадный режим. Это осуществляется простым добавлением знака «» после звёздочки.

В нежадном режиме точка-звёздочка пустит поиск дальше сразу, как только нашла совпадение:

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

В javascript это сделать нельзя… Вот такая особенность. А вопросительный знак после звёздочки рулит – честное слово.

String Methods

Method	Description
charAt()	Returns the character at the specified index (position)
charCodeAt()	Returns the Unicode of the character at the specified index
concat()	Joins two or more strings, and returns a new joined strings
endsWith()	Checks whether a string ends with specified string/characters
fromCharCode()	Converts Unicode values to characters
includes()	Checks whether a string contains the specified string/characters
indexOf()	Returns the position of the first found occurrence of a specified value in a string
lastIndexOf()	Returns the position of the last found occurrence of a specified value in a string
localeCompare()	Compares two strings in the current locale
match()	Searches a string for a match against a regular expression, and returns the matches
repeat()	Returns a new string with a specified number of copies of an existing string
replace()	Searches a string for a specified value, or a regular expression, and returns a new string where the specified values are replaced
search()	Searches a string for a specified value, or regular expression, and returns the position of the match
slice()	Extracts a part of a string and returns a new string
split()	Splits a string into an array of substrings
startsWith()	Checks whether a string begins with specified characters
substr()	Extracts the characters from a string, beginning at a specified start position, and through the specified number of character
substring()	Extracts the characters from a string, between two specified indices
toLocaleLowerCase()	Converts a string to lowercase letters, according to the host’s locale
toLocaleUpperCase()	Converts a string to uppercase letters, according to the host’s locale
toLowerCase()	Converts a string to lowercase letters
toString()	Returns the value of a String object
toUpperCase()	Converts a string to uppercase letters
trim()	Removes whitespace from both ends of a string
valueOf()	Returns the primitive value of a String object

All string methods return a new value. They do not change the original
variable.

Шаблонные строки

Базовые шаблонные строки

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

Frontend developer

Кадровое агентство Алексея Сухорукова, Новосибирск, От 150 000 до 180 000 ₽

tproger.ru

Вакансии на tproger.ru

Вместо двойных или одинарных кавычек заключите строку в обратные кавычки и вставьте переменные, используя синтаксис ${variableName}

До

После

Вы также можете включать выражения в шаблонные строки:

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

Chrome: 41+

Edge: 13+

Firefox: 34+

Safari: 9.1+

Opera: 29+

JavaScript

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

Описание

Этот метод не изменяет объект , на котором он вызывается. Он просто возвращает новую строку.

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

строка замены может включать следующие специальные шаблоны замены:

Шаблон	Замена
	Вставляет символ доллара «$».
	Вставляет сопоставившуюся подстроку.
	Вставляет часть строки, предшествующую сопоставившейся подстроке.
	Вставляет часть строки, следующую за сопоставившейся подстрокой.
или	Символы или являются десятичными цифрами, вставляет n-ную сопоставившуюся подгруппу из объекта в первом параметре.

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

Результат вызова функции (её возвращаемое значение) будет использоваться в качестве строки замены (обратите внимание: описанные выше специальные шаблоны замены в этом случае не применяются). Обратите внимание, что функция будет вызвана несколько раз для каждого полного сопоставления, если регулярное выражение в первом параметре является глобальным

Функция принимает следующие аргументы:

Возможное имя	Получаемое значение
	Сопоставившаяся подстрока (соответствует шаблону замены , описанному выше).
	n-ная сопоставившаяся подгруппа из объекта в первом параметре метода (соответствует шаблонам замены , и так далее, описанным выше). Например, если в качестве шаблона передано регулярное выражение , параметр будет значение сопоставления с подгруппой , а параметр  — с подгруппой .
	Смещение сопоставившейся подстроки внутри всей рассматриваемой строки (например, если вся строка равна , а сопоставившаяся подстрока равна , то этот аргумент будет равен 1).
	Вся рассматриваемая строка.

Точное число аргументов будет зависеть от того, был ли первым аргументом объект и, если был, сколько подгрупп в нём определено.

Следующий пример установит переменную в значение :

JS Уроки

JS HOMEJS IntroductionJS Where ToJS OutputJS StatementsJS SyntaxJS CommentsJS VariablesJS OperatorsJS ArithmeticJS AssignmentJS Data TypesJS FunctionsJS ObjectsJS ScopeJS EventsJS StringsJS String MethodsJS NumbersJS Number MethodsJS ArraysJS Array MethodsJS Array SortJS Array IterationJS DatesJS Date FormatsJS Date Get MethodsJS Date Set MethodsJS MathJS RandomJS BooleansJS ComparisonsJS ConditionsJS SwitchJS Loop ForJS Loop WhileJS BreakJS Type ConversionJS BitwiseJS RegExpJS ErrorsJS DebuggingJS HoistingJS Strict ModeJS this KeywordJS Style GuideJS Best PracticesJS MistakesJS PerformanceJS Reserved WordsJS VersionsJS Version ES5JS Version ES6JS JSON

Найти все / Заменить все

Эти две задачи решаются в javascript принципиально по-разному.

Начнём с «простого».

Для замены всех вхождений используется метод String#replace.
Он интересен тем, что допускает первый аргумент – регэксп или строку.

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

Попробуйте:

Как видите, заменился только один плюс, а не оба.

Чтобы заменить все вхождения, String#replace обязательно нужно использовать с регулярным выражением.

В режиме регулярного выражения плюс придётся экранировать, но зато заменит все вхождения (при указании флага ):

Вот такая особенность работы со строкой.

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

Следующий пример произведёт операции вычитания:

В javascript нет одного универсального метода для поиска всех совпадений.
Для поиска без запоминания скобочных групп – можно использовать String#match:

Как видите, оно исправно ищет все совпадения (флаг у регулярного выражения обязателен), но при этом не запоминает скобочные группы. Эдакий «облегчённый вариант».

В сколько-нибудь сложных задачах важны не только совпадения, но и скобочные группы. Чтобы их найти, предлагается использовать многократный вызов RegExp#exec.

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

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

Native JavaScript Methods

imports all of the native JavaScript methods. This is for convenience. The only difference is that the imported methods return objects instead of native JavaScript strings. The one exception to this is the method . This is because only returns a string of length one. This is typically done for comparisons and a object will have little to no value here.

All of the native methods support chaining with the methods.

Example:

var S = require('string');

var phrase = S('JavaScript is the best scripting language ever!');
var sub = 'best scripting';
var pos = phrase.indexOf(sub);
console.log(phrase.substr(pos, sub.length).truncate(8)); //best...

License

Licensed under MIT.

Copyright (C) 2012-2016 JP Richardson jprichardson@gmail.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the «Software»), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED «AS IS», WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Разбиение строк

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

constoriginalString = "How are you?";

// Разбиваемстрокупопробелу
const splitString = originalString.split(" ");

console.log(splitString);

Вывод

Теперь, когда у нас есть новый массив в переменной splitString, можно получить доступ к каждой его части по индексу.

splitString;

Вывод

are

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

Нюансы сравнения строк

Если мы
проверяем строки на равенство, то никаких особых проблем в JavaScript это не
вызывает, например:

if("abc" == "abc") console.log( "строки равны" );
if("abc" != "ABC") console.log( "строки не равны" );

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

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

console.log( "z" > "Za" );        //true

2. Если код
текущего символа одной строки меньше кода текущего символа другой строки, то
первая строка меньше второй:

console.log( "B" < "a" );    //true

3. При равенстве
символов больше та строка, которая содержит больше символов:

console.log( "abc" < "abcd" ); //true

4. В остальных
случаях строки равны:

console.log( "abc" == "abc" ); //true

Но в этом
алгоритме есть один нюанс. Например, вот такое сравнение:

console.log( "Америка" > "Japan" );    //true

Дает значение true, так как
русская буква A имеет больший
код, чем латинская буква J. В этом легко убедиться,
воспользовавшись методом

str.codePointAt(pos)

который
возвращает код символа, стоящего в позиции pos:

console.log( "А".codePointAt(), "J".codePointAt() );

Сморите, у буквы
А код равен 1040, а у буквы J – 74. Напомню,
что строки в JavaScript хранятся в
кодировке UTF-16. К чему
может привести такой результат сравнения? Например, при сортировке мы получим
на первом месте страну «Japan», а потом «Америка». Возможно, это не
то, что нам бы хотелось? И здесь на помощь приходит специальный метод для
корректного сравнения таких строк:

str.localeCompare(compareStr)

он возвращает
отрицательное число, если str < compareStr, положительное
при str > compareStr и 0 если строки
равны. Например:

console.log( "Америка".localeCompare("Japan") );      // -1

возвращает -1
как и должно быть с учетом языкового сравнения. У этого метода есть два
дополнительных аргумента, которые указаны в документации JavaScript. Первый
позволяет указать язык (по умолчанию берётся из окружения) — от него зависит
порядок букв. Второй позволяет определять дополнительные правила, например, чувствительность
к регистру.

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

Равенство

Как вы знаете, что сравнивая два строковых примитива, вы можете использовать операторы == или ===:

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

При использовании оператора == не-строка будет преобразована в строку. Это означает, что JavaScript попытается преобразовать его в строку перед сравнением значений.

Для строгого сравнения, когда не-строки не приводятся к строкам, используйте ===:

То же самое верно и для операторов неравенства !=  и !==:

Если вы не знаете, что использовать, отдавайте предпочтение строгому равенству ===.

Чувствительность к регистру

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

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

Работа с диакритическими знаками в строках JavaScript

Диакритические знаки — это модификации буквы, например é или ž.

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

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

Если вам нужно сравнение без учета регистра, простое преобразование двух строк в один и тот же регистр с помощью toUpperCase() или toLowerCase() не будет учитывать добавление / удаление акцентов и может не дать ожидаемого результата.

Если вам нужен более точный контроль над сравнением, используйте вместо него localeCompare:

Метод localeCompare позволяет указать «sensitivity» сравнения.

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

Поддержка localeCompare() браузерами:

Chrome: 24+

Edge: 12+

Firefox: 29+

Safari: 10+

Opera: 15+

Больше / меньше

При сравнении строк с использованием операторов < и > JavaScript будет сравнивать каждый символ в «лексикографическом порядке».

Это означает, что они сравниваются по буквам в том порядке, в котором они появляются в словаре:

True или false строки

Пустые строки в JavaScript считаются равными false при сравнении с использованием оператора == (но не при использовании ===)

Строки со значением являются «истинными», поэтому вы можете делать нечто подобное:

Экранирующий символ

Поскольку строки должны быть записаны в кавычках, JavaScript будет неправильно понимать эту строку:

var x = «Мы так называемые «Викинги» из севера.»;

Строка будет разделена на фразе «Мы так называемые «.

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

Экранирующий символ обратной косой черты () превращает специальные символы в строковые символы:

Код	Результат	Описание
\’	‘	Одинарные кавычки
\»	«	Двойные кавычки
\\	\	Обратный слэш

Последовательность   вставляет двойную кавычку в строку:

Пример

var x = «Мы так называемые \»Викинги\» из севера.»;

Последовательность   вставляет одинарную кавычку в строку:

Пример

var x = ‘Это\’ правильно.’;

Последовательность   вставляет обратный слэш в строку:

Пример

var x = «Символ \\ называется обратной косой чертой (обратным слэшем).»;

Шесть других экранирующих последовательностей, валидных в JavaScript:

Код	Результат
\b	Backspace (возврат на одну позицию)
\f	Подача формы
\n	Новая линия (новая строка)
\r	Возврат каретки
\t	Горизонтальный табулятор
\v	Вертикальный табулятор

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

Конкатенация

Конкатенация — это объединение двух или более строк в одну большую. Объединение происходит с помощью оператора + (плюс). При конкатенации каждая последующая строка добавляется в конец предыдущей:

var str1 = "Hello ";
var str2 = "World!";

document.write(str1 + str2 + "<br>"); // "Hello World!"
document.write(str1 + "World!");

Попробовать »

Значение любого типа, которое объединяется со строкой, будет неявно (автоматически) преобразовано в строку и далее будет произведена конкатенация.

var str1 = "Hello ";

alert(str1 + 1);     // "Hello 1"
alert(true + str1);  // "trueHello"
alert(str1 + NaN);   // "Hello NaN"

Попробовать »

С этой темой смотрят:

• Типы данных
• Числа
• Infinity и NaN
• Boolean
• Преобразование типов данных

str.replace(str|regexp, str|func)

Это универсальный метод поиска-и-замены, один из самых полезных. Этакий швейцарский армейский нож для поиска и замены в строке.

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

Хотя есть подводный камень.

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

Вы можете видеть это в приведённом выше примере: только первый заменяется на .

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

Второй аргумент – строка замены. Мы можем использовать специальные символы в нем:

Спецсимволы	Действие в строке замены
	вставляет
	вставляет всё найденное совпадение
	вставляет часть строки до совпадения
	вставляет часть строки после совпадения
	если это 1-2 значное число, то вставляет содержимое n-й скобки
	вставляет содержимое скобки с указанным именем

Например:

Для ситуаций, которые требуют «умных» замен, вторым аргументом может быть функция.

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

Функция вызывается с аргументами :

1. – найденное совпадение,
2. – содержимое скобок (см. главу Скобочные группы).
3. – позиция, на которой найдено совпадение,
4. – исходная строка,
5. – объект с содержимым именованных скобок (см. главу Скобочные группы).

Если скобок в регулярном выражении нет, то будет только 3 аргумента: .

Например, переведём выбранные совпадения в верхний регистр:

Заменим каждое совпадение на его позицию в строке:

В примере ниже две скобки, поэтому функция замены вызывается с 5-ю аргументами: первый – всё совпадение, затем два аргумента содержимое скобок, затем (в примере не используются) индекс совпадения и исходная строка:

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

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

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

Строки могут быть объектами

Обычно строки JavaScript представляют собой примитивные значения, созданные из литералов:

Но строки также могут быть определены как объекты с ключевым словом :

Пример

var x = «Щипунов»;
var y = new String(«Щипунов»);
// typeof x вернет строку// typeof y вернет объект

Не создавайте строки как объекты. Это замедляет скорость выполнения.
Ключевое слово усложняет код. Это может привести к неожиданным результатам:

При использовании оператора равные строки равны:

Пример

var x = «Щипунов»;             
var y = new String(«Щипунов»);
// (x == y) true, потому что x и y имеют равные значения

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

Пример

var x = «Щипунов»;             
var y = new String(«Щипунов»);
// (x === y) false, потому что x и y имеют разные типы (string и object)

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

Пример

var x = new String(«Щипунов»);             
var y = new String(«Щипунов»);
// (x == y) false, потому что x и y — разные объекты

Пример

var x = new String(«Щипунов»);             
var y = new String(«Щипунов»);
// (x === y) false, потому что x и y — разные объекты

Обратите внимание на разницу между и .
Сравнение двух объектов JavaScript всегда возвращает