JavaScript
Zeichenketten

Syntax

• "String-Literal"
• 'String-Literal'
• "String-Literal mit 'nicht übereinstimmenden Anführungszeichen'" // keine Fehler; Zitate sind unterschiedlich.
• "String-Literal mit" Escape-Anführungszeichen "" // keine Fehler; Anführungszeichen werden geschützt.
• `Vorlagenzeichenfolge $ {Ausdruck}`
• String ("ab c") // gibt String zurück, wenn er im Nichtkonstruktorkontext aufgerufen wird
• new String ("ab c") // das String-Objekt, nicht das String-Grundelement

Basisinformationen und String-Verkettung

Zeichenfolgen in JavaScript können in einfache Anführungszeichen 'hello' , doppelte Anführungszeichen "Hello" und (ab ES2015, ES6) in Template Literals ( Backticks ) "Hello" `hello` .

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

Zeichenfolgen können mit der Funktion String() aus anderen Typen erstellt werden.

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

Oder toString() kann verwendet werden, um Zahlen, Booleans oder Objekte in Strings zu konvertieren.

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

Zeichenfolgen können auch mithilfe der String.fromCharCode Methode erstellt werden.

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

Das Erstellen eines String-Objekts mit einem new Schlüsselwort ist zulässig, wird jedoch nicht empfohlen, da es sich im Gegensatz zu primitiven Strings wie Objekte verhält.

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

Zeichenketten verketten

Die Verkettung von concat() kann mit dem + Verkettungsoperator oder mit der integrierten Methode concat() für den String-Objektprototyp durchgeführt werden.

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"

Strings können mit Nicht-String-Variablen verkettet werden, konvertieren jedoch die Nicht-String-Variablen in Strings.

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

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

String-Vorlagen

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

Fluchtzitate

Wenn Ihre Zeichenfolge in einfachen Anführungszeichen eingeschlossen ist, müssen Sie das innere wörtliche Anführungszeichen mit einem Backslash \

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

Gleiches gilt für doppelte Anführungszeichen:

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

Wenn Sie HTML-Darstellungen innerhalb eines Strings speichern, muss der Notierung von Anführungszeichen besondere Aufmerksamkeit gewidmet werden, da HTML-Strings häufig in Zitaten verwendet werden, dh in Attributen:

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

Anführungszeichen in HTML-Strings können auch mit ' (oder ' ) als einfaches Zitat und " (oder " ) als Anführungszeichen.

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

Hinweis: Die Verwendung von ' und " überschreibt keine doppelten Anführungszeichen, die Browser automatisch in Anführungszeichen setzen können. Zum Beispiel wird <p class=special> für <p class="special"> , wobei " kann zu <p class=""special""> wobei \" <p class="special"> .

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

Umgekehrte Zeichenfolge

Die "populärste" Methode zum Umkehren einer Zeichenfolge in JavaScript ist das folgende Codefragment, das häufig vorkommt:

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

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

Dies funktioniert jedoch nur, solange die umgedrehte Zeichenfolge keine Ersatzpaare enthält. Astralsymbole, dh Zeichen außerhalb der mehrsprachigen Grundebene, können durch zwei Codeeinheiten dargestellt werden und führen bei dieser naiven Technik zu falschen Ergebnissen. Darüber hinaus erscheinen Zeichen mit Kombinationsmarkierungen (z. B. Diaeresis) auf dem logischen "nächsten" Zeichen anstelle des ursprünglichen, mit dem sie kombiniert wurden.

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

Während die Methode für die meisten Sprachen gut funktioniert, ist ein wirklich genauer Algorithmus für die Umkehrung von Strings etwas komplizierter. Eine solche Implementierung ist eine kleine Bibliothek mit dem Namen Esrever , die reguläre Ausdrücke zum Kombinieren von Markierungen und Ersatzpaaren verwendet, um das Umkehren perfekt durchzuführen.

Erläuterung

Spread-Operator verwenden

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"

Benutzerdefinierte reverse() Funktion

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

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

Leerraum abschneiden

