Метод String toUpperCase JavaScript и TypeScript возврат значения строки в верхнем регистре


Содержание материала:

Изменение регистра текста с помощью Javascript

Если у вас возникла необходимость используя Javascript изменить регистр написания текста сделать весь текст маленькими буквами или наоборот, сделать весь текст большими буквами, то можно воспользоваться следующими свойствами текстовых переменных:

Пример изменения регистра (переход к заглавным буквам), используя toUpperCase

выведет сообщение с текстом «HELLO, WORLD!».

Пример изменения регистра (переход к маленьким буквам), используя toLowerCase

выведет сообщение с текстом «hello, world!».

Строки

Строки и объект String

Для создания строк мы можем как напрямую присваивать переменной строку:

Для работы со строками предназначен объект String , поэтому также можно использовать конструктор String:

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

Объект String имеет большой набор свойств и методов, с помощью которых мы можем манипулировать строками.

Свойство length указывает на длину строки:

Метод repeat() позволяет создать строку путем многократного повторения другой строки. Количество повторов передается в качестве аргумента:

Шаблоны строк

Шаблоны строк позволяют вставлять в строку различные значения. Для этого строки заключаются в косые кавычки:

Для вставки значения в строку оно заключается в фигурные скобки, перед которыми ставится знак доллара.

Также вместо скалярных значений могут добавляться свойства сложных объектов или результаты выражений:

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

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

Подстроку, которую надо найти

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

Оба этих метода возвращают индекс символа, с которого в строке начинается подстрока. Если подстрока не найдена, то возвращается число -1.

Еще один метод — includes() возвращает true, если строка содержит определенную подстроку.

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

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

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

Метод substring() принимает два параметра:

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

индекс, до которого надо обрезать строку

Метод substr() также в качестве первого параметра принимает начальный индекс подстроки, а в качестве второго — длину вырезаемой подстроки:

Если второй параметр не указывается, то обрезается вся остальная часть строки:

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

Для изменения регистра имеются методы toLowerCase() (для перевода в нижний регистр) и toUpperCase() (для перевода в верхний регистр).

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

Чтобы получить определенный символ в строке по индексу, можно применять методы charAt() и charCodeAt() . Оба этих метода в качестве параметра принимают индекс символа:

Но если в качестве результата метод charAt() возвращает сам символ, то метод charCodeAt() возвращает числовой код этого символа.

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

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

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

Метод concat() объединяет две строки:

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

Метод replace() заменяет первое вхождение одной подстроки на другую:

Первый параметр метода указывает, какую подстроку надо заменить, а второй параметр — на какую подстроку надо заменить.

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

Метод split() разбивает строку на массив подстрок по определенному разделителю. В качестве разделителя используется строка, которая передается в метод:

Проверка начала и окончания строки

Метод startsWith() возвращает true, если строка начинается с определенной подстроки. А метод endsWith() возвращает true, если строка оканчивается на определенную подстроку.

При этом играет роль регистр символов, и из примера выше мы видим, что «let» не эквивалентно «Let».

Дополнительный второй параметр позволяет указать индекс (для startsWith — индекс с начала, а для endsWith — индекс с конца строки), относительно которого будет производиться сравнение:

Методы объекта String

У примитивных значений или литералов, вроде строки «Иван Петров», не может быть свойств или методов (потому что они не объекты). Однако, в JavaScript все устроено так, что даже у примитивных значений доступны свои методы и свойства, потому что JavaScript интерпретирует любые значения, как объекты с выполняемыми методами и свойствами.

Встроенные методы и свойства строк помогают работать с этими самыми строками.

Длина строки

При помощи свойства length можно узнать длину строки:

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

Метод indexOf() возвращает индекс (позицию) первого вхождения заданного текста в строке:

Метод lastIndexOf() возвращает индекс последнего вхождения заданного текста в строке:

Если подстрока не найдена, то оба метода, indexOf() и lastIndexOf(), вернут -1.

Внимание! JavaScript считает позицию от нуля. 0 это первый символ в строке, 1 — второй, 2 — третий и т.д.

Оба метода в качестве второго параметра принимают начальную позицию поиска:

Кроме этого, для поиска подстроки существует метод search(), который возвращает позицию найденной подстроки:

Вероятно вы заметили, что два метода, indexOf() и search(), очень похожи друг на друга. Они принимают одинаковые аргументы (параметры) и возвращают одинаковые значения. Получается эти методы одно и то же?

На самом деле у этих методов есть ряд существенных отличий:

  • Метод search() не принимает второй, связанный с позицией, параметр.
  • Метод indexOf() не принимает «усиленные» поисковые значения (регулярные выражения).

Подробнее о регулярных выражениях будет рассказано в следующих главах этого учебника.

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

Существует три метода, позволяющих извлечь часть строки:

  • slice(начало, конец)
  • substring(начало, конец)
  • substr(начало, длина)

Метод slice()

Метод slice() извлекает часть строки и возвращает извлеченную часть в новой строке.

Этот метод принимает 2 параметра: начальный и конечный индекс (позицию).

