JavaScript
Струны

Синтаксис

• "строковый литерал"
• 'string literal'
• «строковый литерал с« несовпадающими кавычками »» // без ошибок; цитаты разные.
• «строковый литерал с« экранированными кавычками »» // без ошибок; кавычки экранированы.
• `template string $ {выражение}`
• String ("ab c") // возвращает строку при вызове в контексте неконструктора
• new String ("ab c") // объект String, а не примитив строки

Основная информация и конкатенация строк

Строки в JavaScript могут быть заключены в одинарные кавычки 'hello' , двойные кавычки "Hello" и (из ES2015, ES6) в Template Literals ( backticks ) `hello` .

var hello  = "Hello";
var world  = 'world';
var helloW = `Hello World`;              // ES2015 / ES6

Строки могут быть созданы из других типов с помощью функции String() .

var intString = String(32); // "32"
var booleanString = String(true); // "true"
var nullString = String(null); // "null" 

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

var intString = (5232).toString(); // "5232"
var booleanString = (false).toString(); // "false"
var objString = ({}).toString(); // "[object Object]"

Строки также могут быть созданы с помощью метода String.fromCharCode .

String.fromCharCode(104,101,108,108,111) //"hello"

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

var objectString = new String("Yes, I am a String object");
typeof objectString;//"object"
typeof objectString.valueOf();//"string"

Конкатенация строк

Конкатенацию строк можно выполнить с помощью оператора + конкатенации или со встроенным методом concat() на прототипе объекта String.

var foo = "Foo";
var bar = "Bar";
console.log(foo + bar);        // => "FooBar"
console.log(foo + " " + bar);  // => "Foo Bar"

foo.concat(bar)            // => "FooBar"
"a".concat("b", " ", "d")  // => "ab d"

Строки могут быть объединены с нестроковыми переменными, но будут вводить типы-непеременные переменные в строки.

var string = "string";
var number = 32;
var boolean = true;

console.log(string + number + boolean); // "string32true"

Строковые шаблоны

var greeting = `Hello`;

var place = `World`;
var greet = `Hello ${place}!`

console.log(greet); // "Hello World!"

`a\\b` // =  a\b
String.raw`a\\b` // = a\\b

Кавычки

Если ваша строка заключена (т. Е.) В одинарные кавычки, вам нужно избежать внутренней литеральной цитаты с обратным слэшем \

var text = 'L\'albero means tree in Italian';
console.log( text ); \\ "L'albero means tree in Italian"

То же самое касается двойных кавычек:

var text = "I feel \"high\"";

Особое внимание следует уделить экранированию кавычек, если вы храните HTML-представления в String, поскольку HTML-строки широко используют цитаты, то есть в атрибутах:

var content = "<p class=\"special\">Hello World!</p>";        // valid String
var hello   = '<p class="special">I\'d like to say "Hi"</p>'; // valid String

Цитаты в строках HTML также могут быть представлены с использованием ' (или ' ) в виде одиночной кавычки и " (или " ) в виде двойных кавычек.

var hi    = "<p class='special'>I'd like to say &quot;Hi&quot;</p>"; // valid String
var hello = '<p class="special">I&apos;d like to say "Hi"</p>';      // valid String

Примечание: Использование ' и " не будет перезаписывать двойные кавычки, которые браузеры могут автоматически помещать в кавычки атрибутов. Например, <p class=special> делается для <p class="special"> , используя " может привести к <p class=""special""> где \" будет <p class="special"> .

var x = `"Escaping " and ' can become very annoying`;

Обратная строка

Самый «популярный» способ обращения к строке в JavaScript - это следующий фрагмент кода, который довольно распространен:

function reverseString(str) {
    return str.split('').reverse().join('');
}

reverseString('string');    // "gnirts"

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

'𝌆■.'.split('').reverse().join(''); //fails

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

объяснение

Использование оператора распространения

function reverseString(str) {
    return [...String(str)].reverse().join('');    
}

console.log(reverseString('stackoverflow'));  // "wolfrevokcats"
console.log(reverseString(1337));             // "7331"
console.log(reverseString([1, 2, 3]));        // "3,2,1"

Пользовательская функция reverse()

function reverse(string) {
    var strRev = "";
    for (var i = string.length - 1; i >= 0; i--) {
        strRev += string[i];
    }
    return strRev; 
}

reverse("zebra");  // "arbez"

Обрезать пробелы

Чтобы обрезать пробелы по краям строки, используйте String.prototype.trim :

"    some whitespaced string  ".trim();  // "some whitespaced string"

Многие механизмы JavaScript, но не Internet Explorer , реализовали нестандартные методы trimLeft и trimRight . Существует предложение , в настоящее время на стадии 1 процесс, стандартизированные trimStart и trimEnd методов, псевдонимы к trimLeft и trimRight для совместимости.