Verwenden Sie String.prototype.trim um Leerzeichen von den Kanten einer Zeichenfolge zu String.prototype.trim :

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

Viele JavaScript-Engines, jedoch nicht Internet Explorer , haben nicht standardmäßige trimLeft und trimRight Methoden trimRight . Derzeit befindet sich auf Stufe 1 des Prozesses ein Vorschlag für standardisierte trimStart und trimEnd Methoden, die aus Gründen der trimLeft auf trimLeft und trimRight sind.

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

Substrings mit Scheibe

Verwenden Sie .slice() , um Teilzeichenfolgen mit zwei Indizes zu extrahieren:

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

Bei einem Index wird es von diesem Index bis zum Ende der Zeichenfolge dauern:

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

Einen String in ein Array aufteilen

Verwenden Sie .split , um von Zeichenfolgen zu einem Array der geteilten Teilzeichenfolgen zu gelangen:

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

Verwenden Sie die Array-Methode .join , um zu einer Zeichenfolge zurückzukehren:

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

Strings sind Unicode

Alle JavaScript-Strings sind Unicode!

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

In JavaScript gibt es keine rohen Bytes oder binären Zeichenfolgen. Verwenden Sie typisierte Arrays , um mit binären Daten effektiv umzugehen .

Eine Zeichenfolge erkennen

Um festzustellen, ob ein Parameter eine primitive Zeichenfolge ist, verwenden Sie typeof :

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

Wenn Sie jemals ein String Objekt über einen new String("somestr") , funktioniert das obige nicht. In diesem Fall können wir instanceof :

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

Um beide Fälle abzudecken, können wir eine einfache Hilfsfunktion schreiben:

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

Oder wir können die toString Funktion von Object . Dies kann nützlich sein, wenn in einer switch-Anweisung auch nach anderen Typen gesucht werden muss, da diese Methode ebenso wie typeof andere Datentypen unterstützt.

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

Eine robustere Lösung ist, einen String überhaupt nicht zu erkennen , sondern nur zu prüfen, welche Funktionalität erforderlich ist. Zum Beispiel:

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

Zeichenketten Lexikographisch vergleichen

Verwenden Sie localeCompare() um Zeichenfolgen alphabetisch zu vergleichen. Dies gibt einen negativen Wert zurück, wenn der Referenzstring lexikographisch (alphabetisch) vor dem verglichenen String (dem Parameter) steht, einen positiven Wert, wenn er danach kommt, und einen Wert von 0 wenn sie gleich sind.

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

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

Die Operatoren > und < können auch verwendet werden, um Zeichenfolgen lexikographisch zu vergleichen, sie können jedoch keinen Wert Null zurückgeben (dies kann mit dem Gleichheitsoperator == getestet werden). Folglich kann eine Form der localeCompare() Funktion folgendermaßen geschrieben werden:

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

Dies ist besonders nützlich, wenn Sie eine Sortierfunktion verwenden, die das Vorzeichen des Rückgabewerts (z. B. sort ) vergleicht.

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

String zu Großbuchstaben

String.prototype.toUpperCase ():

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

String zu Kleinbuchstaben

String.prototype.toLowerCase ()

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

Wortzähler

Angenommen, Sie haben ein <textarea> und möchten Informationen über die Anzahl der folgenden Informationen abrufen:

• Zeichen (insgesamt)
• Zeichen (keine Leerzeichen)
• Wörter
• Linien

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

Zugriffszeichen am Index in Zeichenfolge

Verwenden Sie charAt() , um ein Zeichen am angegebenen Index in der Zeichenfolge charAt() .

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

Da Zeichenfolgen wie Arrays behandelt werden können, verwenden Sie den Index alternativ über Klammern .

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

Um den Zeichencode des Zeichens an einem angegebenen Index charCodeAt() , verwenden Sie charCodeAt() .

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

Beachten Sie, dass diese Methoden Getter-Methoden sind (geben Sie einen Wert zurück). Zeichenfolgen in JavaScript sind unveränderlich. Mit anderen Worten, keines von ihnen kann verwendet werden, um ein Zeichen an einer Position in der Zeichenfolge zu setzen.