В следующем примере вырезается часть строки, начиная с позиции 7 и заканчивая позицией 13:

В результате в переменной res будет строка «Banana».

Если в параметре заданы отрицательные значения, то позиция будет отсчитываться с конца строки.

В следующем примере вырезается часть строки с позиции -12 до позицией -6:

В результате в переменной res будет строка «Banana».

Если второй параметр не указан, то вырезается вся подстрока, начиная с заданной позиции. Задавать также можно положительные и отрицательные значения.

Внимание! Отрицательные значения параметров не работают в Internet Explorer 8 и более ранних версий.

Метод substring()

Метод substring() похож на метод slice(). Разница между ними в том, что метод substring() не может принимать в качестве параметров отрицательные значения.

В результате в переменной res будет строка «Banana».

Если второй параметр не указан, то метод substring() вырежет всю подстроку, начиная с заданной позиции.

Метод substr()

Метод substr() аналогичен методу slice(). Разница между ними в том, что вторым параметром в методе substr() задается длина извлекаемой подстроки.

В результате в переменной res будет строка «Banana».

Если в первом параметре задано отрицательное значение, то позиция будет отсчитываться с конца строки.

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

Если второй параметр не указан, то метод substr() вырежет всю подстроку, начиная с заданной позиции.

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

Метод replace() ищет в строке заданную подстроку и заменяет ее другим значением:

В результате в переменной n будет строка «Посетите MSiter!».

Метод replace() не изменяет исходную строку. Он возвращает новую строку.

По умолчанию, метод replace() заменяет первую совпавшую подстроку:

В результате в переменной n будет строка «Посетите MSiter и Microsoft!».

По умолчанию, метод replace() регистрозависим. Поэтому запись подстроки MICROSOFT (большими буквами) в следующем примере не сработает:

Чтобы заменить подстроку независимо от регистра букв, используйте регулярное выражение с флагом /i:

Обратите внимание, что регулярные выражения записываются без кавычек.

Чтобы заменить все найденные совпадения, используйте регулярное выражение с флагом /g:

Изменение регистра букв

Метод toUpperCase() позволяет преобразовать строку в верхний регистр:

Метод toLowerCase() позволяет преобразовать строку в нижний регистр:

Метод concat()

Метод concat() объединяет две и больше строк:

Метод concat() может использоваться вместо оператора +. Следующий пример делает то же самое, что и предыдущий:

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

Извлечение символа из строки

Существует 2 безопасных метода для извлечения символа из строки:

Метод charAt()

Метод charAt() возвращает символ строки, расположенный в заданной позиции:

Метод charCodeAt()

Метод charCodeAt() возвращает код символа строки, расположенного в заданной позиции:

Обращение к строке как к массиву небезопасно

Иногда можно увидеть следующий код, в котором к строке обращаются как к массиву:

Этого никогда не следует делать, так как это небезопасно и может привести к непредсказуемым результатам:

  • Подобное работает не во всех браузерах (не работает в IE5, IE6, IE7)
  • Выглядит так, будто строка это массив (но на самом деле это не так)
  • Выражение str[0] = «H» не приводит к ошибке (но не работает)

Если вам нужно прочитать строку как массив, то сначала преобразуйте ее в массив.

Преобразование строки в массив

При помощи метода split() строку можно преобразовать в массив:

Если разделитель не указан, то будет возвращен массив, который состоит из одного элемента — исходной строки, расположенной по индексу [0].

Если в качестве разделителя указана пустая строка «», то будет возвращен массив, в котором строка разделена посимвольно:

JavaScript: методы работы со строками

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

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

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

Конвертирование в String

Вы можете конвертировать число, булево выражение или объект в строку:

Вы можете сделать это так же с помощью String():

Если вы не уверены, что значение не является null или undefined, вы можете использовать String(), которая всегда возвращает строку, независимо от типа значения.

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

Чтобы разделить строки в массив подстрок, вы можете использовать метод split():

Как видно в последней строке, второй параметр функции — это лимит количества элементов, которое будет в итоговом массиве.

Получение длины строки

Чтобы найти, сколько символов в строки, мы используем свойство length:

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

Есть два метода для поиска подстроки:

Использование indexOf():

indexOf() метод начинает поиск подстроки с начала строки, и возвращает позицию начала первого вхождения подстроки. В данном случае — 7 позиция.

Использование lastIndexOf():

Метод возвращает начальную позицию последнего вхождения подстроки в строку.

В обоих методах, если подстрока не найдена, возвращается значение -1, и оба принимают необязательный второй аргумент, указывающий положение в строке, где вы хотите начать поиск. Таким образом, если второй аргумент «5», indexOf() начинает поиск с 5 символа, игнорируя символы 0-4, в то время как lastIndexOf() начинает поиск с символа 5 и идет в обратном направлении, игнорируя символы 6 и дальше.

Топ-пост этого месяца:  Что такое Laravel пакеты

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

Чтобы заменить вхождение подстроки в строке на другую подстроку, вы можете использовать replace():

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

