Строка – это последовательность из одного или нескольких символов, которая может содержать буквы, числа и другие символы. В JavaScript это простейший неизменяемый тип данных.
Строки позволяют отображать текст и работать с ним, а текст – основной способ общения и передачи информации в сети. Потому строки являются одним из главных понятий программирования.
Данный мануал научит вас создавать и просматривать вывод строк, объединять строки и хранить их в переменных. Также вы узнаете о правилах использования кавычек, апострофов и перехода к новой строке в JavaScript.
Создание и просмотр строки
В JavaScript существует три способа создания троки: их можно писать в одинарных кавычках (‘), в двойных («) или в обратных кавычках (`). Хотя иногда в сценариях встречаются строки всех трех типов, в рамках одной строки нужно использовать только один тип кавычек.
Строки в одинарных и двойных кавычках – это, по сути, одно и то же. Не существует никаких соглашений касательно использования того или иного типа кавычек, но обычно в сценариях программы рекомендуется последовательно использовать какой-нибудь один тип.
"This string uses single quotes.";
"This string uses double quotes.";
Третий и новейший способ создания строки называется шаблонным литералом. Шаблонные литералы пишутся в обратных кавычках (также этот символ называется тупым ударением) и работают так же, как обычные строки с несколькими дополнительными функциями, которые мы рассмотрим в этой статье.
`This string uses backticks.`;
Простейший способ просмотреть вывод строки – ввести ее в консоль с помощью console.log().
console.log("This is a string in the console.");
This is a string in the console.
Другим простым способом запросить значение строки является всплывающее окно в браузере, которое можно вызвать с помощью alert():
alert("This is a string in an alert.");
Эта строка откроет в браузере окно уведомления с таким текстом:
This is a string in an alert.
Метод alert() используется реже, поскольку оповещения нужно постоянно закрывать.
Хранение строк в переменных
Переменные в JavaScript – это именованные контейнеры, которые хранят значения с помощью ключевых слов var, const или let. Строки можно присваивать переменным.
const newString = "This is a string assigned to a variable.";
Теперь переменная newString содержит строку, на нее можно сослаться и вывести с помощью консоли.
console.log(newString);
This is a string assigned to a variable.
Присваивая строки переменным, не нужно повторно вводить строку каждый раз, когда ее нужно вывести, что упрощает работу со строками внутри программ.
Конкатенация строк
Конкатенация строк – это процесс объединения двух или нескольких строк в одну новую строку. Конкатенация выполняется с помощью оператора +. Символ + также является оператором сложения в математических операциях.
Для примера попробуйте объединить две короткие строки:
"Sea" + "horse";
Seahorse
Конкатенация объединяет конец одной строки с началом другой строки, не вставляя пробелов. Чтобы между строками был пробел, его нужно добавить в конец первой строки.
"Sea " + "horse";
Sea horse
Конкатенация позволяет объединять строки и переменные со строковыми значениями.
const favePoem = "My favorite poem is " + poem + " by " + author ".";
Новые строки, полученные в результате конкатенации, можно использовать в программе.
Переменные с шаблонными литералами
Одной из особенностей шаблонных литералов является возможность включения в строку выражений и переменных. Вместо конкатенации можно использовать синтаксис $ {} для вставки переменной.
const poem = "The Wide Ocean";
const author = "Pablo Neruda";
const favePoem = `My favorite poem is ${poem} by ${author}.`;
My favorite poem is The Wide Ocean by Pablo Neruda.
Это синтаксис позволяет получить тот же результат. Шаблонные литералы упрощают конкатенацию строк.
Строковые литералы и строковые значения
Как вы уже, должно быть, заметили, все строки пишутся в кавычках или обратных кавычках, но при выводе строка кавычек не содержит.
"Beyond the Sea";
Beyond the Sea
Строковый литерал – это строка, как она выглядит в исходном коде, включая кавычки. Строковое значение – это строка, которая появляется в выводе (без кавычек).
В данном примере «Beyond the Sea» – это строковый литерал, а Beyond the Sea – строковое значение.
Обход кавычек и апострофов в строках
В связи с тем, что кавычки используются для обозначения строк, существуют особые правила использования апострофов и кавычек в строках. Например, апостроф в середине строки в одинарных кавычках JavaScript воспримет как закрывающую одинарную кавычку, а остальную часть предполагаемой строки попытается прочитать как код.
Рассмотрим такой пример:
const brokenString = "I"m a broken string";
console.log(brokenString);
unknown: Unexpected token (1:24)
То же самое произойдет, если попробовать использовать двойные кавычки внутри строки, взятой в двойные кавычки. Интерпретатор не заметит разницы.
Чтобы избежать подобных ошибок, можно использовать:
- Другой синтаксис строк.
- Escape-символы.
- Шаблонный литерал.
Альтернативный синтаксис строк
Проще всего обойти эту проблему с помощью синтаксиса, обратного тому, который вы используете в сценарии. Например, строки с апострофами брать в двойные кавычки:
"We"re safely using an apostrophe in double quotes."
Строки с цитатами можно брать в одинарные кавычки:
"Then he said, "Hello, World!"";
Комбинируя одиночные и двойные кавычки, вы можете управлять отображением кавычек и апострофов внутри строк. Однако это повлияет на согласованность синтаксиса в файлах проекта, их будет сложно поддерживать.
Escape-символ \
С помощью обратного слеша JavaScript не будет интерпретировать кавычки как закрывающие.
Комбинация \’ всегда будет восприниматься как апостроф, а \» – как двойные кавычки, без исключений.
Это позволяет использовать апострофы в строках в одинарных кавычках, а цитаты – в строках с двойными кавычками.
"We\"re safely using an apostrophe in single quotes."
"Then he said, \"Hello, World!\"";
Этот метод выглядит немного беспорядочно. Но он необходим, если в одной строке содержатся и апостроф, и двойные кавычки.
Шаблонные литералы
Шаблонные литералы определяются обратными кавычками, поэтому и двойные кавычки, и апострофы можно спокойно использовать без каких-либо дополнительных манипуляций.
`We"re safely using apostrophes and "quotes" in a template literal.`;
Шаблонные литералы не только позволяют избежать ошибок при отображении кавычек и апострофов, но также предоставляют поддержку встроенных выражений и многострочных блоков, о чем речь пойдет в следующем разделе.
Многострочные строки и переход к новой строке
В некоторых ситуациях есть необходимость вставить символ новой строки или разрыв строки. Escape-символы \n or \r помогут вставить новую строку в вывод кода.
const threeLines = "This is a string\nthat spans across\nthree lines.";
This is a string
that spans across
three lines.
Это разобьет вывод на несколько строк. Однако если в коде есть длинные строки, с ними будет сложно работать и читать. Чтобы отобразить одну строку в нескольких строках, используйте оператор конкатенации.
const threeLines = "This is a string\n" +
"that spans across\n" +
"three lines.";
Обойти новую строку можно также с помощью escape-символа \.
const threeLines = "This is a string\n\
that spans across\n\
three lines.";
Примечание : Этот метод использовать не рекомендуется, так как это может вызвать проблемы в некоторых браузерах.
Чтобы сделать код удобочитаемым, используйте шаблонные литералы. Это позволяет исключить конкатенацию и escape-символы.
const threeLines = `This is a string
that spans across
three lines.`;
This is a string
that spans across
three lines.
Поскольку разные базы кода могут использовать разные стандарты, важно знать все способы перехода к новой строке и создания многострочных строк.
Заключение
Теперь вы знаете основные принципы работы со строками в JavaScript,умеете создавать строки и шаблонные литералы, выполнять конкатенацию и обход и присваивать строки переменным.
Tags:Последнее обновление: 06.04.2018
Для создания строк мы можем как напрямую присваивать переменной строку:
Let name = "Tom";
Для работы со строками предназначен объект String , поэтому также можно использовать конструктор String:
Var name = new String("Tom");
Но как правило, используется первый более краткий способ. В первом случае JavaScript при необходимости автоматически преобразует переменную примитивного типа в объект String.
Объект String имеет большой набор свойств и методов, с помощью которых мы можем манипулировать строками.
Свойство length указывает на длину строки:
Var hello = "привет мир"; console.log("В строке "" + hello + "" " + hello.length + " символов");
Метод repeat() позволяет создать строку путем многократного повторения другой строки. Количество повторов передается в качестве аргумента:
Let hello = "hello "; console.log(hello.repeat(3)); // hello hello hello
Шаблоны строк
Шаблоны строк позволяют вставлять в строку различные значения. Для этого строки заключаются в косые кавычки:
Let name = "Tom"; let hello = `Hello ${name}`; console.log(hello); // Hello Tom let age = 23; let info = `${name} is ${age} years old`; console.log(info); // Tom is 23 years old
Для вставки значения в строку оно заключается в фигурные скобки, перед которыми ставится знак доллара.
Также вместо скалярных значений могут добавляться свойства сложных объектов или результаты выражений:
Let tom ={ name: "Tom", age: 25 } let info = `${tom.name} is ${tom.age} years old`; console.log(info); // Tom is 23 years old function sum(x, y){ return x + y; } let a = 5, b = 4; let result = `${a} + ${b} = ${sum(a, b)}`; console.log(result); // 5 + 4 = 9
Поиск в строке
Для поиска в строки некоторой подстроки используются методы indexOf() (индекс первого вхождения подстроки) и lastIndexOf() (индекс последнего вхождения подстроки). Эти методы принимают два параметра:
Подстроку, которую надо найти
Необязательный параметр, который указывает, с какого символа следует проводить поиск подстроки в строке
Оба этих метода возвращают индекс символа, с которого в строке начинается подстрока. Если подстрока не найдена, то возвращается число -1.
Let hello = "привет мир. пока мир"; let key = "мир"; let firstPos = hello.indexOf(key); let lastPos = hello.lastIndexOf(key); console.log("Первое вхождение: ", firstPos); // 7 console.log("Последнее вхождение: ", lastPos); // 17
Еще один метод - includes() возвращает true, если строка содержит определенную подстроку.
Let hello = "привет мир. пока мир"; console.log(hello.includes("мир")); // true console.log(hello.includes("миг")); // false
С помощью второго дополнительного параметра можно определить индекс, с которого будет начинаться поиск подстроки:
Let hello = "привет мир. пока мир"; console.log(hello.includes("мир", 5)); // true console.log(hello.includes("привет", 6)); // false
Выбор подстроки
Для того, чтобы вырезать из строки подстроку, применяются методы substr() и substring() .
Метод substring() принимает два параметра:
индекс символа в строке, начиная с которого надо проводить обрезку строки
индекс, до которого надо обрезать строку
Метод substr() также в качестве первого параметра принимает начальный индекс подстроки, а в качестве второго - длину вырезаемой подстроки:
Let hello = "привет мир. пока мир"; let bye = hello.substr(12, 4); console.log(bye); // пока
Если второй параметр не указывается, то обрезается вся остальная часть строки:
Let hello = "привет мир. пока мир"; let bye = hello.substr(12); console.log(bye); // пока мир
Управление регистром
Для изменения регистра имеются методы toLowerCase() (для перевода в нижний регистр) и toUpperCase() (для перевода в верхний регистр).
Let hello = "Привет Том"; console.log(hello.toLowerCase()); // привет том console.log(hello.toUpperCase()); // ПРИВЕТ ТОМ
Получение символа по индексу
Чтобы получить определенный символ в строке по индексу, можно применять методы charAt() и charCodeAt() . Оба этих метода в качестве параметра принимают индекс символа:
Let hello = "Привет Том"; console.log(hello.charAt(2)); // и console.log(hello.charCodeAt(2)); // 1080
Но если в качестве результата метод charAt() возвращает сам символ, то метод charCodeAt() возвращает числовой код этого символа.
Удаление пробелов
Для удаления начальных и концевых пробелов в стоке используется метод trim() :
Let hello = " Привет Том "; let beforeLength = hello.length; hello = hello.trim(); let afterLength = hello.length; console.log("Длина строки до: ", beforeLength); // 15 console.log("Длина строки после: ", afterLength); // 10
Объединение строк
Метод concat() объединяет две строки:
Let hello = "Привет "; let world = "мир"; hello = hello.concat(world); console.log(hello); // Привет мир
Замена подстроки
Метод replace() заменяет первое вхождение одной подстроки на другую:
Let hello = "Добрый день"; hello = hello.replace("день", "вечер"); console.log(hello); // Добрый вечер
Первый параметр метода указывает, какую подстроку надо заменить, а второй параметр - на какую подстроку надо заменить.
Разделение строки
Метод split() разбивает строку на массив подстрок по определенному разделителю. В качестве разделителя используется строка, которая передается в метод:
Var message = "Сегодня была прекрасная погода"; var stringArray = message.split(" "); for(var str in stringArray) console.log(stringArray);
Вывод браузера
Сегодня была прекрасная погода
Проверка начала и окончания строки
Метод startsWith() возвращает true, если строка начинается с определенной подстроки. А метод endsWith() возвращает true, если строка оканчивается на определенную подстроку.
Let hello = "let me speak from my heart"; console.log(hello.startsWith("let")); // true console.log(hello.startsWith("Let")); // false console.log(hello.startsWith("lets")); // false console.log(hello.endsWith("heart")); // true console.log(hello.startsWith("bart")); // false
При этом играет роль регистр символов, и из примера выше мы видим, что "let" не эквивалентно "Let".
Дополнительный второй параметр позволяет указать индекс (для startsWith - индекс с начала, а для endsWith - индекс с конца строки), относительно которого будет производиться сравнение:
Let hello = "let me speak from my heart"; console.log(hello.startsWith("me", 4)); // true, "me" - 4 индекс с начала строки console.log(hello.startsWith("my", hello.length-8)); // true, "my" - 8 индекс с конца
Приветствую всех читателей блога сайт В этой статье мы рассмотрим встроенный объект 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.
Методы класса String JS
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, то приходится часто обращаться к поисковым системам, с целью уточнить синтаксис методов (и порядок, определение аргументов) работающих со строками.
В этой статье я постараюсь привести примеры и описание наиболее распространенных методов 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).
Конкатенация строк в javascript
По большой части для конкатенации строк вы будете использовать оператор (+). Но вы также можете объединить строки, используя метод 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."
Часть строки (извлечь подстроку в javascript)
Есть три различных способа создать новую строку, "выдернув" часть подстроки из уже имеющейся строки.
Используя 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 первый аргумент также определяет позицию символа, с которого начинается подстрока. Второй аргумент является необязательным. Но в тоже время второй аргумент определяет количество символов, которые должны быть включены в подстроку, начиная с позиции, которую мы уже определили в первом аргументе. Данная методика хорошо проиллюстрирована на примере выше.
Преобразование строки в нижний или верхний регистр на javascript
Есть четыре метода сделать необходимые преобразования. Два для преобразования символов строки в верхний регистр.
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-методы".
Соответствие шаблону в javascript
Проверить наличие шаблона в строке можно при помощи 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. Если возвращается нулевое значение, две строки эквивалентны.
Всем привет и с наступающим новым годом. Поехали! Начнем мы с рассмотрения свойства length которое позволяет нам посчитать количество символов в строке:
Var str = "методы и свойства для работы со строками в javaScript"; console.log(str.length);
как видите в консоли выведен результат, количество символов строки(54).
Var str = "методы и свойства для работы со строками в javaScript"; console.log(str.charAt(7));
с помощью метода charAt() мы можем по заданной позиции получить символ строки, в нашем случае нам возвращается символ "и" на 7 позиции. Отмечу что отчет позиций строки начинается с нуля. К примеру если мы хотим получить первый символ строки:
Var str = "методы и свойства для работы со строками в javaScript"; str.charAt(0);
здесь нам вернется "м". Еще есть похожий метод charCodeAt() ОН РАБОТАЕТ ТОЧНО ТАКЖЕ КАК И charAt(), но возвращает уже не сам символ, а его код.
Var str = "методы и свойства для работы со строками в javaScript"; console.log(str.charCodeAt(0));
Нам вернется код символа "м" (1084).
Метод charAt() полезен для извлечения одиночного символа из строки, если же мы хотим получить набор символов(подстроку), то для этих целей подойдут следующие методы:
Var str = "методы и свойства для работы со строками в javaScript"; console.log(str.slice(8,17));
метод slice() возвращает подстроку("свойства"), в качестве аргументов принимает два числовых значения, начальный и конечный индекс подстроки. Другой похожий метод substr():
Var str = "методы и свойства для работы со строками в javaScript"; console.log(str.substr(8,17));
здесь нам уже вернется подстрока("свойства для раб"), первым аргументом является начальная позиция, а вторым количество символов в подстроке. Дальше мы рассмотрим методы для работы с регистром в строках.
Var str = "методы и свойства для работы со строками в javaScript"; console.log(str.toUpperCase());
метод toUpperCase() возвращает нам строку где все символы в верхнем регистре, то есть большими буквами.
Var str = "MBA"; console.log(str.toLowerCase());
метод toLowerCase() возвращает нам строке где все символы в нижнем регистре, маленькие буквы.
Для поиска подстроки в строке мы можем воспользоваться методом indexOf():
Var str = "методы и свойства для работы со строками в javaScript"; document.write(str.indexOf("работы"));
данный метод принимает в качестве аргумента подстроку которую мы хотим найти в строке и если он ее находит, то возвращается позиция с которой было найдено совпадение. Если данной подстроки не содержится в строке, то:
Var str = "методы и свойства для работы со строками в javaScript"; document.write(str.indexOf("работа"));
нам вернется значение -1. Пример:
Var str = "методы и свойства для работы со строками в javaScript", sub = "работа"; function indexOf(str, substr) { if (str.indexOf(substr) === -1) { return "Данной подстроки ""+substr+"" не содержится в строке ""+str+"""; } else{ index =str.indexOf(substr) return "Подстрока ""+substr+"" найдена в позиции "+index; } } document.write(indexOf(str,sub));
здесь мы записали небольшую функцию indexOf(str,sub) которая в качестве аргументов принимает строку(str) и подстроку(sub) и с помощью метода indexOf() проверяет наличие подстроки в строке и возвращает сообщение об результате. Отмечу что метод indexOf() возвращает позицию подстроки относительно начала строки, то есть от нулевого индекса.
Если мы захотим найти позицию подстроки относительно конца, тогда можно воспользоваться функцией lastIndexOf().
Метод trim() позволяет убрать пробелы из начала и конца строки, допустим у нас есть такая строка:
Var str = " методы и свойства для работы со строками в javaScript "; console.log(str);
и мы хотим убрать пробелы в начале и конце:
Console.log(str.trim());
после того как мы воспользуемся методом trim() пробелы из конца и начала строки будут успешно удалены.
Ну вот в принципе и все что я вам хотел рассказать про работу со строками в JavaScript, конечно же есть еще методы конкатенации и сравнения строк, но мы их рассматривать не будем, так как эти методы легко заменяются стандартными операторами.
Я поздравляю вас с наступающим новым годом, желаю счатья, здоровья, успехов, любви и конечно же удачи! Пока!
Похожие статьи
