JavaScript
Smyczki

Składnia

• „dosłowny ciąg”
• „dosłowny ciąg”
• msgstr "literał łańcuchowy z„ niedopasowanymi cudzysłowami ”" // brak błędów; cytaty są różne.
• „literał łańcuchowy z„ cudzysłowami ”” // brak błędów; cytaty są pomijane.
• `ciąg szablonu $ {wyrażenie}`
• String („ab c”) // zwraca ciąg znaków, gdy jest wywoływany w kontekście innym niż konstruktor
• new String ("ab c") // obiekt String, a nie łańcuch podstawowy

Podstawowe informacje i łączenie łańcuchów

Ciągi w JavaScript mogą być zawarte w pojedynczych cudzysłowach 'hello' , podwójnych cudzysłowach "Hello" i (od ES2015, ES6) w literałach szablonów ( backticks ) `hello` .

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

Ciągi znaków można tworzyć z innych typów za pomocą funkcji String() .

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

Lub toString() można użyć do konwersji liczb, boolanów lub obiektów na ciągi znaków.

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

Ciągi można również tworzyć za pomocą metody String.fromCharCode .

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

Tworzenie obiektu String przy użyciu new słowa kluczowego jest dozwolone, ale nie jest zalecane, ponieważ zachowuje się jak Obiekty w przeciwieństwie do łańcuchów pierwotnych.

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

Łączenie strun

Konkatenację ciągów można wykonać za pomocą operatora + konkatenacji lub wbudowanej metody concat() w prototypie obiektu 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"

Ciągi mogą być łączone ze zmiennymi nieciągowymi, ale będą przekształcać zmienne nieciągowe w ciągi.

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

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

Szablony ciągów

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

Uciekające cytaty

Jeśli ciąg jest ujęty (tj.) W pojedyncze cudzysłowy, musisz uciec od wewnętrznego dosłownego cudzysłowu z ukośnikiem \

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

To samo dotyczy podwójnych cytatów:

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

Szczególną uwagę należy zwrócić na znaki ucieczki, jeśli przechowujesz reprezentacje HTML w ciągu znaków, ponieważ ciągi HTML w dużym stopniu wykorzystują cytaty, tj. W atrybutach:

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

Cytaty w ciągach HTML można również przedstawić za pomocą ' (lub ' ) jako pojedynczy cytat i " (lub " ) jako podwójne cudzysłowy.

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

Uwaga: użycie ' i " nie zastąpi podwójnych cudzysłowów, które przeglądarki mogą automatycznie umieszczać w cudzysłowach atrybutów. Na przykład <p class=special> zostaje zmienione na <p class="special"> przy użyciu " może prowadzić do <p class=""special""> gdzie \" będzie <p class="special"> .

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

Odwróć ciąg

Najbardziej „popularnym” sposobem odwracania łańcucha w JavaScript jest następujący fragment kodu, który jest dość powszechny:

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

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

Działa to jednak tylko wtedy, gdy odwracany ciąg nie zawiera par zastępczych. Symbole astralne, tj. Znaki spoza podstawowej płaszczyzny wielojęzyczności, mogą być reprezentowane przez dwie jednostki kodu i poprowadzą tę naiwną technikę do uzyskania błędnych wyników. Ponadto znaki z łączonymi znakami (np. Diaeresis) pojawią się na logicznym „następnym” znaku zamiast oryginalnego, z którym został połączony.

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

Chociaż metoda będzie działać dobrze w większości języków, nieco dokładniejszy jest naprawdę dokładny, zgodny z kodowaniem algorytm odwracania łańcucha. Jedną z takich implementacji jest niewielka biblioteka o nazwie Esrever , która używa wyrażeń regularnych do dopasowywania łączenia znaków i par zastępczych w celu perfekcyjnego wykonania cofania.

Wyjaśnienie

Korzystanie z operatora rozrzutu

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"

Niestandardowa funkcja reverse()

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

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

Przytnij białe znaki

Aby przyciąć białe znaki na krawędziach łańcucha, użyj String.prototype.trim :

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

Wiele silników JavaScript, ale nie Internet Explorer , zaimplementowało niestandardowe metody trimLeft i trimRight . Istnieje propozycja , obecnie na etapie 1 procesu, znormalizowanych metod trimStart i trimEnd , aliasowanych do trimLeft i trimRight celu zapewnienia zgodności.

// 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"

Podciągi z plasterkiem

Użyj .slice() aby wyodrębnić podciągi o dwóch indeksach:

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

Biorąc pod uwagę jeden indeks, pobierze od tego indeksu do końca ciągu:

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

Dzielenie łańcucha na tablicę

Użyj .split aby przejść od ciągów do tablicy podzielonych podciągów:

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

Użyj metody tablicowej .join aby wrócić do ciągu:

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

Ciągi znaków są Unicode

Wszystkie ciągi JavaScript są Unicode!

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

W JavaScript nie ma nieprzetworzonych bajtów ani ciągów binarnych. Aby skutecznie obsługiwać dane binarne, użyj tablic typowanych .

Wykrywanie ciągu

Aby wykryć, czy parametr jest ciągiem pierwotnym , użyj typeof :

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

Jeśli kiedykolwiek masz obiekt String , poprzez new String("somestr") , powyższe nie będzie działać. W tym przypadku możemy użyć instanceof :

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

Aby objąć oba przypadki, możemy napisać prostą funkcję pomocnika:

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