Чтобы заменить все вхождения, нужно использовать регулярное выражение с глобальным флагом:

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

Получить символ по заданной позиции в строке

Получить символ мы можем с помощью функции charAt():

Как часто бывает в JavaScript, первая позиция в строке начинается с 0, а не с 1.

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

Заметьте, что код для символа «F» (11 позиция) другой, нежели у символа «f» (позиция 7).

Соединение строк

В большинстве случаем, чтобы соединить строки, можно использовать оператор «+». Но так же можно использовать метод concat():

Таким способом мы можем соединить множество строк в одну в том порядке, в котором они записаны:

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

Есть 3 способа получения строки из части другой строки:

Используя slice():

Используя substring():

В обеих функция первый параметр — символ, с которого начинает подстрока (начиная с 0 позиции) и второй аргумент (необязательный) — позиция символа, до которого возвращается подстрока. В примере (5, 10) возвращается строка между позицией 5 и 9.

Используя substr():

Перевод строки в верхний или нижний регистр.

Другие 2 переводят строку в нижний регистр:

Лучше использовать «locale» методы, т.к. в разных местах, например, в Турции отображение регистров работает не совсем так, как мы привыкли и поэтому результат может быть тот, который мы хотели. Если использовать «locale» методы, то таких проблем не будет.

Pattern Matching

Соответствие по шаблону в строке может быть использовано с помощью 2-х методов, которые работают по-разному.

Метод match() применяется к строке и он принимает в качестве параметра регулярное выражение:

Метод exec() применяется к объекту регулярного выражения и принимает в качестве параметра строку:

В обоих методах возвращается лишь первое совпадение. Если совпадений не было — возвращается null.

Так же можно использовать метод search(), который принимает регулярное выражение и возвращает позицию первого совпадения по шаблону:

Если совпадений не было — возращается «-1«.

Сравнение двух строк для сортировки

Вы можете сравнить 2 строки, чтобы определить, какая их них идет первая по алфавиту. Для этого воспользуемся методом localeCompare(), который возвращает 3 возможных значения:

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

