Методы строк js. Методы javascript для работы со строками
, очень часто приходится лазить по интернету в поисках информации о синтаксисе и параметрах для методов, работающих со строками.

Содержание
- Конвертирование в String
- Разделение строки в подстроки
- Получение длины строки
- Поиск подстроки в строке
- Замена подстроки
- Получить символ по заданной позиции в строке
- Соединение строк
- Извлечение подстроки
- Перевод строки в верхний или нижний регистр
- Pattern Matching
- Сравнение двух строк для сортировки
- Описание строковых переменных
- Строка - это всегда массив
- Основные строковые функции
- Классические строчные функции
- Строки и регулярные выражения
- Примеры регулярных выражений
- Объектно-ориентированные строки
- Сравнение строк
- Синтаксис строчных переменных
- Поговорим немного о специальных символах
- Запасаемся тяжелым арсеналом методов и свойств
- Займемся конвертацией
Когда пишешь JavaScript
Я прочитал множество статей по работе со строками. В данном посте будет показаны примеры и краткие описания наиболее распространенных методов по работе со строками. Я попытался поставить самые частые методы в верхней части для быстрого ознакомления.
Конечно, большинство опытных разработчиков уже достаточно знакомы со многими из методов, но я думаю, что это хороший список для начинающих, чтобы понимать спектр методов, которые могут помочь выполнить сложные операции простыми средствами.
Конвертирование в String
Вы можете конвертировать число, булево выражение или объект в строку:
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" методы, то таких проблем не будет.
Pattern Matching
Соответствие по шаблону в строке может быть использовано с помощью 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. Методы работы со строками здесь имеют свой стиль, но в обычном применении это просто синтаксис в пределах простой семантики: поиск, замена, вставка, извлечение, контенкация, смена регистра
Описание строковых переменных
Для объявления строки используется конструкция 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 работа со строками представлена широким ассортиментом функций. Но это не является веским основанием для использования их в первозданном виде. Синтаксис и качество функций безупречны, но это универсальное решение.
Любое применение строчных функций предполагает обработку реального смысла, который определяется данными, областью применения, конкретным назначением алгоритма.