Lub możemy skorzystać z funkcji toString Object . Może to być przydatne, jeśli musimy sprawdzić inne typy, a także powiedzieć w instrukcji switch, ponieważ ta metoda obsługuje również inne typy danych, podobnie jak 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]"    

Bardziej niezawodnym rozwiązaniem jest w ogóle nie wykrywanie łańcucha, a jedynie sprawdzanie, jaka funkcjonalność jest wymagana. Na przykład:

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, );
}

Porównywanie ciągów leksykograficznych

Aby porównać ciągi alfabetycznie, użyj localeCompare() . Zwraca wartość ujemną, jeśli łańcuch referencyjny jest leksykograficznie (alfabetycznie) przed porównywanym łańcuchem (parametr), wartość dodatnią, jeśli występuje później, i wartość 0 jeśli są równe.

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

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

Operatory > i < mogą być również użyte do porównania ciągów leksykograficznych, ale nie mogą zwrócić wartości zero (można to sprawdzić za pomocą operatora == równości). W rezultacie można zapisać postać funkcji localeCompare() sposób:

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

Jest to szczególnie przydatne, gdy używana jest funkcja sortowania, która porównuje na podstawie znaku wartości zwracanej (np. sort ).

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

Ciąg do wielkich liter

String.prototype.toUpperCase ():

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

Ciąg do małych liter

String.prototype.toLowerCase ()

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

Licznik słów

Załóżmy, że masz <textarea> i chcesz uzyskać informacje o liczbie:

• Znaki (ogółem)
• Znaki (bez spacji)
• Słowa
• Linie

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)

Przykład jsFiddle

Uzyskaj dostęp do znaku w indeksie w ciągu

Użyj charAt() aby uzyskać znak o określonym indeksie w ciągu.

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

Alternatywnie, ponieważ łańcuchy można traktować jak tablice, użyj indeksu za pomocą notacji nawiasowej .

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

Aby uzyskać kod znaku pod określonym indeksem, użyj charCodeAt() .

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

Zauważ, że wszystkie te metody są metodami pobierającymi (zwracają wartość). Ciągi w JavaScript są niezmienne. Innymi słowy, żaden z nich nie może być użyty do ustawienia znaku na pozycji w ciągu.

Ciąg Znajdź i zamień funkcje

Aby wyszukać ciąg w ciągu, istnieje kilka funkcji:

indexOf( searchString ) i lastIndexOf( searchString )

indexOf() zwróci indeks pierwszego wystąpienia searchString w ciągu. Jeśli nie znaleziono searchString , zwracane jest -1 .

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

Podobnie lastIndexOf() zwróci indeks ostatniego wystąpienia searchstring lub -1 jeśli nie zostanie znaleziony.

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

includes( searchString, start )

includes() zwróci wartość logiczną, która mówi, czy w searchString istnieje searchString , zaczynając od indeksu start (domyślnie 0). Jest to lepsze niż indexOf() jeśli po prostu trzeba przetestować pod kątem istnienia podłańcucha.

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

replace( regexp|substring, replacement|replaceFunction )

replace() zwraca ciąg znaków, który ma wszystkie wystąpienia podciągów pasujących do RegExp regexp lub ciąg substring z ciągiem replacement lub zwracanej wartości replaceFunction .

Zauważ, że to nie modyfikuje łańcucha w miejscu, ale zwraca łańcuch z zamiennikami.

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 może być używany do wymiany warunkowych dla stałych obiektów ekspresyjnymi (tj z użytku z regexp ). Parametry są w następującej kolejności:

Pamiętaj, że wszystkie parametry są opcjonalne.

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!"

Znajdź indeks podciągu w ciągu

Metoda .indexOf zwraca indeks podłańcucha w innym ciągu (jeśli istnieje lub -1, jeśli inaczej)

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

.indexOf akceptuje również dodatkowy argument numeryczny wskazujący, na jakim indeksie powinna zacząć szukać funkcja

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

Należy pamiętać, że w .indexOf jest .indexOf liter

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

Ciąg reprezentacji liczb

JavaScript ma natywną konwersję z liczby na reprezentację ciągu dla dowolnej bazy od 2 do 36 .

Najpopularniejsza reprezentacja po przecinku (podstawa 10) jest szesnastkowa (podstawa 16) , ale zawartość tej sekcji działa dla wszystkich baz w zakresie.

Aby przekonwertować liczbę z dziesiętnej (podstawa 10) na jej szesnastkową (podstawa 16) Ciąg znaków , można zastosować metodę toString z podstawką 16 .

// base 10 Number
var b10 = 12;

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

Jeśli reprezentowana liczba jest liczbą całkowitą, odwrotną operację można wykonać ponownie za pomocą parseInt i podstawki 16

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

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

Aby przekonwertować dowolną liczbę (tj. Niecałkowitą) z reprezentacji ciągu na liczbę , operacja musi zostać podzielona na dwie części; część całkowita i część ułamkowa.

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

Uwaga 1: Zachowaj ostrożność, ponieważ mogą wynikać małe błędy z powodu różnic w tym, co można przedstawić w różnych bazach. Pożądane może być później zaokrąglenie.
Uwaga 2: Bardzo długie odwzorowanie liczb może również powodować błędy ze względu na dokładność i maksymalne wartości liczb środowiska, w którym mają miejsce konwersje.

Powtórz ciąg

"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"

Kod znaków

Metoda charCodeAt pobiera kod znaku Unicode pojedynczego znaku:

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

Aby uzyskać kod znaku w ciągu, pozycja znaku oparta na 0 jest przekazywana jako parametr do 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();