Для проверки возвращаемого значения лучше использовать if ( result Автор статьи: Alex. Категория: JavaScript
Дата публикации: 19.03.2013

JavaScript Строковые методы

Строковые методы помогают работать со строками.

Строковые методы и свойства

Примитивные значения, такие как «John Doe», не могут иметь свойств или методов (поскольку они не являются объектами).

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

Длина строки

Свойство length возвращает длину строки:

Пример

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

Метод IndexOf () возвращает индекс (положение) первого вхождения заданного текста в строку:

Пример

JavaScript подсчитывает позиции с нуля.
0 — первая позиция в строке, 1 — вторая, 2 — третья.

Метод LastIndexOf () возвращает индекс последнего вхождения заданного текста в строке:

Пример

Оба IndexOf () и LastIndexOf () return-1, если текст не найден.

Пример

Оба метода принимают второй параметр в качестве начальной позиции для поиска:

Пример

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

Метод Search () ищет строку для заданного значения и возвращает позицию совпадения:

Пример

Вы заметили?

Два метода, IndexOf () и Search (), равны?

Они принимают одни и те же аргументы (параметры) и возвращают одно и то же значение?

Два метода не равны. Вот различия:

  • Метод Search () не может принимать второй аргумент начального положения.
  • Метод IndexOf () не может принимать мощные значения поиска (регулярные выражения).

Вы узнаете больше о регулярных выражениях в более поздней главе.

Извлечение строковых деталей

Существует 3 способа извлечения части строки:

  • срез (начало, конец)
  • подстрока (начало, конец)
  • substr (начало, длина)

Метод slice ()

slice () извлекает часть строки и возвращает извлеченную часть в новой строке.

Метод принимает 2 параметра: начальный индекс (положение) и Конечный индекс (позиция).

Этот пример нарезает часть строки из позиции 7 в положение 13:

Пример

The result of res will be:

Если параметр имеет отрицательное значение, позиция учитывается от конца строки.

Этот пример нарезает часть строки из позиции-12 в положение-6:

Пример

The result of res will be:

Если опустить второй параметр, метод выполнит срез оставшейся части строки:

Пример

или, считая с конца:

Пример

Отрицательные позиции не работают в Internet Explorer 8 и более ранних версиях.

Метод подстроки ()

подстрока () аналогична срезу ().

Разница заключается в том, что подстрока () не может принимать отрицательные индексы.

Пример

The result of res will be:

Если опустить второй параметр, подстрока () будет разрезать оставшуюся часть строки.

Метод substr ()

substr () похож на slice ().

Разница в том, что второй параметр указывает длину извлеченной детали.

Пример

The result of res will be:

Если опустить второй параметр, substr () будет разрезать оставшуюся часть строки.

Пример

The result of res will be:

Если первый параметр отрицательный, позиция рассчитывается от конца строки.

Пример

The result of res will be:

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

Метод Replace () заменяет указанное значение другим значением в строке:

Пример

Метод Replace () не изменяет строку, в которой он вызывается. Возвращает новую строку.

По умолчанию функция Replace () заменяет только первое совпадение:

Пример

По умолчанию функция Replace () учитывает регистр. Написание Microsoft (с верхним регистром) не будет работать:

Пример

Чтобы заменить регистр без учета регистра, используйте регулярное выражение с пометкой » i » (нечувствительно):

Пример

Обратите внимание, что регулярные выражения записываются без кавычек.

Чтобы заменить все совпадения, используйте регулярное выражение с флагом /g (глобальное совпадение):

Пример

Вы узнаете намного больше о регулярных выражениях в главе регулярные выражения JavaScript.

Преобразование в верхний и нижний регистр

Строка преобразуется в верхний регистр с toUpperCase ():

Пример

Строка преобразуется в нижний регистр с toLowerCase ():

Пример

Метод Concat ()

concat () соединяет две или более строк:

Пример

Вместо оператора Plus можно использовать метод concat () . Эти две строки делают то же самое:

Пример

Все строковые методы возвращают новую строку. Они не изменяют исходную строку.
Формально сказал: строки являются неизменяемыми: строки не могут быть изменены, только заменены.

String.trim()

String.trim() Удаляет пробелы с обеих сторон строки.

Пример

Строка. Trim () не поддерживается в Internet Explorer 8 или ниже.

Если вам нужно поддерживать IE 8, вы можете использовать String. Replace с регулярным выражением вместо:

Пример

Метод charCodeAt ()

Метод charCodeAt () возвращает Юникод символа по указанному индексу в строке:

Пример

var str = «HELLO WORLD»;

str.charCodeAt(0); // returns 72

Доступ к строке в виде массива небезопасен

Возможно, вы видели такой код, обращаясь к строке как к массиву:

var str = «HELLO WORLD»;

str[0]; // returns H


Это небезопасно и непредсказуемо:

  • Она не работает во всех браузерах (не в IE5, IE6, IE7)
  • Это делает строки выглядят как массивы (но они не являются)
  • str [0] = «H» не дает ошибки (но не работает)

Если требуется считать строку массивом, сначала преобразуйте ее в массив.

Преобразование строки в массив

Строка может быть преобразована в массив с помощью метода Split () :

Пример

Если разделитель опущен, возвращаемый массив будет содержать всю строку в index [0].

Если разделитель «», возвращаемый массив будет массивом из одного символа:

Пример

Полная ссылка на строку

Для полной справки перейдите к нашей полной ссылке на строку JavaScript.

Ссылка содержит описания и примеры всех строковых свойств и методов.

Основы регулярных выражений в JavaScript

Если вы иногда поглядываете на регулярные выражения, но всё никак не решаетесь их освоить, думая, что всё это невероятно сложно — знайте — вы не одиноки. Для любого, кто не понимает, что такое регулярные выражения, или не разбирается в том, как они работают, они выглядят как совершенная бессмыслица.

Мощная картинка для привлечения внимания 🙂 Осторожно, может засосать!

Но, на самом деле, регулярные выражения — это мощный инструмент, который может помочь вам сэкономить уйму времени. В этом материале мы рассмотрим основы регулярных выражений в JavaScript.

Создание регулярных выражений в JS

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

Существует два способа создания регулярных выражений.

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

Второй задействует конструктор объекта RegExp , которому передают строку, из которой он создаёт регулярное выражение:

В обоих вышеприведённых примерах создаётся один и тот же шаблон — символ c , за которым следует символ a , за которым идёт символ t .

Какой способ создания регулярных выражений выбрать? Тут стоит придерживаться такого правила: если вы предполагаете пользоваться регулярным выражением так, что оно остаётся неизменным — лучше использовать литерал. Если ваше регулярное выражение является динамическим, оно может меняться в ходе выполнения программы, лучше использовать конструктор RegExp .

Методы регулярных выражений

Выше вы могли заметить, что регулярные выражения в JS — это объекты. У объектов, как известно, есть методы, и регулярные выражения — не исключение.

Один из основных методов регулярных выражения — это .test() , который возвращает логическое значение:

А именно, этот метод возвращает true если строка содержит совпадение с заданным шаблоном регулярного выражения. Если совпадений не найдено — он возвращает false .

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

Как и ожидается, когда мы проверяем первую строку, str1 , на наличие в ней последовательности символов cat , мы получаем true . А вот проверив вторую строку, str2 , мы в ней cat не находим, поэтому метод .test() возвращает false .

Базовые конструкции регулярных выражений

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

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

▍Символы

▍Группы символов

▍Флаги

Существует пять необязательных флагов регулярных выражений. Они могут использоваться совместно или раздельно, их помещают после закрывающего слэша. Регулярные выражения с флагами выглядят так: /[A-Z]/g . Мы рассмотрим тут лишь два флага:

  • g — глобальный поиск по строке.
  • i — поиск, нечувствительный к регистру.

▍Дополнительные конструкции

Более сложные примеры регулярных выражений

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

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

Как видите, код возвращает true — это неудивительно, так как в исследуемой строке есть четыре цифровых символа.

А что если нам нужно проверить строку на наличие в ней некоей последовательности цифровых символов? В подобном случае можно воспользоваться шаблоном \d , повторённым несколько раз. Например, для того, чтобы регулярное выражение соответствовало строке 11 , можно воспользоваться конструкцией \d\d , которая описывает два любых последовательно расположенных цифровых символа. Взгляните на этот код:

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

Как быть, если неважно сколько именно цифр находится до или после чёрточек, если их количество больше или равняется единице? В подобной ситуации можно воспользоваться знаком + для того, чтобы указать, что шаблон /d может встречаться один или более раз. Вот как это выглядит:

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

Получилось. Теперь давайте рассмотрим это выражение подробнее. На самом деле, тут происходит много интересного.

Итак, вот регулярное выражение.

  • m — соответствует одиночной букве m .
  • e+ — соответствует букве e , повторённой один или более раз.
  • (ow)+ соответствует сочетанию ow , повторённому один или более раз.
  • w — соответствует одиночной букве w .

В результате это выражение воспринимает строку следующим образом:

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

Топ-пост этого месяца:  Как сделать логотип не кликабельынм только на главной странице

Вот ещё один пример, он касается использования оператора ? . Знак вопроса указывает на то, что присутствие предшествующего ему символа в строке необязательно.

Взгляните на это:

Как видите, каждое из выражений возвращает true . Это происходит потому что мы сделали символы s в конце последовательностей cat и say необязательными. Кроме того, можно заметить, что в конце регулярного выражения находится флаг i . Благодаря ему при анализе строк игнорируется регистр символов. Именно поэтому регулярное выражение реагирует и на строку cat , и на строку Cat .

Об экранировании служебных символов

Регулярные выражения заключают в слэши. Кроме того, некоторые символы, вроде + , ? , и другие, имеют особый смысл. Если вам нужно организовать поиск в строках этих особых символов, их нужно экранировать с помощью обратного слэша. Вот как это выглядит:

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

  • \d — это то же самое, что и [0-9] . Каждое из этих выражений соответствует любому цифровому символу.
  • \w — это то же самое, что [A-Za-z0-9_] . И то и другое найдёт в строке любой одиночный алфавитно-цифровой символ или знак подчёркивания.

Проект №1: добавление пробелов в строки, построенные в верблюжьемСтиле

Теперь пришло время применить полученные знания на практике. В нашем первом проекте мы собираемся написать функцию, которая принимает на вход строку, вроде CamelCase , и добавляет между отдельными словами, из которой она состоит, пробелы. Использование готовой функции, которую мы назовём removeCc , выглядит так:

Для начал надо написать каркас функции, которая принимает строку и возвращает новую строку:

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

Это регулярное выражение отреагирует на букву C в строке camelCase . А как добавить пробел перед этой буквой C ?

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

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

Обратите внимание на то, что нам не нужно захватывать значение в скобках. Можно и не использовать его, или использовать незахватывающие скобки с помощью конструкции вида (?:x) . В данном примере находится соответствие с x , но оно не запоминается.

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

Мы уже близки к решению, хотя цели пока ещё не достигли. Взглянем снова на наш код. Тут мы захватываем заглавные буквы, затем меняем их на эти же буквы. А нам надо, чтобы перед ними оказались пробелы. Сделать это довольно просто — достаточно добавить пробел перед переменной $1 . В результате перед каждой заглавной буквой в строке, которую возвратит функция, будет пробел. В итоге у нас получилось следующее:

Проект №2: удаление заглавных букв из строки

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

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

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

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

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

Если мы ещё и используем флаг глобального поиска, функция будет вызываться для каждого совпадения с шаблоном, найденного в строке. Помня об этом, мы можем воспользоваться методом .toLowerCase() объекта String для преобразования входной строки к нужному нам виду. Вот как, с учётом вышесказанного, выглядит решение нашей задачи:

Проект №3: преобразование к верхнему регистру первую букву первого слова строки

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

Тут, как и прежде, будем пользоваться методом .replace() . Однако, в этот раз нам нужно найти лишь самый первый символ строки. Для того, чтобы это сделать, задействуем символ ^ . Вспомним один из вышеприведённых примеров:

Если добавить в начало шаблона символ ^ , true эта конструкция уже не возвратит. Произойдёт это из-за того, что слово cat находится не в начале строки:

Нам надо, чтобы специальный символ ^ воздействовал на любой символ в нижнем регистре, находящийся в начале строки. Поэтому мы добавляем его прямо перед конструкцией [a-z] . В результате регулярное выражение отреагирует только на первую букву строки в нижнем регистре:

Кроме того, тут мы не используем флаг глобального поиска, так как нам нужно найти лишь одно совпадение с шаблоном. Теперь всё, что осталось сделать — это преобразовать найденный символ к верхнему регистру. Сделать это можно с помощью строкового метода .toUpperCase() :

Совместное использование ранее созданных функций

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

Итоги

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

Уважаемые читатели! Если у вас получилось написать функцию, о которой только что шла речь — предлагаем поделиться её кодом в комментариях. Кроме того, если вы хорошо знакомы с регулярными выражениями, просим рассказать о том, помогло ли вам это знакомство в реальных проектах.

Ну и топ Хабрапостов про регулярные выражения.

Самые необходимые строковые и числовые методы в JavaScript

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

String

У объекта String есть один статический метод, String.fromCharCode() , который обычно используют для создания строкового представления последовательности Unicode символов. В этом примере мы делаем простую строку с использованием ASCII кодов:

Вы также можете использовать восьмеричные и шестнадцатеричные числа:

Все другие, описанные ниже методы, это методы “из коробки”, которые работают на строках.

charAt()

Отдаёт символ под заданным индексом i .

Если вы зададите индекс, который не подходит по строке, то на выходе вы получите уже пустую строку.

В JavaScript нет типа char, так что char это строка с длиной 1 .

charCodeAt()

Отдаёт код символа под индексом i . Как и с charAt() , отдаёт Unicode 16-битное целое число, представляющее символ:

Вызов toString() после него, отдаст шестнадцатеричное число, которое вы можете найти в любой Unicode таблице, такой как эта.

codePointAt()

Этот метод был представлен уже в ES2015, чтобы работать с Unicode символами, которые не могут быть представлены как единичная 16-ти битная Unicode единица и которым вместо этого нужно их две.

Используя charCodeAt() , вам надо получить первый и второй, и затем совместить их. Используя codePointAt() вы получаете весь символ в одном запросе.

К примеру, этот китайский символ “��” состоит из двух UTF-16 частей:

Комбинируем эти два unicode символа:

Вы можете получить тот же результат, но только используя codePointAt() :

Если вы создаете новый символ, комбинируя эти unicode символы:

concat()

Объединяет актуальную строку со строкой str .

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

endsWith()

Проверяет заканчивается ли строка со значением другой строки str .

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

includes()

Проверяет есть ли в строке значение строки str .

includes() также принимает второй опциональный параметр, целое число, которое указывает на позицию с которой начинать поиск.

Этот блог бесплатный, в нём нет рекламы и ограничений paywall.
Вы можете его поддержать через Яндекс.Деньги. Спасибо.

indexOf()

Даёт позицию начала заданной строки str в строке, на которой применяется метод.

Вы можете передать второй параметр, чтобы указать точку старта:

lastIndexOf()

Даёт позицию последнего появления строки str в актуальной строке.

Отдаёт -1 , если поисковая строка не найдена.

localeCompare()

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

Язык определяется настоящим местоположением или вы можете указать его, как второй аргумент:

Очень часто его используют для сортировки массивов:

Где бы вы обычно использовали:

Только тут мы можем это сделать с помощью localeCompare(), который позволит нам работать с алфавитами по всему миру.

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

match()

А вот работа с регулярными выражениями RegEx.

normalize()

В Unicode есть четыре главные формы нормализации. Их коды это NFC , NFD , NFKC и NFKD . На Википедии есть хорошая статья про это.

Метод normalize() возвращает строку, нормализованную в соответствии с указанной формой, которую вы передаёте как параметр. ( NFC используется как стандарт, если она не указана в ручную).

Вот пример с MDN:

padEnd()

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

padEnd() был представлен в ES2020, как метод добавляющий символы в конец строки.

padStart()

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

repeat()

Этот метод был представлен в ES2015 и повторяет строки заданное количество раз.

Отдает пустую строку, если параметр не указан или параметр равен нулю. А в случае с отрицательным числом вы получите RangeError.

replace()

Этот метод находит первое упоминание str1 в заданной строке и заменяет его на str2 .

Отдаёт новую строку, не трогая оригинальную.

Вы можете передать регулярное выражение как первый аргумент:

replace() заменяет только первое упоминание, но а если вы будете использовать regex как поиск строки, то вы можете использовать ( /g ):

Второй параметр может быть функцией. Эта функция будет вызвана с заданным количеством аргументов, когда найдётся совпадение (или каждое совпадение в случае с regex /g ):

  • Нужная строка
  • Целое число, которое указывает позицию в строке, где произошло совпадение
  • Строка

Отдающееся значение функции заменит совпадающую часть строки.

Это работает и для обычных строк, а не только для регулярок:

В случае c regex, когда выбираются группы, все эти значения будут переданы как аргументы прямо после параметра совпадения.

search()

Отдаёт расположение первого совпадения строки str в заданной строке.

Этот метод отдаёт индекс начала упоминания или -1 , если такого не было найдено.

Вы можете использовать регулярные выражения (и на самом деле, даже если вы передаёте строку, то внутренне оно тоже применяется как регулярное выражение).

slice()

Отдает новую строку, которая является частью строки на которой применялся метод, от позиций begin до end .

Оригинальная строка не изменяется.

Если вы выставите первым параметром отрицательное число, то начальный индекс будет считаться с конца и второй параметр тоже должен быть отрицательным, всегда ведя отсчет с конца:

split()

Этот метод вырезает строку при её нахождении в строке на которой применяется метод ( чувствительный к регистру) и отдаёт массив с токенами.

startsWith()

Проверяет начинается ли строка со значения str .

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

Вы можете вызвать startWith() на любой строке, указать подстроку и проверить отдаёт результат true или false .

Этот метод допускает второй параметр, который позволит вам указать с какого символа вам надо начать проверку:

toLocaleLowerCase()

Этот метод отдаёт новую строку, которая представляет собой изначальную строку в нижнем регистре, в соответствии с нормами разметки указанной локали.

Собственно, первый параметр представляет локаль, но он опционален. Если его пропустить, то будет использоваться актуальная локаль:

Как и всегда, мы можем не осознавать все преимущества интернационализации, но я читал на MDN, что правила разметки текста в турецком языке отличаются от других языков, чьё описание основано на латинице.

В общем, это как и toLowerCase() , но с учетом локали.

toLocaleUpperCase()

Этот метод отдаёт новую строку, которая представляет собой изначальную строку в верхнем регистре, в соответствии с нормами разметки указанной локали.

Первым параметром указывается локаль, но это опционально, как и в случае с методом выше:

toLowerCase()

Этот метод отдаёт новую строку с текстом в нижнем регистре.

Не изменяет изначальную строку.

Не принимает параметры.

Работает как и toLocaleLowerCase() , но не учитывает локали.

toString()

Отдает строку из заданного строчного объекта.

toUpperCase()

Отдаёт новую строку с текстом в верхнем регистре.

Не изменяет оригинальную строку.

Не принимает параметры.

Если вы передадите пустую строку, то он возвратит пустую строку.

Метод похож на toLocaleUpperCase() , но не принимает параметры.

Отдает новую строку удаляя пробелы вначале и в конце оригинальной строки.

trimEnd()

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

trimStart()

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

valueOf()

Отдает строчное представление заданного строчного объекта:

Это тоже самое, что и toString()

Теперь пройдемся по числовым методам.

isInteger()

Отдаст true , если переданное значение является целым числом. Всё иное, такое как, логические значения, строки, объекты, массивы, отдают false .

isNaN()

NaN это особый случай. Число является NaN , только если оно NaN или если это выражения деления ноль на ноль, что отдаёт NaN . Во всех других случаях мы можем передать ему что захотим, но получим false :

isSafeInteger()

Число может удовлетворять Number.isInteger() , но не Number.isSafeInteger() , если оно заходит за пределы безопасных целых чисел.

Так что, всё что выше 2⁵³ и ниже -2⁵³ не является безопасным.

parseFloat()

Парсит аргумент как дробное число и отдаёт его. Аргумент при этом является строкой:

Как вы видите Number.parseFloat() довольно гибок. Он также может конвертировать строки со словами, выделяя только первое число, но в этом случае строка должна начинаться с числа:

parseInt()

Парсит аргумент как целое число и отдаёт его:

Как вы видите Number.parseInt() тоже гибок. Он также может конвертировать строки со словами, выделяя первое число, строка должна начинаться с числа.

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

Вызов toUppercase() для строковой переменной

Я новичок и просто успешно справляюсь с моим кодом. Я рад, что нашел это, но мне потребовалось много времени. Я надеюсь узнать, почему это произошло.

Вот исходный код багги. Предположим, что переменной [nextAlpha] уже присвоено строковое значение:

Через какое-то творческое тестирование я смог определить, что это была проблема, вызывающая проблемы. Я подумал, что, возможно, это не обновление значения переменной [nextAlpha] . Я попробовал это вместо этого, и это сработало:

Я оставил остальную часть своего кода, но предположим, что [var = nextAlpha] уже объявлен в верхней части моего script, что, я думаю, означает «глобально». С этой информацией я подумал, что достаточно просто вызвать метод для переменной. Почему это «обновление» строки в верхнем регистре, как это происходит, когда я перехожу на дополнительный шаг, чтобы (re) назначить его исходной строке [nextAlpha] ?

toUpperCase возвращает преобразованную строку как новый объект — она ​​не выполняет преобразование на nextAlpha .

Из ссылки Mozilla:

Метод toUpperCase возвращает значение строки, преобразованной в верхний регистр. toUpperCase не влияет на значение самой строки.

В JavaScript строки неизменяемы:

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

How can I test if a letter in a string is uppercase or lowercase using JavaScript?

How can I test if a letter in a string is uppercase or lowercase using JavaScript?

28 Answers 28

The answer by josh and maleki will return true on both upper and lower case if the character or the whole string is numeric. making the result a false result. example using josh

another way is to test it first if it is numeric, else test it if upper or lower case example

This will log true if character is uppercase letter, and log false in every other case:

You may test it here: http://jsfiddle.net/Axfxz/ (use Firebug or sth).

and this is for lowercase:).