// Stage 1 proposal
"    this is me    ".trimStart();  // "this is me    "
"    this is me    ".trimEnd();  // "    this is me"

// Non-standard methods, but currently implemented by most engines
"    this is me    ".trimLeft();  // "this is me    "
"    this is me    ".trimRight();  // "    this is me"

Подложки со срезом

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

var s = "0123456789abcdefg";
s.slice(0, 5);  // "01234"
s.slice(5, 6);  // "5"

Учитывая один индекс, он будет принимать от этого индекса до конца строки:

s.slice(10);    // "abcdefg"

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

Используйте .split чтобы перейти от строк к массиву разделяемых подстрок:

var s = "one, two, three, four, five"
s.split(", ");  // ["one", "two", "three", "four", "five"]

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

s.split(", ").join("--");  // "one--two--three--four--five"

Строки являются unicode

Все строки JavaScript являются unicode!

var s = "some ∆≈ƒ unicode ¡™£¢¢¢";
s.charCodeAt(5);  // 8710

В JavaScript нет исходных байтов или двоичных строк. Чтобы эффективно обрабатывать двоичные данные, используйте Typed Arrays .

Обнаружение строки

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

var aString = "my string";
var anInt = 5;
var anObj = {};
typeof aString === "string";   // true
typeof anInt === "string";     // false
typeof anObj === "string";     // false

Если у вас когда-либо был объект String , через new String("somestr") , то вышеуказанное не будет работать. В этом случае мы можем использовать instanceof :

var aStringObj = new String("my string");
aStringObj instanceof String;    // true

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

var isString = function(value) {
    return typeof value === "string" || value instanceof String;
};

var aString = "Primitive String";
var aStringObj = new String("String Object");
isString(aString); // true
isString(aStringObj); // true
isString({}); // false
isString(5); // false

Или мы можем использовать функцию toString Object . Это может быть полезно, если мы должны проверить другие типы, а также сказать в инструкции switch, так как этот метод поддерживает другие типы данных, а также как typeof .

var pString = "Primitive String";
var oString = new String("Object Form of String");
Object.prototype.toString.call(pString);//"[object String]"
Object.prototype.toString.call(oString);//"[object String]"    

Более надежное решение состоит в том, чтобы не обнаруживать строку вообще, а только проверять, какая функциональность требуется. Например:

var aString = "Primitive String";
// Generic check for a substring method
if(aString.substring) {

}
// Explicit check for the String substring prototype method
if(aString.substring === String.prototype.substring) {
    aString.substring(0, );
}

Сравнение строк в лексикографическом

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

var a = "hello";
var b = "world";

console.log(a.localeCompare(b)); // -1

Операторы > и < могут также использоваться для сравнения строк лексикографически, но они не могут вернуть значение нуля (это можно проверить с помощью оператора равенства == ). В результате форма функции localeCompare() может быть записана так:

function strcmp(a, b) {
    if(a === b) {
        return 0;
    }

    if (a > b) {
        return 1;
    }

    return -1;
}

console.log(strcmp("hello", "world")); // -1
console.log(strcmp("hello", "hello")); //  0
console.log(strcmp("world", "hello")); //  1

Это особенно полезно при использовании функции сортировки, которая сравнивается на основе знака возвращаемого значения (например, sort ).

var arr = ["bananas", "cranberries", "apples"];
arr.sort(function(a, b) {
    return a.localeCompare(b);
});
console.log(arr); // [ "apples", "bananas", "cranberries" ]

Строка в верхний регистр

String.prototype.toUpperCase ():

console.log('qwerty'.toUpperCase()); // 'QWERTY'

Строка для нижнего регистра

String.prototype.toLowerCase ()

console.log('QWERTY'.toLowerCase()); // 'qwerty'

Счетчик слов

Скажем, у вас есть <textarea> и вы хотите получить информацию о количестве:

• Персонажи (всего)
• Символы (без пробелов)
• слова
• линии

function wordCount( val ){
    var wom = val.match(/\S+/g);
    return {
        charactersNoSpaces : val.replace(/\s+/g, '').length,
        characters         : val.length,
        words              : wom ? wom.length : 0,
        lines              : val.split(/\r*\n/).length
    };
}


// Use like:
wordCount( someMultilineText ).words;   // (Number of words)

Пример jsFiddle

Символ доступа по индексу в строке

Используйте charAt() чтобы получить символ в указанном индексе в строке.

var string = "Hello, World!";
console.log( string.charAt(4) ); // "o"

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

var string = "Hello, World!";
console.log( string[4] ); // "o"

Чтобы получить код символа символа с указанным индексом, используйте charCodeAt() .

