jeena/en.javascript.info
1
0
Fork 0
Code Issues Pull requests Projects Packages Wiki Activity Actions

edit

Browse source
This commit is contained in:
Ilya Kantor 2016-03-04 19:06:22 +03:00
parent e78e527866
commit 05a93ced80
212 changed files with 3213 additions and 3968 deletions
Download patch file Download diff file Expand all files Collapse all files

3
1-js/4-data-structures/3-string/1-ucfirst/solution.md
View file

@ -12,8 +12,7 @@ var newStr = str[0].toUpperCase() + str.slice(1);
Выхода два. Первый -- использовать `str.charAt(0)`, он всегда возвращает строку, для пустой строки -- пустую, но не `undefined`. Второй -- отдельно проверить на пустую строку, вот так:
```js
//+ run
```js run
function ucFirst(str) {
// только пустая строка в логическом контексте даст false
if (!str) return str;

6
1-js/4-data-structures/3-string/1-ucfirst/task.md
View file

@ -1,6 +1,8 @@
# Сделать первый символ заглавным
importance: 5
[importance 5]
---
# Сделать первый символ заглавным
Напишите функцию `ucFirst(str)`, которая возвращает строку `str` с заглавным первым символом, например:

3
1-js/4-data-structures/3-string/2-check-spam/solution.md
View file

@ -2,8 +2,7 @@
Для проверки приведем к нижнему регистру и строку `str` а затем уже будем искать.
```js
//+ run
```js run
function checkSpam(str) {
var lowerStr = str.toLowerCase();

6
1-js/4-data-structures/3-string/2-check-spam/task.md
View file

@ -1,6 +1,8 @@
# Проверьте спам
importance: 5
[importance 5]
---
# Проверьте спам
Напишите функцию `checkSpam(str)`, которая возвращает `true`, если строка `str` содержит 'viagra' or 'XXX', а иначе `false`.

6
1-js/4-data-structures/3-string/3-truncate/solution.md
View file

@ -1,7 +1,6 @@
Так как окончательная длина строки должна быть `maxlength`, то нужно её обрезать немного короче, чтобы дать место для троеточия.
```js
//+ run
```js run
function truncate(str, maxlength) {
if (str.length > maxlength) {
return str.slice(0, maxlength - 3) + '...';
@ -17,8 +16,7 @@ alert( truncate("Всем привет!", 20) );
Можно было бы написать этот код ещё короче:
```js
//+ run
```js run
function truncate(str, maxlength) {
return (str.length > maxlength) ?
str.slice(0, maxlength - 3) + '...' : str;

6
1-js/4-data-structures/3-string/3-truncate/task.md
View file

@ -1,6 +1,8 @@
# Усечение строки
importance: 5
[importance 5]
---
# Усечение строки
Создайте функцию `truncate(str, maxlength)`, которая проверяет длину строки `str`, и если она превосходит `maxlength` -- заменяет конец `str` на `"..."`, так чтобы ее длина стала равна `maxlength`.

6
1-js/4-data-structures/3-string/4-extract-currency/task.md
View file

@ -1,6 +1,8 @@
# Выделить число
importance: 4
[importance 4]
---
# Выделить число
Есть стоимость в виде строки: `"$120"`. То есть, первым идёт знак валюты, а затем -- число.

322
1-js/4-data-structures/3-string/article.md
View file

@ -3,8 +3,10 @@
В JavaScript любые текстовые данные являются строками. Не существует отдельного типа "символ", который есть в ряде других языков.
Внутренним форматом строк, вне зависимости от кодировки страницы, является [Юникод (Unicode)](http://ru.wikipedia.org/wiki/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4).
[cut]
## Создание строк
## Создание строк
Строки создаются при помощи двойных или одинарных кавычек:
@ -16,7 +18,7 @@ var anotherText = 'еще строка';
var str = "012345";
```
В JavaScript нет разницы между двойными и одинарными кавычками.
В JavaScript нет разницы между двойными и одинарными кавычками.
### Специальные символы
@ -24,8 +26,7 @@ var str = "012345";
Он обозначается как `\n`, например:
```js
//+ run
```js run
alert( 'Привет\nМир' ); // выведет "Мир" на новой строке
```
@ -57,8 +58,7 @@ var str = '*!*I\'m*/!* a JavaScript programmer';
В двойных кавычках -- экранируются внутренние двойные:
```js
//+ run
```js run
var str = "I'm a JavaScript \"programmer\" ";
alert( str ); // I'm a JavaScript "programmer"
```
@ -67,8 +67,7 @@ alert( str ); // I'm a JavaScript "programmer"
Сам символ обратного слэша `'\'` является служебным, поэтому всегда экранируется, т.е пишется как `\\`:
```js
//+ run
```js run
var str = ' символ \\ ';
alert( str ); // символ \
@ -76,34 +75,30 @@ alert( str ); // символ \
Заэкранировать можно любой символ. Если он не специальный, то ничего не произойдёт:
```js
//+ run
```js run
alert( "\a" ); // a
// идентично alert( "a" );
```
## Методы и свойства
Здесь мы рассмотрим методы и свойства строк, с некоторыми из которых мы знакомились ранее, в главе [](/properties-and-methods).
## Методы и свойства
Здесь мы рассмотрим методы и свойства строк, с некоторыми из которых мы знакомились ранее, в главе <info:properties-and-methods>.
### Длина length
Одно из самых частых действий со строкой -- это получение ее длины:
```js
//+ run
```js run
var str = "My\n"; // 3 символа. Третий - перевод строки
alert( str.length ); // 3
```
### Доступ к символам
### Доступ к символам
Чтобы получить символ, используйте вызов `charAt(позиция)`. Первый символ имеет позицию `0`:
```js
//+ run
```js run
var str = "jQuery";
alert( str.charAt(0) ); // "j"
```
@ -112,39 +107,33 @@ alert( str.charAt(0) ); // "j"
Также для доступа к символу можно также использовать квадратные скобки:
```js
//+ run
```js run
var str = "Я - современный браузер!";
alert( str[0] ); // "Я"
```
Разница между этим способом и `charAt` заключается в том, что если символа нет -- `charAt` выдает пустую строку, а скобки -- `undefined`:
```js
//+ run
```js run
alert( "".charAt(0) ); // пустая строка
alert( "" [0] ); // undefined
```
Вообще же метод `charAt` существует по историческим причинам, ведь квадратные скобки -- проще и короче.
[warn header="Вызов метода -- всегда со скобками"]
```warn header="Вызов метода -- всегда со скобками"
Обратите внимание, `str.length` -- это *свойство* строки, а `str.charAt(pos)` -- *метод*, т.е. функция.
Обращение к методу всегда идет со скобками, а к свойству -- без скобок.
Обращение к методу всегда идет со скобками, а к свойству -- без скобок.
```
[/warn]
### Изменения строк
### Изменения строк
Содержимое строки в JavaScript нельзя изменять. Нельзя взять символ посередине и заменить его. Как только строка создана -- она такая навсегда.
Можно лишь создать целиком новую строку и присвоить в переменную вместо старой, например:
```js
//+ run
```js run
var str = "строка";
str = str[3] + str[4] + str[5];
@ -152,12 +141,11 @@ str = str[3] + str[4] + str[5];
alert( str ); // ока
```
### Смена регистра
### Смена регистра
Методы `toLowerCase()` и `toUpperCase()` меняют регистр строки на нижний/верхний:
```js
//+ run
```js run
alert( "Интерфейс".toUpperCase() ); // ИНТЕРФЕЙС
```
@ -169,12 +157,11 @@ alert( "Интерфейс" [0].toLowerCase() ); // 'и'
### Поиск подстроки
Для поиска подстроки есть метод <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/indexOf">indexOf(подстрока[, начальная_позиция])</a>.
Для поиска подстроки есть метод <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/indexOf">indexOf(подстрока[, начальная_позиция])</a>.
Он возвращает позицию, на которой находится `подстрока` или `-1`, если ничего не найдено. Например:
```js
//+ run
```js run
var str = "Widget with id";
alert( str.indexOf("Widget") ); // 0, т.к. "Widget" найден прямо в начале str
@ -184,8 +171,7 @@ alert( str.indexOf("widget") ); // -1, не найдено, так как пои
Необязательный второй аргумент позволяет искать, начиная с указанной позиции. Например, первый раз `"id"` появляется на позиции `1`. Чтобы найти его следующее появление -- запустим поиск с позиции `2`:
```js
//+ run
```js run
var str = "Widget with id";
alert(str.indexOf("id", 2)) // 12, поиск начат с позиции 2
@ -193,13 +179,12 @@ alert(str.indexOf("id", 2)) // 12, поиск начат с позиции 2
Также существует аналогичный метод <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/String/lastIndexOf">lastIndexOf</a>, который ищет не с начала, а с конца строки.
[smart]
Для красивого вызова `indexOf` применяется побитовый оператор НЕ `'~'`.
````smart
Для красивого вызова `indexOf` применяется побитовый оператор НЕ `'~'`.
Дело в том, что вызов `~n` эквивалентен выражению `-(n+1)`, например:
```js
//+ run
```js run
alert( ~2 ); // -(2+1) = -3
alert( ~1 ); // -(1+1) = -2
alert( ~0 ); // -(0+1) = -1
@ -208,14 +193,13 @@ alert( ~-1 ); // -(-1+1) = 0
*/!*
```
Как видно, `~n` -- ноль только в случае, когда `n == -1`.
Как видно, `~n` -- ноль только в случае, когда `n == -1`.
То есть, проверка `if ( ~str.indexOf(...) )` означает, что результат `indexOf` отличен от `-1`, т.е. совпадение есть.
Вот так:
```js
//+ run
```js run
var str = "Widget";
if (~str.indexOf("get")) {
@ -223,12 +207,10 @@ if (~str.indexOf("get")) {
}
```
Вообще, использовать возможности языка неочевидным образом не рекомендуется, поскольку ухудшает читаемость кода.
Вообще, использовать возможности языка неочевидным образом не рекомендуется, поскольку ухудшает читаемость кода.
Однако, в данном случае, все в порядке. Просто запомните: `'~'` читается как "не минус один", а `"if ~str.indexOf"` читается как `"если найдено"`.
[/smart]
````
### Поиск всех вхождений
@ -236,9 +218,8 @@ if (~str.indexOf("get")) {
Пример такого цикла:
```js
//+ run
var str = "Ослик Иа-Иа посмотрел на виадук"; // ищем в этой строке
```js run
var str = "Ослик Иа-Иа посмотрел на виадук"; // ищем в этой строке
var target = "Иа"; // цель поиска
var pos = 0;
@ -255,9 +236,8 @@ while (true) {
Впрочем, тот же алгоритм можно записать и короче:
```js
//+ run
var str = "Ослик Иа-Иа посмотрел на виадук"; // ищем в этой строке
```js run
var str = "Ослик Иа-Иа посмотрел на виадук"; // ищем в этой строке
var target = "Иа"; // цель поиска
*!*
@ -268,115 +248,91 @@ while ((pos = str.indexOf(target, pos + 1)) != -1) {
*/!*
```
### Взятие подстроки: substr, substring, slice.
### Взятие подстроки: substr, substring, slice.
В JavaScript существуют целых 3 (!) метода для взятия подстроки, с небольшими отличиями между ними.
<dl>
<dt>`substring(start [, end])`
<dd>
Метод `substring(start, end)` возвращает подстроку с позиции `start` до, но не включая `end`.
`substring(start [, end])`
: Метод `substring(start, end)` возвращает подстроку с позиции `start` до, но не включая `end`.
```js
//+ run
var str = "*!*s*/!*tringify";
alert(str.substring(0,1)); // "s", символы с позиции 0 по 1 не включая 1.
```
```js run
var str = "*!*s*/!*tringify";
alert(str.substring(0,1)); // "s", символы с позиции 0 по 1 не включая 1.
```
Если аргумент `end` отсутствует, то идет до конца строки:
Если аргумент `end` отсутствует, то идет до конца строки:
```js
//+ run
var str = "st*!*ringify*/!*";
alert(str.substring(2)); // ringify, символы с позиции 2 до конца
```
```js run
var str = "st*!*ringify*/!*";
alert(str.substring(2)); // ringify, символы с позиции 2 до конца
```
</dd>
<dt>`substr(start [, length])`</dt>
<dd>Первый аргумент имеет такой же смысл, как и в `substring`, а второй содержит не конечную позицию, а количество символов.
<dt>`substr(start [, length])`
: Первый аргумент имеет такой же смысл, как и в `substring`, а второй содержит не конечную позицию, а количество символов.
```js
//+ run
var str = "st*!*ring*/!*ify";
str = str.substr(2,4); // ring, со 2й позиции 4 символа
alert(str)
```
```js run
var str = "st*!*ring*/!*ify";
str = str.substr(2,4); // ring, со 2й позиции 4 символа
alert(str)
```
Если второго аргумента нет -- подразумевается "до конца строки".</dd>
<dt>`slice(start [, end])`</dt>
<dd>Возвращает часть строки от позиции `start` до, но не включая, позиции `end`. Смысл параметров -- такой же как в `substring`.</dd>
</dl>
Если второго аргумента нет -- подразумевается "до конца строки".
`slice(start [, end])`
: Возвращает часть строки от позиции `start` до, но не включая, позиции `end`. Смысл параметров -- такой же как в `substring`.
### Отрицательные аргументы
Различие между `substring` и `slice` -- в том, как они работают с отрицательными и выходящими за границу строки аргументами:
<dl>
<dt>`substring(start, end)`</dt>
<dd>Отрицательные аргументы интерпретируются как равные нулю. Слишком большие значения усекаются до длины строки:
`substring(start, end)`
: Отрицательные аргументы интерпретируются как равные нулю. Слишком большие значения усекаются до длины строки:
```js
//+ run
alert( "testme".substring(-2) ); // "testme", -2 становится 0
```
```js run
alert( "testme".substring(-2) ); // "testme", -2 становится 0
```
Кроме того, если <code>start &gt; end</code>, то аргументы меняются местами, т.е. возвращается участок строки *между* `start` и `end`:
Кроме того, если <code>start &gt; end</code>, то аргументы меняются местами, т.е. возвращается участок строки *между* `start` и `end`:
```js
//+ run
alert( "testme".substring(4, -1) ); // "test"
// -1 становится 0 -> получили substring(4, 0)
// 4 > 0, так что аргументы меняются местами -> substring(0, 4) = "test"
```
```js run
alert( "testme".substring(4, -1) ); // "test"
// -1 становится 0 -> получили substring(4, 0)
// 4 > 0, так что аргументы меняются местами -> substring(0, 4) = "test"
```
</dd>
<dt>`slice`</dt>
<dd>Отрицательные значения отсчитываются от конца строки:
`slice`
: Отрицательные значения отсчитываются от конца строки:
```js
//+ run
alert( "testme".slice(-2) ); // "me", от 2 позиции с конца
```
```js run
alert( "testme".slice(-2) ); // "me", от 2 позиции с конца
```
```js run
alert( "testme".slice(1, -1) ); // "estm", от 1 позиции до первой с конца.
```
```js
//+ run
alert( "testme".slice(1, -1) ); // "estm", от 1 позиции до первой с конца.
```
Это гораздо более удобно, чем странная логика `substring`.
</dd>
</dl>
Это гораздо более удобно, чем странная логика `substring`.
Отрицательное значение первого параметра поддерживается в `substr` во всех браузерах, кроме IE8-.
Если выбирать из этих трёх методов один, для использования в большинстве ситуаций -- то это будет `slice`: он и отрицательные аргументы поддерживает и работает наиболее очевидно.
Если выбирать из этих трёх методов один, для использования в большинстве ситуаций -- то это будет `slice`: он и отрицательные аргументы поддерживает и работает наиболее очевидно.
## Кодировка Юникод
Как мы знаем, символы сравниваются в алфавитном порядке `'А' < 'Б' < 'В' < ... < 'Я'`.
Как мы знаем, символы сравниваются в алфавитном порядке `'А' < 'Б' < 'В' < ... < 'Я'`.
Но есть несколько странностей..
<ol>
<li>Почему буква `'а'` маленькая больше буквы `'Я'` большой?
1. Почему буква `'а'` маленькая больше буквы `'Я'` большой?
```js
//+ run
alert( 'а' > 'Я' ); // true
```
```js run
alert( 'а' > 'Я' ); // true
```
2. Буква `'ё'` находится в алфавите между `е` и `ж`: <code>абвгде**ё**жз..</code>. Но почему тогда `'ё'` больше `'я'`?
</li><li>
Буква `'ё'` находится в алфавите между `е` и `ж`: <code>абвгде**ё**жз..</code>. Но почему тогда `'ё'` больше `'я'`?
```js
//+ run
alert( 'ё' > 'я' ); // true
```
</li>
</ol>
```js run
alert( 'ё' > 'я' ); // true
```
Чтобы разобраться с этим, обратимся к внутреннему представлению строк в JavaScript.
@ -385,31 +341,22 @@ alert( 'ё' > 'я' ); // true
Неважно, на каком языке написана страница, находится ли она в windows-1251 или utf-8. Внутри JavaScript-интерпретатора все строки приводятся к единому "юникодному" виду. Каждому символу соответствует свой код.
Есть метод для получения символа по его коду:
<dl>
<dt>String.fromCharCode(code)</dt>
<dd>Возвращает символ по коду `code`:
```js
//+ run
alert( String.fromCharCode(1072) ); // 'а'
```
String.fromCharCode(code)
: Возвращает символ по коду `code`:
</dd>
</dl>
```js run
alert( String.fromCharCode(1072) ); // 'а'
```
...И метод для получения цифрового кода из символа:
<dl>
<dt>str.charCodeAt(pos)</dt>
<dd>Возвращает код символа на позиции `pos`. Отсчет позиции начинается с нуля.
str.charCodeAt(pos)
: Возвращает код символа на позиции `pos`. Отсчет позиции начинается с нуля.
```js
//+ run
alert( "абрикос".charCodeAt(0) ); // 1072, код 'а'
```
</dd>
</dl>
```js run
alert( "абрикос".charCodeAt(0) ); // 1072, код 'а'
```
Теперь вернемся к примерам выше. Почему сравнения `'ё' > 'я'` и `'а' > 'Я'` дают такой странный результат?
@ -417,8 +364,7 @@ alert( "абрикос".charCodeAt(0) ); // 1072, код 'а'
Выведем отрезок символов юникода с кодами от `1034` до `1113`:
```js
//+ run
```js run
var str = '';
for (var i = 1034; i <= 1113; i++) {
str += String.fromCharCode(i);
@ -433,51 +379,44 @@ alert( str );
Мы можем увидеть из этого отрезка две важных вещи:
<ol>
<li>**Строчные буквы идут после заглавных, поэтому они всегда больше.**
1. **Строчные буквы идут после заглавных, поэтому они всегда больше.**
В частности, `'а'(код 1072) > 'Я'(код 1071)`.
В частности, `'а'(код 1072) > 'Я'(код 1071)`.
То же самое происходит и в английском алфавите, там `'a' > 'Z'`.
</li>
<li>**Ряд букв, например `ё`, находятся вне основного алфавита.**
То же самое происходит и в английском алфавите, там `'a' > 'Z'`.
2. **Ряд букв, например `ё`, находятся вне основного алфавита.**
В частности, маленькая буква `ё` имеет код, больший чем `я`, поэтому **`'ё'(код 1105) > 'я'(код 1103)`**.
В частности, маленькая буква `ё` имеет код, больший чем `я`, поэтому **`'ё'(код 1105) > 'я'(код 1103)`**.
Кстати, большая буква `Ё` располагается в Unicode до `А`, поэтому **`'Ё'`(код 1025) < `'А'`(код 1040)**. Удивительно: есть буква меньше чем `А` :)
</li>
</ol>
Кстати, большая буква `Ё` располагается в Unicode до `А`, поэтому **`'Ё'`(код 1025) < `'А'`(код 1040)**. Удивительно: есть буква меньше чем `А` :)
**Буква `ё` не уникальна, точки над буквой используются и в других языках, приводя к тому же результату.**
Например, при работе с немецкими названиями:
```js
//+ run
```js run
alert( "ö" > "z" ); // true
```
[smart header="Юникод в HTML"]
Кстати, если мы знаем код символа в кодировке юникод, то можем добавить его в HTML, используя "числовую ссылку" (numeric character reference).
```smart header="Юникод в HTML"
Кстати, если мы знаем код символа в кодировке юникод, то можем добавить его в HTML, используя "числовую ссылку" (numeric character reference).
Для этого нужно написать сначала `&#`, затем код, и завершить точкой с запятой `';'`. Например, символ `'а'` в виде числовой ссылки: `&#1072;`.
Если код хотят дать в 16-ричной системе счисления, то начинают с `&#x`.
В юникоде есть много забавных и полезных символов, например, символ ножниц: &#x2702; (`&#x2702;`), дроби: &#xBD; (`&#xBD;`) &#xBE; (`&#xBE;`) и другие. Их можно использовать вместо картинок в дизайне.
[/smart]
```
## Посимвольное сравнение
Сравнение строк работает *лексикографически*, иначе говоря, посимвольно.
Сравнение строк работает *лексикографически*, иначе говоря, посимвольно.
Сравнение строк `s1` и `s2` обрабатывается по следующему алгоритму:
<ol><li>Сравниваются первые символы: `s1[0]` и `s2[0]`. Если они разные, то сравниваем их и, в зависимости от результата их сравнения, возвратить `true` или `false`. Если же они одинаковые, то...</li>
<li>Сравниваются вторые символы `s1[1]` и `s2[1]`</li>
<li>Затем третьи `s1[2]` и `s2[2]` и так далее, пока символы не будут наконец разными, и тогда какой символ больше -- та строка и больше. Если же в какой-либо строке закончились символы, то считаем, что она меньше, а если закончились в обеих -- они равны.</li>
</ol>
1. Сравниваются первые символы: `s1[0]` и `s2[0]`. Если они разные, то сравниваем их и, в зависимости от результата их сравнения, возвратить `true` или `false`. Если же они одинаковые, то...
2. Сравниваются вторые символы `s1[1]` и `s2[1]`
3. Затем третьи `s1[2]` и `s2[2]` и так далее, пока символы не будут наконец разными, и тогда какой символ больше -- та строка и больше. Если же в какой-либо строке закончились символы, то считаем, что она меньше, а если закончились в обеих -- они равны.
Спецификация языка определяет этот алгоритм более детально. Если же говорить простыми словами, смысл алгоритма в точности соответствует порядку, по которому имена заносятся в орфографический словарь.
@ -486,23 +425,19 @@ alert( "ö" > "z" ); // true
"Дома" > "До" // true, т.к. начало совпадает, но в 1й строке больше символов
```
[warn header="Числа в виде строк сравниваются как строки"]
````warn header="Числа в виде строк сравниваются как строки"
Бывает, что числа приходят в скрипт в виде строк, например как результат `prompt`. В этом случае результат их сравнения будет неверным:
```js
//+ run
```js run
alert( "2" > "14" ); // true, так как это строки, и для первых символов верно "2" > "1"
```
Если хотя бы один аргумент -- не строка, то другой будет преобразован к числу:
```js
//+ run
```js run
alert( 2 > "14" ); // false
```
[/warn]
````
## Правильное сравнение
@ -510,8 +445,7 @@ alert( 2 > "14" ); // false
Способ использования:
```js
//+ run
```js run
var str = "Ёлки";
alert( str.localeCompare("Яблони") ); // -1
@ -519,16 +453,14 @@ alert( str.localeCompare("Яблони") ); // -1
Метод `str1.localeCompare(str2)` возвращает `-1`, если `str1 < str2`, `1`, если `str1 > str2` и `0`, если они равны.
Более подробно про устройство этого метода можно будет узнать в статье [](/intl), когда это вам понадобится.
Более подробно про устройство этого метода можно будет узнать в статье <info:intl>, когда это вам понадобится.
## Итого
<ul>
<li>Строки в JavaScript имеют внутреннюю кодировку Юникод. При написании строки можно использовать специальные символы, например `\n` и вставлять юникодные символы по коду.</li>
<li>Мы познакомились со свойством `length` и методами `charAt`, `toLowerCase/toUpperCase`, `substring/substr/slice` (предпочтителен `slice`). Есть и другие методы, например [trim](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim) обрезает пробелы с начала и конца строки.</li>
<li>Строки сравниваются побуквенно. Поэтому если число получено в виде строки, то такие числа могут сравниваться некорректно, нужно преобразовать его к типу *number*.</li>
<li>При сравнении строк следует иметь в виду, что буквы сравниваются по их кодам. Поэтому большая буква меньше маленькой, а буква `ё` вообще вне основного алфавита.</li>
<li>Для правильного сравнения существует целый стандарт ECMA 402. Это не такое простое дело, много языков и много правил. Он поддерживается во всех современных браузерах, кроме IE10-, в которых нужна библиотека [](https://github.com/andyearnshaw/Intl.js/). Такое сравнение работает через вызов `str1.localeCompare(str2)`.</li>
</ul>
- Строки в JavaScript имеют внутреннюю кодировку Юникод. При написании строки можно использовать специальные символы, например `\n` и вставлять юникодные символы по коду.
- Мы познакомились со свойством `length` и методами `charAt`, `toLowerCase/toUpperCase`, `substring/substr/slice` (предпочтителен `slice`). Есть и другие методы, например [trim](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim) обрезает пробелы с начала и конца строки.
- Строки сравниваются побуквенно. Поэтому если число получено в виде строки, то такие числа могут сравниваться некорректно, нужно преобразовать его к типу *number*.
- При сравнении строк следует иметь в виду, что буквы сравниваются по их кодам. Поэтому большая буква меньше маленькой, а буква `ё` вообще вне основного алфавита.
- Для правильного сравнения существует целый стандарт ECMA 402. Это не такое простое дело, много языков и много правил. Он поддерживается во всех современных браузерах, кроме IE10-, в которых нужна библиотека <https://github.com/andyearnshaw/Intl.js/>. Такое сравнение работает через вызов `str1.localeCompare(str2)`.
Больше информации о методах для строк можно получить в справочнике: [http://javascript.ru/String]().
Больше информации о методах для строк можно получить в справочнике: <http://javascript.ru/String>.