The problem with the other answers is, that some characters like numbers or punctuation also return true when checked for lowercase/uppercase.

I found this to work very well for it:

This will work for punctuation, numbers and letters:

To check one letter just call it using isLowerCase(str[charIndex])

You could utilize a regular expression test and the toUpperCase method:

More specifically to what is being asked. Pass in a String and a position to check. Very close to Josh’s except that this one will compare a larger string. Would have added as a comment but I don’t have that ability yet.

You can also use a regular expression to explicitly detect uppercase roman alphabetical characters.

EDIT: the above function is correct for ASCII/Basic Latin Unicode, which is probably all you’ll ever care about. The following version also support Latin-1 Supplement and Greek and Coptic Unicode blocks. In case you needed that for some reason.

This strategy starts to fall down if you need further support (is Ѭ uppercase?) since some blocks intermix upper and lowercase characters.

There’s a really simple answer, which nobody else has mentioned:

If str.toUpperCase() does not return the same str , it has to be lower case. To test for upper case you change it to str !== str.toLowererCase() .

Unlike some other answers, it works correctly on non-alpha characters (returns false ) and it works for other alphabets, accented characters etc.

A good answer to this question should be succinct, handle unicode correctly, and deal with empty strings and nulls.

This approach deals with empty strings and nulls first, then ensures that converting the given string to lower case changes its equality. This ensures that the string contains at least one capital letter according to the current local’s capitalisation rules (and won’t return false positives for numbers and other glyphs that don’t have capitalisation).

