Объявление строк

var s = "a";                // Объявление строк
var s = 'abc';              // Одинарные или двойные кавычки

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

"Миг" < "Мир"               // true
"Зим" < "Зима"              // true

Свойства строк

  • length

Содержит длину строки

var s = "abcd";
s.length;                   // 4

Функции работы со строками

  • [i]

Возвращает символ на позиции i (начинается с 0). Если символа нет, то выдает undefined

var s = "1,2,3";
s[4];                       // "3"
s[5];                       // undefined
  • charAt(i)

Возвращает символ на позиции i (начинается с 0). Если символа нет, то выдает пустую строку !

var s = "1,2,3";
s.charAt(4);                // "3"
s.charAt(5);                // ""
  • charCodeAt(pos)

Возвращает код символа на позиции pos. Отсчет начинается с 0.

var s = "abcdef";
s.charCodeAt(1);            // 98
  • concat([s1[, s2[, ...]]])

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

var s = "abc";
s = s.concat("de", "f");    // "abcdef"
  • fromCharCode(code)

Возвращает символ по коду code.

var s = "abcdef";
String.fromCharCode(98);    // "b"
  • indexOf(s, pos)

Поиск подстроки s, начиная с позиции pos (по-умолчанию 0). Отрицательные значения позиции трактуются как 0

var s = "abcdabcd";
s.indexOf("cd");            // 2
s.indexOf("cd", 3);         // 6
  • lastIndexOf(s, pos)

Поиск подстроки s с конца строки, с позиции pos (по-умолчанию +Infinity). Отрицательные значения позиции трактуются как 0

var s = "abcdabcd";
s.lastIndexOf("b");         // 5
s.lastIndexOf("b", 4);      // 1
  • localeCompare(s)

Сравнение строки с переданной строкой s с учетом правил языка. Если строка больше s, возвращается 1. Если строка меньше s, возвращается -1. Если строки равны, возвращается 0.

var s = "abc";
s.localeCompare("ab");      // 1
s.localeCompare("z");       // -1
s.localeCompare("abc");     // 0
"а".localeCompare("Я");     // -1
"ё".localeCompare("я");     // -1
  • match(reg)

Возвращает результат поиска в строке, используя переданное регулярное выражение. Если в регулярном выражении указан ключ i, то выполняется сравнение без учета регистра букв. Если указан ключ g, то возвращается массив из всех совпадений. Если ключ g не указан, то возвращается массив у которого элемент с индексом 0 будет содержать результат совпадения, элемент 'index' - индекс найденного совпадения в строке, а элемент 'input' - исходную строку.

var s = "a1b2c3";
s.match(/\d+/g);      // ['1', '2', '3']
s.match(/\d+/);       // ['1', index: 1, input: 'a1b2c3']
s.match(/B2/i);       // ['b2', index: 2, input: 'a1b2c3']
  • replace(reg, expr)

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

var s = "a1-b2-c3";
var r = s.replace(/\d/, "0");               // a0-b2-c3
var r = s.replace(/\d/g, "0");              // a0-b0-c0
var r = s.replace(/\d/g, "");               // a-b-c
var r = s.replace(/[\d|-]/g, "");           // abc

Замена найденных подстрок выполняется на выражение expr. Выражением может быть строка, либо функция. Если в качестве выражения expr используется строка, то в ней можно использовать специальные символы:
$& - обозначает найденное совпадение
$` - обозначает часть строки до совпадения
$' - обозначает часть строки после совпадения
$n - обозначает n-ное совпадение с выражением, заданном в регулярном выражении в скобках

var s = "a1b2c3";
var r = s.replace(/\d/g, "($&)");           // a(1)b(2)c(3)

Вместо строки в качестве выражения expr можно указать callback-функцию. В этом случае ей передаются следующие параметры:
str - найденное совпадение
s1, s2, ... sn - содержимое скобок регулярного выражения (если они заданы)
pos - позиция найденного совпадения
src - исходная строка

var s = "a1b2c3";
var r = s.replace(/\d/g, function(str, pos, src) {
    console.log(pos);                   // 1, 4, 7
    return str * 2;
});                                     // a2-b4-c6
var r = s.replace(/\D+(\d)\D+(\d)\D+(\d)/, function(str, s1, s2, s3, pos, src) {
    return s3 + "-" + s2 + "-" + s1;
});                                     // 3-2-1
  • search(reg)

Поиск в строке по заданному регулярному выражению. Если совпадение найдено, то функция возвратит его индекс в исходной строке. В противном случае функция вернет -1.

var s = "a1-b2-c3";
var i = s.search(/b\d/);              // 3
var i = s.search(/\d\d/);             // -1
  • slice(st, fin)

Возвращает подстроку с позиции st по fin (не включая fin). Отрицательные аргументы означают отсчет от конца строки. Если второй аргумент отсутствует, то идет до конца строки. Если ни один аргумент не указан, то вернется вся строка. Синтаксис метода такой же как у аналогичного метода для массивов.

var s = "abcdef";
s.slice(3, 2);              // ""
s.slice(3);                 // "def"
s.slice(3, 5);              // "de"
s.slice(-5, 2);             // "b"
s.slice(2, -1);             // "cde"
s.slice();                  // "abcdef"
  • split(s[,n])

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

var s = "1, 2, 3";
s.split(', ');              // ["1", "2", "3"]
s.split(', ', 2);           // ["1", "2"]
"test".split("");           // ["t", "e", "s", "t"]
  • substr(st, len)

Возвращает подстроку с позиции st, длиной len. Если второй аргумент отсутствует, то идет до конца строки. Отрицательный первый аргумент означает отсчет от конца строки.

var s = "abcdef";
s.substr(3, 2);             // "de"
s.substr(3);                // "def"
s.substr(4, 3);             // "ef"
s.substr(-5, 2);            // "bc"
s.substr(2, -1);            // ""
  • substring(st, fin)

Возвращает подстроку с позиции st по fin (не включая fin). Если второй аргумент отсутствует, то идет до конца строки. Отрицательные аргументы интерпретируются как 0. Если st > fin, то они меняются местами.

var s = "abcdef";
s.substring(1, 4);          // "bcd"
s.substring(3);             // "def"
s.substring(4, 3);          // "d"
s.substring(-3);            // "abcdef"
  • toLocaleLowerCase()

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

var s = "ABC";
s = s.toLocaleLowerCase();           // abc
  • toLowerCase()

Возвращает строку в нижнем регистре

var s = "Abcd";
s.toLowerCase();            // "abcd"
  • toLocaleUpperCase()

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

var s = "abc";
s = s.toLocaleUpperCase();           // ABC
  • toUpperCase()

Возвращает строку в верхнем регистре

var s = "Abcd";
s.toUpperCase();            // "ABCD"
  • trim()

Возвращает строку с вырезанными пробельными символами с начала и с конца строки

var s = "   abc   ";
s = s.trim();               // "abc"