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

"Роботландия".charAt(0)  // Равно "Р"
"Роботландия".charAt(10) // Равно "я"
var x = "Роботландия";
x.charAt(x.length-1)     // Равно "я"

Таким образом, прочитать n-ый символ строки можно при помощи метода charAt(n).

А есть ли метод, позволяющий записать на место n-го символа другой, или удалить n-ый символ из строки? Таких методов нет. Но операции замены и удаления символа легко смоделировать.

// Возвращает строку, в которой удален n-ый символ
// Если n неправильно задан, возвращает исходную строку
// Аргументы:
// str -- исходная строка
// n   -- позиция, в которой должен быть удален символ
function delSymbol(str, n) 
{
  if (n < 0 || n > str.length-1) return str;
  else return str.substring(0,n)+str.substring(n+1); 
}

var s = "Эккран";
s = delSymbol(s,1);  // s == "Экран"

// Возвращает строку, в которой n-ый символ заменён подстрокой
// Если n неправильно задан, возвращает исходную строку
// Аргументы:
// str -- исходная строка
// n   -- позиция, в которой символ заменяется
// sub -- строка для замены
function replaceSymbol(str, n, sub) 
{
  if (n < 0 || n > str.length-1) return str;
  else return str.substring(0,n)+sub+str.substring(n+1); 
}

var s1 = "Ошипка", s2="Кутча";
s1 = replaceSymbol(s1,3,"б");    // s1 == "Ошибка"
s2 = replaceSymbol(s2,2,"кара"); // s2 == "Кукарача"

Возвращает Unicode n-го символа строки (число от 0 до 65535).

"1 и 2".charCodeAt(1)              // Равно числу 32
"1 и 2".charCodeAt(1).toString(16) // Равно строке "20"

Как работает последний пример:

1. Для строки "1 и 2" создаётся экземпляр объекта String.
2. К полученному объекту применяется метод charCodeAt() — получается число 32.
3. Созданная обертка String уничтожается.
4. Для числа 32 создаётся экземпляр объекта Number.
5. К полученному объекту применяется метод toString(16) — получается строка "20" (32 в 16-ричной системе счисления).
6. Созданная обертка Number уничтожается.

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

"Робот".concat("ландия")      // Равно "Роботландия"                           
var s  = "";
var s1 = s.concat(1,2,3,4,5); // s1 == "12345" (s == "")                            
"".concat(20/5," дня")        // Равно "4 дня"                           

Отметим, что оператор +, примененный к строкам, действует аналогично.

"Робот" + "ландия"  // Равно "Роботландия"                           
"" + 20/5 + " дня"  // Равно "4 дня"                           

Возвращает строку из символов, заданных кодами Unicode. Это метод класса, он не передается экземпляру, его можно вызывать только как String.fromCharCode(). Например, записи s.fromCharCode(), "Роботландия".fromCharCode() — неправомочны.

// Создаём строку "hello"
var s = String.fromCharCode(104,101,108,108,111);                                 

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

"Роботландия".indexOf("бот")   // Равно 2
"Роботландия".indexOf("робот") // Равно -1
"Роботландия".indexOf("бот",3) // Равно -1

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

"Роботландия".lastIndexOf("бот")   // Равно 2
"Роботландия".lastIndexOf("робот") // Равно -1
"Роботландия".lastIndexOf("бот",3) // Равно -1
"Роботландия".lastIndexOf("бот",4) // Равно 2
"кикимора".lastIndexOf("ки")       // Равно 2
"кикимора".indexOf("ки")           // Равно 0

Сравнивает две строки с учетом порядка следования символов национального языка (установленного в операционной системе). Возвращает:

• отрицательное число, если меньше
• ноль, если равно
• положительное число, если больше

"арба".localeCompare("бот")   // Равно -1
"папа".localeCompare("мама")  // Равно 1
"кот".localeCompare("к"+"от") // Равно 0

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

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

Пример 1

"1 плюс 2 плюс 45".match(/\d/) // Равно ["1"]

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

\d — обозначает любые ASCII-цифры, то есть, 0–9.

Регулярное выражение /\d/ задает шаблон цифры. Метод match() ищет первую цифру и записывает результат в массив: ["1"] — массив из одного элемента.

Пример 2

"1 плюс 2 плюс 45".match(/\d/g)  // Равно ["1", "2", "4", "5"]

Пояснение. К регулярному выражению добавился флаг g — выполнять глобальный поиск. Найдены все цифры. Результат — массив из 4 элементов.

Пример 3

"1 плюс 2 плюс 45".match(/\d+/g)  // Равно ["1", "2", "45"]

Пояснение. Символ + соответствует одному или нескольким экземплярам предшествующего шаблона \d, то есть запись \d+ означает одну или несколько цифр, идущих подряд.

Пример 4

"один плюс два".match(/\d/g)  // Равно null

Пояснение. Поиск оказался неудачным. Метод возвращает значение null.

Значение null имеет в JavaScript специальный смысл: null есть объект (typeof null == "object") и в то же время говорит об отсутствии объекта.