The original question asked specifically about testing the first character. In order to keep your code simple and clear I’d split the first character off the string separately from testing whether it’s upper case.

This is straightforward, readable solution using a simple regex.

You can test if your array has an upper case or lower case string by using the match method and regex, below is just a basic foundation to start your test

You can also use this, it will check the string for lower and uppercase

This checks the ENTIRE string, not just the first letter. I thought I’d share it with everyone here.

Here is a function that uses a regular expression to test against the letters of a string; it returns true if the letter is uppercase (A-Z). We then reduce the true/false array to a single value. If it is equal to the length of the string, that means all the letters passed the regex test, which means the string is uppercase. If not, the string is lowercase.

The best way is to use a regular expression, a ternary operator, and the built in .test() method for strings.

I leave you to Google the ins and outs of regular expressions and the test method for strings (they’re easy to find), but here we’ll use it to test your variable.

This will return TRUE of FALSE based on whether or not your character matches the character set in the regular expression. Our regular expression checks for all letters a-z /[a-z]/ regardless of their case thanks to the i flag.

So, a basic test would be:

Now we need to determine if it’s upper or lower case. So, if we remove the i flag from our regular expression, then our code above will test for lower case letters a-z. And if we stick another if statement in the else of our first if statement, we can test for upper case too by using A-Z. Like this:

And just in case it’s not a letter, we can add a final else statement:

The above code would work. But it’s kinda ugly. Instead, we can use a «ternary operator» to replace our if-else statements above. Ternary operators are just shorthand simple ways of coding an if-else . The syntax is easy:

And these can be nested within each other, too. So a function might look like:

The above code looks good, but won’t quite work, because if our character is lower case, theAnswer gets set to «» when it test for uppercase, so lets nest them:

That will work great! But there’s no need to have two seperate lines for setting the variable theAnswer and then returning it. And we should be using let and const rather than var (look those up if you’re not sure why). Once we make those changes:

And we end up with an elegant, concise piece of code. 😉

Объект String в Javascript

Всем доброго времени суток. На связи Алексей Гулынин. В прошлой статье вы узнали об объекте Date в Javascript. В данной статье я бы хотел рассказать об объекте String в Javascript. Ни для кого не секрет, что работа со строками занимает одну из ведущих позиций абсолютно в любом языке программирования, поэтому крайне важно уметь с ними работать. Давайте всё также, на примерах, разбираться с методами и свойствами объекта String в Javascript.
Первое свойство, которое следует изучить — это свойство length , которое возвращает длину строки:

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

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

Метод replace() применяется для замены подстроки на другую строку. На примере будет нагляднее:

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