Идеальное решение всегда состоит в том, чтобы интерпретировать данные по их смыслу.
Представляя каждый параметр в виде объекта, можно сформулировать функции для работы с ним. Всегда речь идет об обработке символов: числа или строки - это конкретным образом организованные последовательности символов.
Есть общие алгоритмы, а есть частные. Например, фамилия или номер дома - это строки, но если в первом случае допустимы только русские буквы, то во втором случае допустимы цифры, русские буквы и могут встречаться дефисы или индексы через наклонную черту. Индексы могут быть буквенными или цифровыми. Дом может иметь корпуса.
Все ситуации не всегда можно предусмотреть. Это важный момент в программировании. Редкий алгоритм не требует доработки, а в большинстве случаев приходится систематически корректировать функционал.
Формализация обрабатываемой строчной информации в виде объекта улучшает читабельность кода, позволяет вывести его на уровень смысловой обработки. Это другая степень функциональности и значительно лучшее качество кода при большей надежности разработанного алгоритма.
И методах работы с ними.
Строки - это просто группы символов, такие как " JavaScript ", " Hello world! ", " " или даже " 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
Один из самых широко используемых встроенных методов это "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
Также существует метод "lastIndexOf", который возвращает последнее вхождение символа или комбинации. Он действует противоположно "indexOf". Команда
Var b = "I am a student.";
document.write(b.lastIndexOf("t"));
Возвратит 13 , потому что это индекс последней "t" в строке.
CharAt
Метод "charAt" возвращает символ, стоящий на указанной позиции. Например, когда Вы вводите
Var b = "I am a student.";
document.write(b.charAt(5));
В результате получается " a ", так как это символ на шестой позиции (помните, что индекс первого символа начинается с 0).
Length
Метод "length" возвращает длину строки.
Var b = "I am a student.";
document.write(b.length);
Возвратит "15". Длина строки на 1 больше, чем индекс последнего символа.
Split
" 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
Также есть метод "substr", работающий немного по-другому. В качестве второго аргумента он использует не номер индекса, а количество символов. То есть
Document.write(a.substr(4, 8));
Возвращает 8 символов, начиная от символа с индексом 4 ("o"), то есть в результате получаем: " o world! "
ToLowerCase и toUpperCase
Наконец, 2 метода, которые иногда могут Вам пригодиться: "toLowerCase" переводит всю строку в нижний регистр, а "toUpperCase" - в верхний.
Var b = "I am a student.";
document.write(b.toUpperCase());
В результате получим " I AM A STUDENT. ".
Здравствуйте! В этом уроке рассмотрим как в 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.
Приветствую всех, кто основательно решил изучить прототипно-ориентированный язык. В прошлый я рассказал вам про , а сегодня мы будем разбирать строки JavaScript-а. Так как в этом языке все текстовые элементы являются строками (нет отдельного формата для символов), то вы можете сами догадаться, что этот раздел занимает значимую часть в изучении синтаксиса js.
Именно поэтому в этой публикации я расскажу вам, как создаются строчные элементы, какие методы и свойства для них предусмотрены, как правильно конвертировать строки, например, преобразовывать в число, каким образом можно извлечь нужную подстроку и многое другое. В добавок к этому я прикреплю примеры программного кода. А теперь вперед за дело!
Синтаксис строчных переменных
В языке js все переменные объявляются при помощи ключевого слова var, а далее в зависимости от формата оформления параметров определяется тип объявленной переменной. Как вы помните из , в JavaScript-е отсутствует строгая типизация. Именно поэтому в коде и обстоит вот такая ситуация.
При инициализации переменных значения могут быть обрамлены в двойные, одинарные, а начиная с 2015 года и в скошенные одинарные кавычки. Ниже я прикрепил примеры каждого способа объявления строк.
Хочу уделить особое внимание третьему способу. Он обладает рядом преимуществ.
С его помощью можно спокойно осуществлять перенос строки и это будет выглядеть вот так:
alert (`несколько
Переношу
А еще третий способ позволяет использовать конструкцию ${...}. Такой инструмент нужен для вставки интерполяции. Не пугайтесь, сейчас расскажу, что это такое.
Благодаря ${...} в строки можно вставлять не только значения переменных, а еще и выполнять с ними арифметические и логические операции, вызывать методы, функции и т.д. Все это называется одним терминов - интерполяция. Ознакомьтесь с примером реализации данного подхода.
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
. Он используется таким образом:
var string = "Единороги";
alert (string.length);
В ответе будет выведено число 9. Также данное свойство можно применять и к самим значениям:
"Единороги".length;
Результат не изменится.
CharAt ()
Этот метод позволяет вытащить определенный символ из текста. Напоминаю, что нумерация начинается с нуля, поэтому чтобы вытащить первый символ из строки, необходимо прописать вот такие команды:
var string = "Единороги";
alert (string.charAt (0));.
Однако полученный результат не будет символьного типа, он все еще будет считаться строкой, состоящей из одной буквы.
От toLowerCase () к toUpperCase ()
Данные методы управляют регистром символов. При написании кода "Контент".
toUpperCase ()
Все слово будет отображено заглавными буквами.
Для противоположного эффекта стоит использовать "Контент". toLowerCase ()
IndexOf ()
Востребованное и нужное средство для поиска подстроки. В качестве аргумента нужно вписать слово или фразу, которую необходимо найти, а метод возвращает позицию найденного элемента. Если же искомый текст не был найден, пользователю вернется "-1".
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 предусмотрено только три вида преобразования типов объектов:
- Числовое;
- Строковое;
- Логическое.
В текущей публикации я расскажу про 2 из них, так как знание о них нужнее для работы со строками.
Числовое преобразование
Чтобы значение элемента явно преобразовать к числовому виду, можно использовать Number (value)
Есть и более короткое выражение: +"999"
var a = Number ("999");
Строковая конвертация
Выполняется функцией alert
, а также явным вызовом String (text)
Рубрика: Новичкам и программирование