var string = "Hello, World!";
console.log( string.charCodeAt(4) ); // 111

Обратите внимание, что эти методы - все методы getter (возвращают значение). Строки в JavaScript неизменяемы. Другими словами, ни один из них не может использоваться для установки символа в позиции в строке.

Функция поиска и замены строк

Для поиска строки внутри строки существует несколько функций:

indexOf( searchString ) и lastIndexOf( searchString )

indexOf() вернет индекс первого вхождения searchString в строке. Если searchString не найден, возвращается -1 .

var string = "Hello, World!";
console.log( string.indexOf("o") ); // 4
console.log( string.indexOf("foo") ); // -1

Точно lastIndexOf() же lastIndexOf() вернет индекс последнего вхождения searchstring или -1 если не найден.

var string = "Hello, World!";
console.log( string.lastIndexOf("o") );   // 8
console.log( string.lastIndexOf("foo") ); // -1

includes( searchString, start )

includes() вернет логическое значение, searchString существует ли searchString в строке, начиная с start индекса (по умолчанию 0). Это лучше, чем indexOf() если вам просто нужно проверить наличие подстроки.

var string = "Hello, World!";
console.log( string.includes("Hello") ); // true
console.log( string.includes("foo") );   // false

replace( regexp|substring, replacement|replaceFunction )

replace() вернет строку, содержащую все вхождения подстрок, совпадающих с regexp RegExp или строковой substring с replacement строки или возвращаемым значением replaceFunction .

Обратите внимание, что это не изменяет строку на месте, но возвращает строку с заменой.

var string = "Hello, World!";
string = string.replace( "Hello", "Bye" );
console.log( string ); // "Bye, World!"

string = string.replace( /W.{3}d/g, "Universe" );
console.log( string ); // "Bye, Universe!"

replaceFunction может использоваться для условных замен для объектов регулярного выражения (т. е. с использованием regexp ). Параметры находятся в следующем порядке:

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

var string = "heLlo, woRlD!";
string = string.replace( /([a-zA-Z])([a-zA-Z]+)/g, function(match, g1, g2) {
    return g1.toUpperCase() + g2.toLowerCase();
}); 
console.log( string ); // "Hello, World!"

Найти индекс подстроки внутри строки

Метод .indexOf возвращает индекс подстроки внутри другой строки (если существует, или -1, если в противном случае)

'Hellow World'.indexOf('Wor');    // 7

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

"harr dee harr dee harr".indexOf("dee", 10); // 14

Следует отметить, что .indexOf чувствителен к регистру

 'Hellow World'.indexOf('WOR');    // -1

Строковые представления чисел

JavaScript имеет собственное преобразование из Number в его представление String для любой базы от 2 до 36 .

Наиболее распространенное представление после десятичной (база 10) является шестнадцатеричным (базовое 16) , но содержание этого раздела работает для всех баз в диапазоне.

Чтобы преобразовать число из десятичной (базовая 10) в шестнадцатеричное (базовое 16) представление String, метод toString может использоваться с основанием 16 .

// base 10 Number
var b10 = 12;

// base 16 String representation
var b16 = b10.toString(16); // "c"

Если представленное число является целым числом, обратная операция для этого может быть выполнена с помощью parseInt и радиуса 16 снова

// base 16 String representation
var b16 = 'c';

// base 10 Number
var b10 = parseInt(b16, 16); // 12

Чтобы преобразовать произвольное число (т.е. нецелое) из его представления String в число , операция должна быть разделена на две части; целую часть и часть дроби.

let b16 = '3.243f3e0370cdc';
// Split into integer and fraction parts
let [i16, f16] = b16.split('.');

// Calculate base 10 integer part
let i10 = parseInt(i16, 16); // 3

// Calculate the base 10 fraction part
let f10 = parseInt(f16, 16) / Math.pow(16, f16.length); // 0.14158999999999988

// Put the base 10 parts together to find the Number
let b10 = i10 + f10; // 3.14159

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

Повторить строку

"abc".repeat(3);  // Returns "abcabcabc"
"abc".repeat(0);  // Returns ""
"abc".repeat(-1); // Throws a RangeError

var myString = "abc";
var n = 3;

new Array(n + 1).join(myString);  // Returns "abcabcabc"

Код символа

Метод charCodeAt извлекает код символа Unicode одного символа:

var charCode = "µ".charCodeAt(); // The character code of the letter µ is 181

Чтобы получить код символа символа в строке, позиция символа, базирующаяся на 0, передается как параметр charCodeAt :

var charCode = "ABCDE".charCodeAt(3); // The character code of "D" is 68

// The Grinning Face Emoji has code point 128512 or 0x1F600
var codePoint = "😀".codePointAt();