Метод charAt() позволяет получить символ по его номеру в строке. По идее к элементам строки можно обращаться, как к элементам массива. Если такого индекса не существует, о вернется пустая строка. Пример:

С помощью метода String.fromCharCode() можно узнать код символа и вывести его (обращаю ваше внимание, что данный метод статистический). Более подробно данный пример разбирался здесь.

Метод charCodeAt() возвращает номер символа (по кодировке Unicode) в строке. Пример:

Метод split() позволяет разбить строку на несколько строк по определенному разделителю (тип возвращаемого значения — массив). Если разделитель не указан, то возвращается исходная строка. Думаю на примере всё станет намного понятнее:

Метод slice(begin, end) служит для того, чтобы возвращать часть строки, включая позицию begin, и не включая позицию end. Если end Не указывать, то будет взята вся строка, начиная с begin. Пример:

Есть также метод substr() , который полностью аналогичен этому, за исключением того, что slice() может работать ещё с массивами, в отличие от substr() .

Метод toLowerCase() используется для перевода строки в нижний регистр, а метод toUpperCase() — в верхний:

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

В данной статье вы узнали, что такое объект String в Javascript, а также как с ним работать.

На связи был Алексей Гулынин, оставляйте свои комментарии, увидимся в следующих статьях.

Добавить комментарий