В числовом контексте null преобразуется в число 0:

25+null // Равно 25

В строковом — в строку "null":

"25"+null // Равно "25null"

В логическом — в false:

!null // Равно true

В JavaScript есть ещё одно интересное значение — undefined. Это значение возвращается, если идет обращение к переменной, которая была объявлена, но которой не присвоено значения или к свойству объекта, которого не существует.

Пример 5

var x;
alert(x)  // undefined

Пример 6

alert(x)  // Сообщение об ошибке ("определение x отсутствует")

Пример 7

var x = {}
alert(x.t)  // undefined

Видим, что значения null и undefined отличаются, но оператор эквивалентности считает их равными:

null == undefined // Равно true

Конечно, оператор тождественности их различает:

null === undefined // Равно false

В числовом контексте undefined преобразуется в число NaN, в строковом — в строку "undefined", в логическом — в false.

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

Очень мошный и полезный метод!

"котовасия".replace("васия", "петия")  // Равно "котопетия"
"1 плюс 2 плюс 45".replace(/\d/, "Ц")  // Равно "Ц плюс 2 плюс 45"
"1 плюс 2 плюс 45".replace(/\d/g, "Ц")  // Равно "Ц плюс Ц плюс ЦЦ"
"кокорико".replace("ко", "мо")  // Равно "мокорико"
"кокорико".replace(/ко/, "мо")  // Равно "мокорико"
"кокорико".replace(/ко/g, "мо")  // Равно "моморимо"

Пример

var x = "1 плюс 2 плюс 45";
function z(s)
{
  if (s < 9) s++;
  return s;
}
var y = x.replace(/\d/g, z)  // Равно "2 плюс 3 плюс 56"

Поиск соответствия регулярному выражению. Возвращает номер позиции первой подстроки в строке, которая соответствует регвыр или -1, если соответствие не найдено. Метод не выполняет глобального поиска (флаг g игнорируется).

"113.3216".search(/./)    // Равно 0, так как точка в регулярных 
                          // выражениях обозначает любой символ.      
"113.3216".search(/\./)   // Равно 3. Символ обратного слеша снимает 
                          // специальный смысл точки.
"кокорико".search(/ри/)   // Равно 4
"Котовасия".search(/ко/)  // Равно -1
"Котовасия".search(/ко/i) // Равно 0. Флаг i делает шаблон регулярного  
                          // выражения не чувствительным к регистру

Возвращает подстроку с позиции start (включая) до позиции end (исключая). Исходная строка не меняется. Если start отрицателен, он отмечает позицию от конца строки, -1 — последний символ. Второй аргумент не обязателен, если он не указан, то до конца строки. Если end отрицателен, он отмечает позицию от конца строки, -1 — последний символ.

var s="0123456";
s.slice(0, 4)  // Равно "0123"
s.slice(2, 4)  // Равно "23"
s.slice(4)     // Равно "456"
s.slice(3,-1)  // Равно "345"
s.slice(3,-2)  // Равно "34"
s.slice(-3,-1) // Равно "45"

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

"12345678".split("")  // Равно ["1","2","3","4","5","6","7","8"]
"12 34 56 78".split(" ")  // Равно ["12","23","56","78"]
"-12-34-56-78-".split("-")  // Равно ["", "12","23","56","78",""]
"1 плюс 2 плюс 45".split("плюс") // Равно ["1 "," 2 "," 45"]
"раз1два2три3четыре".split(/\d/) // Равно ["раз","два","три","четыре"]

Возвращает подстроку с позиции начало указанной длины. Если длина отсутствует, возвращает фрагмент до конца строки. Если начало отрицательно, отсчет от конца, -1 — это последний символ. IE до 6 версии отрицательные значения считает нулем. Исходная строка не меняется. Метод считается устаревшим. Рекомендуется вместо него использовать методы substring и slice.

"Роботландия".substr(0, 5) // Равно "Робот" 
"Роботландия".substr(-6)   // Равно "ландия" во всех браузерах, кроме IE 

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

"Роботландия".substring(0, 5) // Равно "Робот" 
"Роботландия".substring(5, 0) // Равно "Робот" 
"Роботландия".substring(5)    // Равно "ландия" 

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

"РоботЛандия".toLocaleLowerCase() // Равно "роботландия"

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

"РоботЛандия".toLocaleUpperCase() // Равно "РОБОТЛАНДИЯ"

Возвращает копию строки преобразованной в нижний регистр. Исходная строка сохраняется неизменной.

"РоботЛандия".toLowerCase() // Равно "роботландия"

Возвращает копию строки преобразованной в верхний регистр. Исходная строка сохраняется неизменной.

"РоботЛандия".toUpperCase() // Равно "РОБОТЛАНДИЯ"

Возвращает саму строку.

"Роботландия".toString() // Равно "Роботландия"

Возвращает саму строку.

"Роботландия".valueOf() // Равно "Роботландия"

Любой объект содержит методы toString() и valueOf(). Они наследуются от главного объекта Object и переопределяются в каждом объекте по-своему. Например, метод toString() в объекте Number преобразует число в строку.