Приветствую всех читателей блога сайт В этой статье мы рассмотрим встроенный объект jscript – String, который отвечает за обработку текста.
Внутренний класс js String языка программирования сервера сценариев предоставляет методы для работы со строками, например, поиск подстроки, парсинг или замена. У него есть одно свойство length , которое возвращает длину строки. Нужно помнить, что . Для объявления класса нет необходимости использовать ключевое слово new и String .
Давайте рассмотрим простой пример:
// Объект js String // length_string.js //************************************* var s1, s2; s1 = "простой текст" ; s2 = new String ("простой текст" ) ; WScript.Echo (s1.length + "\n " + s2.length ) ; |
Видим, что тут мы объявили две переменные s1 и s2, обе хранят текстовое значение "простой текст ", с помощью свойства length мы определили их длину. Как видим, можно использовать как упрощенный формат, так и более громоздкий (ключевые слова new).
Давайте рассмотрим основные методы класса String.
s.charAt (index) – Получить символ с заданным индексом (index) из s.
s.charCodeAt (index) – Извлекаем заданный код символа в кодировке Unicode через его индекс (index) из s.
s1.concat (s2) – Конкатенация (объединение) s1и s2.
String.fromCharCode (c1,...,cN) - Сформировать unicode-строку. Вместо символов мы прописывает коды Unicode .
//************************************* // Объект js String // Формирование строки // fromCharCode_string.js //************************************* var MyResult; //вернет hello MyResult = String .fromCharCode (104 , 101 , 108 , 108 , 111 ) ; WScript.Echo (MyResult) ; |
s.indexOf (substr, startindex) – Данный метод js String класса позволяет производить поиск подстроки substr в строке s. Параметр startindex задает номер знака, с которого следует начинать поиск, если данный параметр отсутствует, то поиск производится с самого начала. Сам процесс происходит слева на право . indexOf возвращает число – индекс знака, начиная с которого найдено вхождение, если ничего не найдено, то будет возвращено значение -1. Не забываем, что нумерация символов начинается с нуля .
//************************************* // объект js String // Поиск в строке // indexOf_string.js //************************************* var MyStr= "один, два, три и четыре" , MyResult; MyResult= MyStr.indexOf ("два" , 2 ) ; WScript.Echo (MyResult) ; |
s.lastIndexOf (substr, startindex) – Аналогично indexOf, но искать будем в обратном порядке.
s.match (rgExp) – Данный метод js класса String позволяет искать в тексте s, используя регулярные выражения (rgExp). В результате, будет получен массив, содержащий результат. Первый элемент массива – найденный текст, второй – подстрока соответствующая первому подвыражению, третий - подстрока соответствующая второму подвыражению, и так далее. Для примера, мы рассмотрим сценарий, который производит парсинг url адреса.
//************************************* // String js // парсинг url адреса // match_string.js //************************************* var url = /(\w+):\/\/([\w.]+)\/(\S*)/ ; var text = "интернет страница http://www.сайт/~vladimir" ; var result = text.match (url) , index, list= "" if (result != null ) { for (var index in result) { list+= result[ index] + "\n " ; } } WScript.Echo (list) ; |
s.slice (start, ) – Получить часть из текста s, параметры start и end задают соответственно начальную и конечную позицию, и являются целыми числами.
s.split (str) – Разбить текст s на подстроки, и прописать их как . Параметр str определяет символьный знак, являющийся признаком начала разбиения. На выходе мы получаем массив.
//************************************* // объект String js // парсинг строки в массив // split_string.js //************************************* var MyStr2, MyResult1, index, list= "" ; MyStr2 = "первый, второй, третий, четвертый" ; MyResult1 = MyStr2.split (", " ) ; for (var index in MyResult1) { list+= MyResult1[ index] + "\n " ; } WScript.Echo (list) ; |
s.substr (start [, length]) – Аналогично slice, но тут мы указываем не конечный индекс, а длину.
s.substring (index1, index2) – Позволяет получить подстроку из заданной s строчки. substring не изменяет исходного значения. Параметры задают позиции начального и конечного знака.
Когда пишешь JavaScript , очень часто приходится лазить по интернету в поисках информации о синтаксисе и параметрах для методов, работающих со строками.
Я прочитал множество статей по работе со строками. В данном посте будет показаны примеры и краткие описания наиболее распространенных методов по работе со строками. Я попытался поставить самые частые методы в верхней части для быстрого ознакомления.
Конечно, большинство опытных разработчиков уже достаточно знакомы со многими из методов, но я думаю, что это хороший список для начинающих, чтобы понимать спектр методов, которые могут помочь выполнить сложные операции простыми средствами.
Вы можете конвертировать число, булево выражение или объект в строку:
Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"
Вы можете сделать это так же с помощью String() :
Var myNumber = 24; // 24 var myString = String(myNumber); // "24"
Если вы не уверены, что значение не является null или undefined , вы можете использовать String() , которая всегда возвращает строку, независимо от типа значения.
Чтобы разделить строки в массив подстрок, вы можете использовать метод split():
Var myString = "coming,apart,at,the,commas"; var substringArray = myString.split(","); // ["coming", "apart", "at", "the", "commas"] var arrayLimited = myString.split(",", 3); // ["coming", "apart", "at"]
Как видно в последней строке, второй параметр функции — это лимит количества элементов, которое будет в итоговом массиве.
Чтобы найти, сколько символов в строки, мы используем свойство length:
Var myString = "You"re quite a character."; var stringLength = myString.length; // 25
Есть два метода для поиска подстроки:
Использование indexOf() :
Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.indexOf("Waldo"); // 7
indexOf() метод начинает поиск подстроки с начала строки, и возвращает позицию начала первого вхождения подстроки. В данном случае — 7 позиция.
Использование lastIndexOf() :
Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22
Метод возвращает начальную позицию последнего вхождения подстроки в строку.
В обоих методах, если подстрока не найдена, возвращается значение -1, и оба принимают необязательный второй аргумент, указывающий положение в строке, где вы хотите начать поиск. Таким образом, если второй аргумент «5», indexOf() начинает поиск с 5 символа, игнорируя символы 0-4, в то время как lastIndexOf() начинает поиск с символа 5 и идет в обратном направлении, игнорируя символы 6 и дальше.
Чтобы заменить вхождение подстроки в строке на другую подстроку, вы можете использовать replace() :
Var slugger = "Josh Hamilton"; var betterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log(betterSlugger); // "Jose Bautista"
Первый аргумент — то, что вы хотите заменить и второй аргумент — новая строка. Функция заменяет только первое вхождение подстроки в строку.
Чтобы заменить все вхождения, нужно использовать регулярное выражение с глобальным флагом:
Var myString = "She sells automotive shells on the automotive shore"; var newString = myString.replace(/automotive/g, "sea"); console.log(newString); // "She sells sea shells on the sea shore"
Второй аргумент может включать специальный шаблон или функцию. Подробней можно почитать .
Получить символ мы можем с помощью функции charAt() :
Var myString = "Birds of a Feather"; var whatsAtSeven = myString.charAt(7); // "f"
Как часто бывает в JavaScript, первая позиция в строке начинается с 0, а не с 1.
В качестве альтернативной функции можно использовать charCodeAt() функцию, которая код символа.
Var myString = "Birds of a Feather"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"
Заметьте, что код для символа «F» (11 позиция) другой, нежели у символа «f» (позиция 7).
В большинстве случаем, чтобы соединить строки, можно использовать оператор «+». Но так же можно использовать метод concat() :
Var stringOne = "Knibb High football "; var stringTwo = stringOne.concat("rules."); // "Knibb High football rules"
Таким способом мы можем соединить множество строк в одну в том порядке, в котором они записаны:
Var stringOne = "Knibb "; var stringTwo = "High "; var stringThree = "football "; var stringFour = "rules."; var finalString = stringOne.concat(stringTwo, stringThree, stringFour); console.log(finalString); // "Knibb high football rules."
Есть 3 способа получения строки из части другой строки:
Используя slice() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice(5, 10); // "fghij"
Используя substring() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring(5, 10); // "fghij"
В обеих функция первый параметр — символ, с которого начинает подстрока (начиная с 0 позиции) и второй аргумент (необязательный) — позиция символа, до которого возвращается подстрока. В примере (5, 10) возвращается строка между позицией 5 и 9.
Используя substr() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr(5, 10); // "fghijklmno"
Первый аргумент — позиция символа, с которого начинается новая строка и второй аргумент — количество символов от начальной позиции новой строки. Т.е. (5, 10) возвращает 10 символов, начиная с 5 позиции.
Есть 4 метода для перевода. Первые 2 переводят строку в верхний регистр:
Var stringOne = "Speak up, I can"t hear you."; var stringTwo = stringOne.toLocaleUpperCase(); // "SPEAK UP, I CAN"T HEAR YOU" var stringThree = stringOne.toUpperCase(); // "SPEAK UP, I CAN"T HEAR YOU"
Другие 2 переводят строку в нижний регистр:
Var stringOne = "YOU DON"T HAVE TO YELL"; var stringTwo = stringOne.toLocaleLowerCase(); // "you don"t have to yell" var stringThree = stringOne.toLowerCase(); // "you don"t have to yell"
Лучше использовать «locale» методы, т.к. в разных местах, например, в Турции отображение регистров работает не совсем так, как мы привыкли и поэтому результат может быть тот, который мы хотели. Если использовать «locale» методы, то таких проблем не будет.
Соответствие по шаблону в строке может быть использовано с помощью 2-х методов, которые работают по-разному.
Метод match() применяется к строке и он принимает в качестве параметра регулярное выражение:
Var myString = "How much wood could a wood chuck chuck"; var myPattern = /.ood/; var myResult = myString.match(myPattern); // ["wood"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "How much wood could a wood chuck chuck"
Метод exec() применяется к объекту регулярного выражения и принимает в качестве параметра строку:
Var myString = "How much wood could a wood chuck chuck"; var myPattern = /.huck/; var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "How much wood could a wood chuck chuck"
В обоих методах возвращается лишь первое совпадение. Если совпадений не было — возвращается null.
Так же можно использовать метод search() , который принимает регулярное выражение и возвращает позицию первого совпадения по шаблону:
Var myString = "Assume"; var patternLocation = myString.search(/ume/); // 3
Если совпадений не было — возращается «-1 «.
Вы можете сравнить 2 строки, чтобы определить, какая их них идет первая по алфавиту. Для этого воспользуемся методом localeCompare() , который возвращает 3 возможных значения:
Var myString = "chicken"; var myStringTwo = "egg"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (Chrome returns -2) whichCameFirst = myString.localeCompare("chicken"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome returns 2)
Как было показано выше, отрицательное число возвращается, если строковый аргумент идет после исходной строки. Положительное число, если строковый аргумент идет раньше исходной строки. Если вернулся 0 — значит строки равны.
Для проверки возвращаемого значения лучше использовать if (result < 0), чем if (result === -1). Последнее не будет работать в Chrome.
Спасибо за внимание, надеюсь, что вы узнали много нового и интересного!
Автор статьи: Alex. Категория:В этой статье речь пойдет о том, что такое строки в JavaScript и методах работы с ними.
Строки — это просто группы символов, такие как « JavaScript », « Hello world! », « http://www.quirksmode.org » или даже « 14 ». Для программирования на JavaScript Вам необходимо знать, что такое строки и как с ними работать, т. к. использовать их придется очень часто. Многие вещи, такие как URL -страницы, значения CSS -параметров и элементов ввода форм — все является строками.
Сначала постараюсь объяснить работы со строками , затем — разницу между в JavaScript. Даже если у Вас есть опыт программирования на другом языке, внимательно прочтите эту часть. В конце я расскажу о самых важных строк в JavaScript .
Давайте рассмотрим основы работы со строками в JavaScript.
Когда Вы объявляете строки в JavaScript или работаете с ними, всегда заключайте их в одинарные или двойные кавычки. Этим Вы объясняете браузеру, что он имеет дело со строкой. Не смешивайте использование кавычек в коде, если Вы начали строку с одинарной кавычки, а закончили двойной, JavaScript не поймет, что Вы имели в виду. Как правило, я использую одинарные кавычки для работы со строками, так как двойные кавычки я решил использовать для HTML , а одинарные — для JavaScript. Конечно, Вы можете делать все по-другому, но я советую вам придумать подобное правило для себя.
Давайте представим две строки, которые мы будем использовать на протяжении всей статьи:
Var a = "Hello world!"; var b = "I am a student.";
Сейчас мы объявили две переменные, « a » и « b », и присвоили им строковые значения. После этого мы можем с ними работать, но сначала решим одну проблему: допустим, я написал:
Var b = "I"m a student.";
Строка содержит в себе лишнюю одинарную кавычку, и JavaScript думает, что строка закончена и выводит сообщение об ошибке, не понимая, что следует дальше. Поэтому Вам нужно экранировать кавычку , сообщая браузеру, что её нужно рассматривать как символ, а не как окончание строки. Это осуществляется с помощью «обратного слеша» перед кавычкой:
Var b = "I\"m a student.";
Заметьте, что Вы можете вставлять в строку двойные кавычки без их экранирования. Так как Вы используете одинарные кавычки, как начало и конец строки,
Var b = "I\"m a "student".";
воспринимается без проблем. Двойные кавычки автоматически рассматриваются, как части строки, а не команды.
После определения строк можно начать их использование. Например, Вы можете соединить одну строку с другой , или взять из строки « b » подстроку, состоящую из второго—четвертого символов и вставить их в середину строки « a », или определить какой символ стоит двенадцатым в « a », сколько символов в « b », есть ли в них буква «q» и т. д.
Для этого Вы можете использовать встроенные функции, которые JavaScript предопределяет для каждой строки. Одна из них — «length» — возвращает длину строки. То есть если Вы хотите вычислить длину «Hello world!», напишите:
Var c = "Hello world!".length;
Ранее мы присвоили эту строку переменной « а ». Таким образом, Вы сделали переменную « a » строкой, поэтому к ней тоже применима функция «length», и следующая операция даст такой же результат:
Var c = a.length;
Запомните, что Вы можете использовать «length» для любой строки — это встроенная функция. Вы можете вычислить длину любой строки , например: « location.href » или « document.title » или объявленной Вами.
Ниже я представлю список распространенных встроенных методов и свойств.
В некоторых языках программирования от Вас требуется указывать, является ли переменная числом или строкой, перед тем, как делать с ней что-либо ещё. JavaScript проще относится к разнице между строками и числами. Фактически Вы даже можете складывать числа со строками:
Var c = a + 12;
В некоторых языках программирования обработка такой строки приведет к ошибке. Всё же « a » — это строка, а «12» — число. Однако JavaScript пытается решить проблему, предполагая, что «12» — тоже строка. Таким образом « с » принимает значение « Hello world!12 ». Значит, если Вы используете «+» со строкой и числом, JavaScript пытается сделать из числа строку. Если же Вы применяете математические операции к строке, JavaScript пробует превратить её в число. При отсутствии возможности перевода строки в число (например, из-за наличия в ней букв), JavaScript возвращает NaN — «Not a Number — не является числом».
Наконец, в JavaScript нет разницы между целыми величинами и числами с плавающей точкой.
Для преобразования числа в строку введите:
Var c = (16 * 24) / 49 + 12; d = c.toString();
После этого Вы можете применять к « d » все строковые методы, а « c » все ещё содержит число.
Если Вы хотите преобразовать строку в число, сначала убедитесь, что она состоит только из символов 0—9 . Для этого я просто умножаю строку на 1 .
Var c = "1234"; d = c * 1;
Так как умножение производится только с числами, JavaScript превращает строку в число, если это возможно. В противном случае, результат — NaN .
Заметим, если написать:
Var c = "1234"; d = c + 0;
Результатом будет « 12340 », потому что JavaScript использует «+» для соединения строк, а не их сложения.
Так что же мы можем делать со строками? Объединение — это особый случай, но все остальные команды (методы) могут использоваться с любой строкой с помощью конструкции:
Имя_строки.метод();
Во-первых, Вы можете объединить строки, сложив их вместе, вот так:
Document.write(a + b);
в результате получится: « Hello world!I am a student. ». Но, конечно же, Вы хотите, чтобы между предложениями был пробел. Для этого запишем код следующим образом:
Document.write(a + " " + b);
Так мы соединим три строки: « а », « " " » (один пробел) и « b », в итоге получив: « Hello world! I am a student. »
Вы можете использовать даже числа или вычисления, например:
Document.write (a + 3 * 3 + b);
Сейчас мы соединяем строку « а », затем результат выражения « 3 * 3 », рассматриваемый как строка, и « b », получая: « Hello world!9 I am a student. »
При использовании сложения нужно быть внимательным. Команда
Document.write (a + 3 + 3 + b);
соединяет 4 строки: « а », « 3 », « 3 » и « b », потому что «+» в данном случае означает «соединить строки», а не «сложить» и в результате: « Hello world!33 I am a student. ». Если Вы хотите сложить 3 и 3 перед созданием строки, используйте скобки.
Document.write (a + (3 + 3) + b);
Данное выражение соединяет строку « а », результат выражения « 3 + 3 » и « b », в итоге: « Hello world!6 I am a student. ».
Один из самых широко используемых встроенных методов это «indexOf». Каждый символ имеет свой индекс, содержащий номер его позиции в строке. Заметим, что индекс первого символа — 0 , второго — 1 и т. д. Таким образом, индекс символа «w» в сроке « а » — 6 .
Используя «indexOf» мы можем вывести индекс символа. Напишите « .indexOf(" ") » после названия строки и вставьте искомый символ между кавычками. Например:
Var a = "Hello world!"; document.write(a.indexOf("w"));
возвратит 6 . Если символ встречается несколько раз, этот метод возвращает первое вхождение. То есть
Document.write(a.indexOf("o"));
возвратит 4 , потому что это индекс первой «o» в строке.
Вы также можете искать комбинацию символов. (Конечно, это тоже строка, но, чтобы избежать путаницы, я не буду называть её так). «indexOf» возвращает позицию первого символа комбинации. Например:
Document.write(a.indexOf("o w"));
тоже возвратит 4 , потому что это индекс «o».
Более того, возможен поиск символа после определенного индекса. Если Вы введете
Document.write(a.indexOf("o", 5));
то получите индекс первой «o», следующей за символом с индексом 5 (это пробел), то есть результат будет — 7 .
Если символ или комбинация не встречается в строке, «indexOf» возвратит « -1 ». Это, по сути, самое популярное применение «indexOf»: проверка существования определенной комбинации символов. Оно является ядром скрипта, определяющего браузер. Для определения IE Вы берете строку:
Navigator.userAgent;
и проверяете, содержит ли она « MSIE »:
If(navigator.userAgent.indexOf("MSIE") != -1) { //Какие-либо дествия с Internet Explorer }
Если индекс « MSIE » — не « -1 » (если « MSIE » встречается где-либо в строке), то текущий браузер — IE .
Также существует метод «lastIndexOf», который возвращает последнее вхождение символа или комбинации. Он действует противоположно «indexOf». Команда
Var b = "I am a student."; document.write(b.lastIndexOf("t"));
возвратит 13 , потому что это индекс последней «t» в строке.
Метод «charAt» возвращает символ, стоящий на указанной позиции. Например, когда Вы вводите
Var b = "I am a student."; document.write(b.charAt(5));
в результате получается « a », так как это символ на шестой позиции (помните, что индекс первого символа начинается с 0).
Метод «length» возвращает длину строки.
Var b = "I am a student."; document.write(b.length);
возвратит «15». Длина строки на 1 больше, чем индекс последнего символа.
« split » — это специальный метод, позволяющий разделить строку по определенным символам. Используется, когда результат необходимо заносить в массив, а не в простую переменную. Давайте разделим « b » по пробелам:
Var b = "I am a student." var temp = new Array(); temp = b.split(" ");
Теперь строка разбита на 4 подстроки, которые помещаются в массив « temp ». Сами пробелы исчезли.
Temp = "I"; temp = "am"; temp = "a"; temp = "student";
Метод «substring» используется для выделения части строки. Синтаксис метода: « .substring(первый_индекс, последний_индекс) ». Например:
Var a = "Hello world!"; document.write(a.substring(4, 8));
возвратит « o wo », от первой «o» (индекс 4) до второй (индекс 7). Заметьте, что «r» (индекс 8) не является частью подстроки.
Также можно написать:
Var a = "Hello world!"; document.write(a.substring(4));
Это даст целую подстроку « o world! », начиная от символа с индексом 4 и до конца строки.
Также есть метод «substr», работающий немного по-другому. В качестве второго аргумента он использует не номер индекса, а количество символов. То есть
Document.write(a.substr(4, 8));
возвращает 8 символов, начиная от символа с индексом 4 («o»), то есть в результате получаем: « o world! »
Наконец, 2 метода, которые иногда могут Вам пригодиться: «toLowerCase» переводит всю строку в нижний регистр, а «toUpperCase» — в верхний.
Var b = "I am a student."; document.write(b.toUpperCase());
В результате получим « I AM A STUDENT. ».
Когда я пишу на javascript, то приходится часто обращаться к поисковым системам, с целью уточнить синтаксис методов (и порядок, определение аргументов) работающих со строками.
В этой статье я постараюсь привести примеры и описание наиболее распространенных методов javascript связанных со строками. Наиболее популярные методы для удобства расположены в верхней части статьи.
Вы можете преобразовать число, булево значение или объект в строку.
Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"
Вы также можете совершить подобную манипуляцию при помощи функции string() .
Var myNumber = 24; // 24 var myString = String(myNumber); // "24"
Николас Закас говорит: "Если вы не уверены в значении (null или undefined), то используйте функцию String() , так как она возвращает строку в независимости от типа переменной".
undefined означает, что переменной не присвоено никакого значения, a null , - что ей присвоено пустое значение (можно сказать, что null определяется, как пустой объект).
Чтобы разбить строку на массив из подстрок вы можете использовать метод split() :
Var myString = "coming,apart,at,the,commas"; var substringArray = myString.split(","); // ["coming", "apart", "at", "the", "commas"] var arrayLimited = myString.split(",", 3); // ["coming", "apart", "at"]
Как следует из последней строки, значение второго необязательного аргумента определяет количество элементов у возвращаемого массива.
При помощи свойства length вы можете найти число юникодных символов в строке:
Var myString = "You"re quite a character."; var stringLength = myString.length; // 25
Есть два способа осуществить задуманное:
Использовать indexOf() :
Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.indexOf("Waldo"); // 7
Метод indexOf() ищет подстроку (первый передаваемый аргумент) в строке (от начала строки) и возвращает позицию первого символа, с которого началось вхождение подстроки в строку.
Использовать lastIndexOf() :
Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22
Метод lastIndexOf() делает все то же самое, за исключением того, что он ищет последнюю подстроку по вхождению в строку.
В случае, если подстрока не найдена оба метода возвращают -1. Второй необязательный аргумент указывает на позицию в строке, с которой вы хотите начать поиск. Так, если для метода indexOf() второй аргумент равен 5, то поиск начнется с 5-го символа, а 0-4 символы будут проигнорированы. Для lastIndexOf() , также если второй аргумент равен 5, поиск начнется в обратном направлении, причем символы от 6-го и выше будут проигнорированы.
Чтобы заменить часть (или даже всю) строки используйте метод replace() .
Var slugger = "Josh Hamilton"; var betterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log(betterSlugger); // "Jose Bautista"
В первом аргументе содержится та часть подстроки, которая подлежит замене; второй аргумент - это та строка, которая встанет на место заменяемой подстроки. Будет заменен только первый экземпляр подстроки.
Чтобы заменить все вхождения подстроки, используйте регулярное выражение c флагом " g ".
Var myString = "She sells automotive shells on the automotive shore"; var newString = myString.replace(/automotive/g, "sea"); console.log(newString); // "She sells sea shells on the sea shore"
Второй аргумент может включать заменяемую подстроку или функцию.
Чтобы выяснить какой символ стоит в заданной позиции, вы можете использовать метод charAt() :
Var myString = "Birds of a Feather"; var whatsAtSeven = myString.charAt(7); // "f"
Как это часто бывает в javascript, первая позиция ведет свой отсчет с 0, а не с 1.
Как альтернативу вы можете использовать метод charCodeAt() , однако вместо самого символа вы получите его код.
Var myString = "Birds of a Feather"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"
Отметьте, что код для прописной буквы (позиция 11) отличается от кода той же буквы, но в малом регистре (позиция 7).
По большой части для конкатенации строк вы будете использовать оператор (+). Но вы также можете объединить строки, используя метод concat() .
Var stringOne = "Knibb High football "; var stringTwo = stringOne.concat("rules."); // "Knibb High football rules"
В concat() можно передать множество строк, причем в результирующей строке они будут расположены в порядке их добавления в метод concat() .
Var stringOne = "Knibb "; var stringTwo = "High "; var stringThree = "football "; var stringFour = "rules."; var finalString = stringOne.concat(stringTwo, stringThree, stringFour); console.log(finalString); // "Knibb high football rules."
Есть три различных способа создать новую строку, "выдернув" часть подстроки из уже имеющейся строки.
Используя slice() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice(5, 10); // "fghij"
Используя substring() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring(5, 10); // "fghij"
Для обеих (slice() и substring()) методов первый аргумент - это позиция символа, с которого начинается подстрока (отсчет ведется с 0) , второй аргумент - это позиция символа, на котором подстрока заканчивается, причем символ, обозначенный во втором аргументе, не включается в возвращаемую подстроку.
Используя substr() :
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr(5, 10); // "fghijklmno"
Для метода substr первый аргумент также определяет позицию символа, с которого начинается подстрока. Второй аргумент является необязательным. Но в тоже время второй аргумент определяет количество символов, которые должны быть включены в подстроку, начиная с позиции, которую мы уже определили в первом аргументе. Данная методика хорошо проиллюстрирована на примере выше.
Есть четыре метода сделать необходимые преобразования. Два для преобразования символов строки в верхний регистр.
Var stringOne = "Speak up, I can"t hear you."; var stringTwo = stringOne.toLocaleUpperCase(); // "SPEAK UP, I CAN"T HEAR YOU" var stringThree = stringOne.toUpperCase(); // "SPEAK UP, I CAN"T HEAR YOU"
И два для преобразования строки в нижний регистр:
Var stringOne = "YOU DON"T HAVE TO YELL"; var stringTwo = stringOne.toLocaleLowerCase(); // "you don"t have to yell" var stringThree = stringOne.toLowerCase(); // "you don"t have to yell"
Как правило, нет разницы между locale-методом и не-locale-методом, однако "для некоторых языков, например для турецкого, у которых регистр символов не следует установленному регистру в системе Unicode, последствия использования не-locale-метода могут быть различными". Поэтому следуйте следующему правилу: "если вы не знаете языка, в котором будет работать код, безопаснее использовать locale-методы".
Проверить наличие шаблона в строке можно при помощи 2-х методов.
Метод match() вызывается у объекта string , в качестве аргумента методу match() передается регулярное выражение.
Var myString = "How much wood could a wood chuck chuck"; var myPattern = /.ood/; var myResult = myString.match(myPattern); // ["wood"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "How much wood could a wood chuck chuck"
И exec() метод вызывается у RegExp объекта, в качестве аргумента передается строка:
Var myString = "How much wood could a wood chuck chuck"; var myPattern = /.huck/; var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "How much wood could a wood chuck chuck"
Оба метода возвращают первое совпавшее вхождение. Если совпадения не найдены будет возвращен NULL. Если у регулярного выражения присутствует флаг " g ", то в качестве результата будет возвращен массив, содержащий все совпадения.
Вы также можете использовать метод search(), который в качестве аргумента принимает регулярное выражение и возвращает начальную позицию первого совпавшего шаблона.
Var myString = "Assume"; var patternLocation = myString.search(/ume/); // 3
Если совпадений не найдено, метод возвратит -1.
Чтобы сравнить две строки в зависимости от порядка сортировки в языковом стандарте, вы можете использовать метод localeCompare . Метод localeCompare возвращает три возможных значения.
MyString = "chicken"; var myStringTwo = "egg"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (except Chrome, which returns -2) whichCameFirst = myString.localeCompare("chicken"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome returns 2)
Как показано выше, будет возвращено отрицательное значение, если оригинальная строка при сортировке оказывается перед строковым аргументом, если строковой аргумент при сортировке оказывается после оригинальная строки, возвращается значение +1. Если возвращается нулевое значение, две строки эквивалентны.
Тип данных строка (string) используется для представления текста. Соответственно, значениями типа string является текст. Любой текст в JavaScript является строкой.
Строки в JavaScript должны быть заключены в кавычки. В JavaScript существует три вида кавычек: двойные (" "), одинарные (" ") и обратные (` `):
"Строка в двойных кавычках" "Строка в одинарных кавычках" `Строка в обратных кавычках`
Вид кавычек в начале и конце строки должен совпадать.
Строки могут состоять из нуля и более символов:
"" // Пустая строка "Строка" // Не пустая строка
Строки с двойными и одинарными кавычками ничем не отличаются между собой по функционалу - они могут содержать лишь текст и управляющие последовательности. А вот строки с обратными кавычками имеют более широкий функционал. Такие строки могут содержать так называемые подстановки , обозначаемые знаком доллара и фигурными скобками ${выражение} . Подстановки могут содержать любые произвольные выражения:
Let стр = "Мир!"; let стр2 = `Привет, ${стр}`; // Использование переменной в строке alert(стр2); // Привет, Мир! alert(`2 + 3 = ${2 + 3}.`); // 2 + 3 = 5.
Выражение, расположенное в подстановке (${...}) вычисляется, и его результат становится частью строки.
Строки в обратных кавычках могут занимать более одной строки, сохраняя все пробельные символы:
Let числа = `Числа: 1 2`; alert(числа); // Числа: // 1 // 2
Строки с обратными кавычками называются строками-шаблонами или шаблонными литералами .
Строки, заключённые в одни кавычки, могут содержать другие кавычки:
"одинарные "кавычки" и `обратные` внутри двойных" "а здесь "так" и `так`!" `а здесь "так" и "так"!`
Для удобства, большие строковые литералы можно разбивать на несколько строк, заканчивая каждую строку, кроме последней, символом \ :
Alert("это всё одна \ длинная \ строка"); // это всё одна длинная строка alert("это всё одна \ длинная \ строка"); // это всё одна длинная строка alert(`это всё одна \ длинная \ строка`); // это всё одна длинная строка
Вне зависимости от того, какая кодировка установлена для страницы, в JavaScript для строк всегда используется кодировка UTF-16.
В JavaScript строка - это неизменяемая, упорядоченная последовательность 16-битных значений, каждое из которых представляет символ Unicode. Для представления символов Unicode в JavaScript используется кодировка UTF-16. Символы включают в себя буквы, цифры, знаки пунктуации, специальные символы и пробельные символы.
Длина строки - это количество 16-битных значений (а не самих символов), содержащихся в ней. Длину строки содержит свойство length:
Alert("Привет".length); // 6
Символы, кодовые пункты которых не умещаются в 16 бит, обрабатываются в соответствии с правилами кодировки UTF-16 как последовательности из двух 16-битных значений. Это означает, что строка, имеющая длину, равную 2 (два 16-битных значения), на деле может представлять единственный символ:
Alert("a".length); // 1 alert("𝑒".length); // 2
Как уже было сказано, строка представляет собой упорядоченную последовательность 16-битных значений, каждому из которых соответствует определённый символ. Нумерация 16-битных значений в строке начинается с нуля, т. е. первое 16-битное значение находится под индексом 0, второе - под индексом 1 и т. д. Индекс - это порядковый номер.
Получить символ строки (состоящий из одного 16-битного значения) можно с помощью индекса, заключённого в квадратные скобки [индекс] :
Let стр = "Привет"; alert(стр); // П alert(стр); // В
Чтобы с помощью индексов обратиться к символу, состоящему из двух 16-битных значений, нужно, используя конкатенацию, написать эти индексы так, чтобы в результате получилась последовательность из двух 16-битных значений:
Let стр = "𝑒"; alert(стр + стр); // "𝑒"
В JavaScript строки неизменяемые. Это значит, что в уже существующей строке нельзя менять никакие символы или добавлять в неё что-то новое.
Так как строки неизменяемые, то методы, используемые для работы со строками, возвращают новые строки, а не изменяют ту строку, относительно которой они были вызваны:
Let стр = "Привет!"; alert(стр.toUpperCase()); // "HELLO" - новое возвращаемое методом значение alert(стр); // "hello" - первоначальная строка не изменена
Чтобы изменить строку, можно создать новую строку и записать её в ту же самую переменную вместо старой строки:
Let стр = "Строка"; стр = стр.toUpperCase(); alert(стр); // "СТРОКА"
В строковых литералах можно использовать управляющие последовательности. Управляющая последовательность - это последовательность, состоящая из обычных символов, которая обозначает символ, не представимый внутри строки другими способами. Управляющие последовательности предназначены для форматирования вывода текстового содержимого.
В таблице ниже представлены управляющие последовательности:
Последовательность | Значение |
---|---|
\0 | Символ NUL - пустой символ ("\u0000"). |
\t | Горизонтальная табуляция ("\u0009"). |
\n | Перевод на новую строку ("\u000A"). |
\b | Возврат на одну позицию - то, что происходит при нажатии на клавишу backspace ("\u0008"). |
\r | Возврат каретки ("\u000D"). |
\f | Перевод страницы - очистка страницы ("\u000C"). |
\v | Вертикальная табуляция ("\u000B"). |
\" | Двойная кавычка ("\u0022"). |
\" | Одинарная кавычка ("\u0027"). |
\\ | Обратный слэш ("\u005C"). |
\xNN | Номер символа из набора символов ISO Latin-1, заданный двумя шестнадцатеричными цифрами (N - шестнадцатеричная цифра 0-F). Например, "\x41" (это код буквы "A"). |
\uNNNN | Номер символа из набора символов Unicode, заданный четырьмя шестнадцатеричными цифрами (N - шестнадцатеричная цифра 0-F). Например, "\u0041" (это код буквы "A"s). |
Управляющие последовательности могут находиться в любом месте строки:
Alert("Греческая буква сигма: \u03a3."); // Греческая буква сигма: Σ. alert("Многострочная\nстрока") // Многострочная // строка alert("внутри используются \"двойные\" кавычки"); // внутри используются "двойные" кавычки
Если символ \ предшествует любому символу, отличному от приведённых в таблице, то он просто игнорируется интерпретатором:
Alert("\k"); // "k"
Символы Unicode, указываемые с помощью управляющей последовательности, можно использовать не только внутри строковых литералов, но и в идентификаторах:
Let a\u03a3 = 5; alert(a\u03a3); // 5
Конкатенация - это объединение двух или более строк в одну большую. Объединение происходит с помощью оператора + (плюс). При конкатенации каждая последующая строка добавляется в конец предыдущей:
Var str1 = "Hello ";
var str2 = "World!";
document.write(str1 + str2 + "
"); // "Hello World!"
document.write(str1 + "World!");
Попробовать »
Значение любого типа, которое объединяется со строкой, будет неявно (автоматически) преобразовано в строку и далее будет произведена конкатенация.
Var str1 = "Hello "; alert(str1 + 1); // "Hello 1" alert(true + str1); // "trueHello" alert(str1 + NaN); // "Hello NaN"