Методы javascript для работы со строками. Задачи на функции работы со строками в JavaScript Функции работы со строками javascript

Приветствую всех, кто основательно решил изучить прототипно-ориентированный язык. В прошлый я рассказал вам про , а сегодня мы будем разбирать строки JavaScript-а. Так как в этом языке все текстовые элементы являются строками (нет отдельного формата для символов), то вы можете сами догадаться, что этот раздел занимает значимую часть в изучении синтаксиса js.

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

Синтаксис строчных переменных

В языке js все переменные объявляются при помощи ключевого слова var, а далее в зависимости от формата оформления параметров определяется тип объявленной переменной. Как вы помните из , в JavaScript-е отсутствует строгая типизация. Именно поэтому в коде и обстоит вот такая ситуация.

При инициализации переменных значения могут быть обрамлены в двойные, одинарные, а начиная с 2015 года и в скошенные одинарные кавычки. Ниже я прикрепил примеры каждого способа объявления строк.

Хочу уделить особое внимание третьему способу. Он обладает рядом преимуществ.

С его помощью можно спокойно осуществлять перенос строки и это будет выглядеть вот так:

alert (`несколько

переношу

А еще третий способ позволяет использовать конструкцию ${…}. Такой инструмент нужен для вставки интерполяции. Не пугайтесь, сейчас расскажу, что это такое.

Благодаря ${…} в строки можно вставлять не только значения переменных, а еще и выполнять с ними арифметические и логические операции, вызывать методы, функции и т.д. Все это называется одним терминов – интерполяция. Ознакомьтесь с примером реализации данного подхода.

1 2 3

var pen = 3; var pencil = 1; alert(`${pen} + ${pencil*5} = ${pen + pencil}`);

var pen = 3; var pencil = 1; alert(`${pen} + ${pencil*5} = ${pen + pencil}`);

В результате на экран выведется выражение: «3 + 1*5 = 8».

Что касается первых двух способов объявления строк, то в них разницы никакой нет.

Поговорим немного о специальных символах

Во многих языках программирования есть специальные символы, которые помогают управлять текстом в строках. Самый известный среди них – это перенос строки (\n) .

Все аналогичные инструменты изначально начинаются с обратного слеша (\) и после идут буквы английского алфавита.

Ниже я прикрепил небольшую табличку, в которой перечислены некоторые специальные символы.

Запасаемся тяжелым арсеналом методов и свойств

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

Length

Начну с самого популярного свойства, которое помогает узнать длину значений строчных переменных. Это length . Он используется таким образом:

var string = «Единороги»;

alert (string.length);

В ответе будет выведено число 9. Также данное свойство можно применять и к самим значениям:

«Единороги».length;

Результат не изменится.

charAt ()

Этот метод позволяет вытащить определенный символ из текста. Напоминаю, что нумерация начинается с нуля, поэтому чтобы вытащить первый символ из строки, необходимо прописать вот такие команды:

var string = «Единороги»;

alert (string.charAt (0));.

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

От toLowerCase () к toUpperCase ()

Данные методы управляют регистром символов. При написании кода «Контент».

toUpperCase () все слово будет отображено заглавными буквами.

Для противоположного эффекта стоит использовать «Контент». toLowerCase () .

indexOf ()

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

1 2 3 4

var text = "Организовать поиск цветов!"; alert(text.indexOf("цвет")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18

var text = "Организовать поиск цветов!"; alert(text.indexOf("цвет")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18

Заметьте, lastIndexOf () выполняет те же действия, только поиск осуществляется с конца предложения.

Извлечение подстрок

Для этого действия в js было создано три примерно одинаковых метода.

Разберем сначала substring (start, end) и slice (start, end) . Работают одинаково. Первый аргумент определяет начальную позицию, с которой будет начинаться извлечение, а второй отвечает за конечный пункт остановки. В обоих методах строка извлекается, не включая символ, который расположен на позиции end.

var text = "Атмосфера"; alert(text.substring(4)); // выведет «сфера» alert(text.substring(2, 5)); //отобразит «мос» alert(text.slice(2, 5)); //отобразит «мос»

А теперь разберем третий метод, который называется substr () . В нем также нужно прописывать 2 аргумента: start и length .

Первый указывает начальную позицию, а второй – количество символов, которые нужно извлечь. Чтобы отследить разницу между этими тремя инструментами, я воспользовался прошлым примером.

var text = «Атмосфера»;

alert (text.substr (2, 5)); //отобразит «мосфе»

Используя перечисленные средства взятия подстрок, можно удалить ненужные символы из новых строчных элементов, с которыми далее работает программа.

Replase ()

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

В этом примере заменится подстрока только в первом слове.

var text = "Атмосфера Атмосфера"; var newText = text.replace("Атмо","Страто") alert(newText) // Результат: Стратосфера Атмостфера

А в этой программной реализации из-за флага регулярного выражения “g” будет выполнена глобальная замена.

var text = "Атмосфера Атмосфера"; var newText = text.replace(/Атмо/g,"Страто") alert(newText) // Результат: Стратосфера Стратосфера

Займемся конвертацией

В JavaScript предусмотрено только три вида преобразования типов объектов:

1. Числовое;
2. Строковое;
3. Логическое.

В текущей публикации я расскажу про 2 из них, так как знание о них нужнее для работы со строками.

Числовое преобразование

Чтобы значение элемента явно преобразовать к числовому виду, можно использовать Number (value) .

Есть и более короткое выражение: +«999» .

var a = Number («999»);

Строковая конвертация

Выполняется функцией alert , а также явным вызовом String (text) .

Как семантические «каркасы» использования функций и конструкций для обработки строк представляют особенный интерес для программирования процессов обработки информации по её смысловому содержанию. На языке JavaScript функции работы со строками можно комбинировать в собственные смысловые конструкции, упрощая код и формализуя предметную область задачи.

В классическом варианте обработка информации - это, прежде всего, строковые функции. Каждая функция и конструкция языка имеет свои особенности в синтаксисе и семантике JavaScript. Методы работы со строками здесь имеют свой стиль, но в обычном применении это просто синтаксис в пределах простой семантики: поиск, замена, вставка, извлечение, контенкация, смена регистра...

Описание строковых переменных

Для объявления строки используется конструкция var. Можно сразу задать ее значение или формировать его в ходе исполнения алгоритма. Для строки можно использовать одинарные или двойные кавычки. Если в ней должна быть кавычка, её необходимо экранировать символом «\».

Строка, обозначенная требует экранирования внутренних двойных кавычек. Аналогично та, что обозначена одинарными, критична к наличию внутри одинарных кавычек.

В данном примере в строке «str_dbl» перечислены полезные специальные символы, которые можно использовать в строке. При этом сам символ «\» экранирован.

Строка - это всегда массив

Работа JavaScript со строками может выполняться множеством способов. Синтаксис языка предоставляет много вариантов. В первую очередь никогда не следует забывать, что (в контексте сделанных описаний):

• str_isV => «V»;
• str_chr => «"»;
• str_dbl => «a».

То есть символы строки доступны как элементы массива, при этом каждый специальный символ - это один символ. Экранирование - это элемент синтакиса. В реальную строку никакой «экран» не помещается.

Использование функции charAt() дает аналогичный эффект:

• str_isV.charAt(3) => «V»;
• str_chr.charAt(1) => «"»;
• str_dbl.charAt(5) => «a».

Программист может использовать любой вариант.

Основные строковые функции

В JavaScript выполнена несколько иначе, чем в других языках. К имени переменной (или непосредственно строки) через точку записывается имя функции. Обычно строчные функции именуют методами в стиле синтаксиса языка, но первое слово привычнее.

Самый важный метод строки (правильнее - свойство) - её длина.

• var xStr = str_isV.length + "/" + str_chr.length + "/" + str_dbl.length.

Результат: 11/12/175 по строкам приведенного выше описания.

Самая важная строчная пара функций - разделение строки на массив элементов и слияние массива в строку:

• split(s [, l]);
• join(s).

В первом случае строка разбивается по символу-разделителю «s» на массив элементов, в котором количество элементов не превышает значения «l». Если количество не задано, то разбивается вся строка.

Во втором случае массив элементов сливается в одну строку через заданный разделитель.

Примечательная особенность данной пары: разбиение можно производить по одному разделителю, а слияние - по другому. В этом контексте в JavaScript работа со строками может быть «выведена за пределы» синтаксиса языка.

Классические строчные функции

Обычные функции обработки строк:

• поиск;
• выборка;
• замена;
• преобразование.

Представлены методами: indexOf(), lastIndexOf(), toLowerCase(), toUpperCase(), concan(), charCodeAt() и другими.

В JavaScript работа со строками представлена большим множеством функций, но они либо дублируют друг друга, либо оставлены для старых алгоритмов и совместимости.

Например, использование метода concat() допустимо, но проще написать:

• str = str1 + str2 + str3;

Применение функции charAt() тоже имеет смысл, а вот применение charCodeAt() имеет реальное практическое значение. Аналогично, для JavaScript перенос строки имеет особенный смысл: в контексте вывода на экран, например, в сообщении alert() - это «\n», в конструкции формирования контента страницы это «
». В первом случае это просто символ, а во втором - строка символов.

Строки и регулярные выражения

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

Метод match находит, а replace заменяет найденное совпадение нужным значением. Регулярные выражения реализованы в JavaScript на высоком уровне, по сути своей, являются сложными, а ввиду специфики применения переносят центр тяжести с сервера в браузер клиента.

При применении методов match, search и replace следует не только уделить должное внимание тестированию на всём спектре допустимых значений исходных параметров и искомых строк, но и оценить нагрузку на браузер.

Примеры регулярных выражений

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

Здесь представлены функции, которые проверяют, ввод содержит целое число (schInt) или число вещественное (schReal). Следующий пример показывает, насколько эффективно обрабатывать строки, проверяя их на наличие только допустимых символов: schText - только текст, schMail - правильный адрес электронной почты.

Очень важно иметь в виду, что в JavaScript символы и строки требуют повышенного внимания к локали, особенно когда нужно работать с кириллицей. Во многих случаях целесообразно указывать реальные коды символов, нежели их значения. Русских букв это касается в первую очередь.

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

Объектно-ориентированные строки

В JavaScript работа со строками представлена широким ассортиментом функций. Но это не является веским основанием для использования их в первозданном виде. Синтаксис и качество функций безупречны, но это универсальное решение.

Любое применение строчных функций предполагает обработку реального смысла, который определяется данными, областью применения, конкретным назначением алгоритма.

Идеальное решение всегда состоит в том, чтобы интерпретировать данные по их смыслу.

Представляя каждый параметр в виде объекта, можно сформулировать функции для работы с ним. Всегда речь идет об обработке символов: числа или строки - это конкретным образом организованные последовательности символов.

Есть общие алгоритмы, а есть частные. Например, фамилия или номер дома - это строки, но если в первом случае допустимы только русские буквы, то во втором случае допустимы цифры, русские буквы и могут встречаться дефисы или индексы через наклонную черту. Индексы могут быть буквенными или цифровыми. Дом может иметь корпуса.

Все ситуации не всегда можно предусмотреть. Это важный момент в программировании. Редкий алгоритм не требует доработки, а в большинстве случаев приходится систематически корректировать функционал.

Формализация обрабатываемой строчной информации в виде объекта улучшает читабельность кода, позволяет вывести его на уровень смысловой обработки. Это другая степень функциональности и значительно лучшее качество кода при большей надежности разработанного алгоритма.

Приветствую всех читателей блога сайт В этой статье мы рассмотрим встроенный объект 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 не изменяет исходного значения. Параметры задают позиции начального и конечного знака.

Тип данных строка (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"

Здравствуйте! В этом уроке рассмотрим как в JavaScript можно создать строку и функции для работы со строками. В принципе в JavaScript любая текстовая переменная является строкой, поскольку JavaScript является не строго типизированным языком программирования (о типах данных читайте ). И также для работы со строками используется класс String:

Var name1 = "Tommy";

Так и использовать конструктор String:

Var name1 = new String("Tommy");

В основном используется 1-ый способ наверное потому что он более краток.

Класс для работы со строками String имеет в своем арсенале довольно большой набор свойств и функций, с помощью которых вы можете совершать различные манипуляции со строками.

Длина строки

Свойство length позволяет задавать а длину строки. Данное свойство возвращает число:

Var hello1 = "привет мир"; document.write("В строке "" + hello + "" " + hello1.length + " символов");

Поиск в строке

Для того чтобы найти в строке некоторую подстроку применяются функции indexOf() (возвращает индекс первого вхождения подстроки) и lastIndexOf() (возвращает индекс последнего вхождения подстроки). Эти функции принимают два аргумента:

• Подстроку, которую собственно и надо найти
• Необязательный аргумент, который показывает, с какого символа надо проводить поиск подстроки в строке

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

Var str1 = "Привет Вася!"; var podstr = "Петя"; if(str.indexOf(podstr) == -1){ document.write("Подстрока не найдена."); } else { document.write("Подстрока найдена."); }

В примере будет выведено сообщение «Подстрока не найдена», поскольку строка «Петя» не содержится в строке «Привет Вася!».

Функции includes, startsWith, endsWith

Более современный метод str.includes(substr, pos) возвращает true, если в строке str есть подстрока substr, либо false, если нет.

Это - правильный выбор, если нам необходимо проверить, есть ли совпадение, но позиция не нужна:

Alert("Widget with id".includes("Widget")); // true alert("Hello".includes("Bye")); // false

Необязательный второй аргумент str.includes позволяет начать поиск с определённой позиции:

Alert("Midget".includes("id")); // true alert("Midget".includes("id", 3)); // false, поиск начат с позиции 3

Методы str.startsWith и str.endsWith проверяют, соответственно, начинается ли и заканчивается ли строка определённой строкой:

Alert("Widget".startsWith("Wid")); // true, "Wid" - начало "Widget" alert("Widget".endsWith("get")); // true, "get" - окончание "Widget"

Выбор подстроки

Для вырезания из строки подстроки, используются такие функции как substr() и substring().

Функция substring() принимает 2 аргумента:

• стартовая позиция символа в строке, начиная с которого будет произведена обрезка строки
• конечная позиция до которой надо обрезать строку

var hello1 = "привет мир. До свидания мир"; var world1 = hello1.substring(7, 10); //с 7-го по 10-й индекс document.write(world1); //мир

Функция substr() также в качестве 1-го параметра принимает стартовый индекс подстроки, а вот в качестве 2-го — длину подстроки:

Var hello1 = "привет мир. До свидания мир"; var bye1 = hello1.substr(12, 2); document.write(bye1);//До

Да и если 2-ой параметр не указывать, то строка будет обрезана до конца:

Var hello1 = "привет мир. До свидания мир"; var bye1 = hello1.substr(12); document.write(bye1); //пока мир

Управление регистром букв

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

Var hello1 = "Привет Джим"; document.write(hello1.toLowerCase() + "
"); //привет джим document.write(hello1.toUpperCase() + "
"); //ПРИВЕТ ДЖИМ

Получение символа по его индексу

Для того чтобы найти определенный символ в строке по его индексу, применяются функции charAt() и charCodeAt(). Обе эти функции в качестве аргумента принимают индекс символа:

Var hello1 = "Привет Джим"; document.write(hello1.charAt(3) + "
"); //в document.write(hello1.charCodeAt(3) + "
"); //1080

Но вот только если в качестве результата своей работы функция charAt() вернет сам символ, то функция charCodeAt() вернет числовой Юникод код этого символа.

Удаление пробелов

Для удаления пробелов в стоке используется функция trim():

Var hello1 = " Привет Джим "; var beforeLen = hello1.length; hello1 = hello1.trim(); var afterLen = hello1.length; document.write("Длина строки до: " + beforeLen + "
"); //15 document.write("Длина строки после: " + afterLen + "
"); //10

Объединение строк

Функция concat() позволяет объединить 2 строки:

Var hello1 = "Привет "; var world1 = "Вася"; hello1 = hello1.concat(world1); document.write(hello); //Привет Вася

Замена подстроки

Функция replace() позволяет заменить одну подстроку на другую:

Var hello1 = "Добрый день"; hello1 = hello1.replace("день", "вечер"); document.write(hello1); //Добрый вечер

Первый аргумент функции указывает, какую именно подстроку надо заменить, а 2-ой аргумент — на какую собственно подстроку надо заменить.

Разделение строки на массив

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

Var mes = "Сегодня была прекрасная погода"; var stringArr = mes.split(" "); for(var str1 in stringArr) document.write(stringArr + "
");

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

Также при сравнении строк следует учитывать регистр букв. Большая буква меньше маленькой, а буква ё вне алфавита вообще.

ЗАДАНИЯ

Замена регистра последней буквы в строке

Напишите функцию lastLetterStr(str), которая будет заменять регистр последней буквы, делая ее большой.

Проверка на спам

Напишите функцию provSpam(str), которая будет проверять строку на наличие подстрок: «spam», «sex», «xxx». И возвращать true, если есть данные подстроки и false в противном случае.

Найти число

Напишите функцию extrNum(str), которая из строки получает число, если строка содержит число и возвращать должна функция число. Например есть строка «120грн» нужно вернуть из строки 120.

И на закрепление смотрите видео по работе со строками в JavaScript.