Funktionen zum Suchen und Ersetzen von Zeichenfolgen

Um nach einem String innerhalb eines Strings zu suchen, gibt es mehrere Funktionen:

indexOf( searchString ) und lastIndexOf( searchString )

indexOf() gibt den Index des ersten Vorkommens von searchString in der Zeichenfolge zurück. Wenn searchString nicht gefunden wird, wird -1 zurückgegeben.

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

In ähnlicher Weise gibt lastIndexOf() den Index des letzten Vorkommens von searchstring oder -1 wenn er nicht gefunden wird.

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

includes( searchString, start )

includes() ein boolean zurück , die angibt , ob searchString im String vorhanden ist , aus dem Index Start start (Standard : 0) gewonnen . Dies ist besser als indexOf() wenn Sie lediglich das Vorhandensein einer indexOf() testen müssen.

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

replace( regexp|substring, replacement|replaceFunction )

replace() zurückkehren wird eine Zeichenfolge , die alle Vorkommen von Teilstrings hat passend zur RegExp regexp oder String substring mit einem String - replacement oder den Rückgabewert von replaceFunction .

Beachten Sie, dass dies die Zeichenfolge nicht ändert, sondern die Zeichenfolge mit Ersetzungen zurückgibt.

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 kann für bedingte Ersetzungen für reguläre Ausdrucksobjekte verwendet werden (z. B. bei Verwendung von regexp ). Die Parameter sind in der folgenden Reihenfolge:

Beachten Sie, dass alle Parameter optional sind.

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

Suchen Sie den Index einer Teilzeichenfolge in einer Zeichenfolge

Die .indexOf Methode gibt den Index eines Teilstrings innerhalb einer anderen Zeichenfolge zurück (falls vorhanden oder -1, falls nicht anders angegeben).

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

.indexOf akzeptiert auch ein zusätzliches numerisches Argument, das angibt, nach welchem ​​Index die Funktion suchen soll

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

Sie sollten beachten, dass .indexOf die Groß- und Kleinschreibung .indexOf

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

String-Darstellungen von Zahlen

JavaScript hat eine native Konvertierung von Number in seine String-Darstellung für jede Basis von 2 bis 36 .

Die häufigste Darstellung nach dem Dezimalzeichen (Basis 10) ist hexadezimal (Basis 16) . Der Inhalt dieses Abschnitts funktioniert jedoch für alle Basen im Bereich.

Damit kann eine Anzahl von dezimal (Basis 10) auf , es ist hexadezimal (Basis 16) String toString Darstellung der Methode zur Umwandlung mit radix verwendet wird 16 .

// base 10 Number
var b10 = 12;

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

Wenn die dargestellte Zahl eine ganze Zahl ist, kann die inverse Operation hierfür erneut mit parseInt und der parseInt 16 werden

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

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

Um eine beliebige Zahl (dh eine nicht ganzzahlige Zahl) aus ihrer String-Darstellung in eine Zahl zu konvertieren, muss die Operation in zwei Teile aufgeteilt werden. der ganzzahlige Teil und der Bruchteil.

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

Hinweis 1: Seien Sie vorsichtig, da kleine Fehler im Ergebnis auftreten können, da sich die Darstellungen in unterschiedlichen Basen unterscheiden können. Es kann wünschenswert sein, anschließend eine Art Rundung durchzuführen.
Hinweis 2: Sehr lange Darstellungen von Zahlen können aufgrund der Genauigkeit und der Maximalwerte der Zahlen der Umgebung, in der die Konvertierungen stattfinden, zu Fehlern führen.

Wiederholen Sie einen String

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

Zeichencode

Die Methode charCodeAt ruft den Unicode-Zeichencode eines einzelnen Zeichens ab:

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

Um den Zeichencode eines Zeichens in einer Zeichenfolge zu erhalten, wird die 0-basierte Position des Zeichens als Parameter an 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();