Die vorherigen Wörter
Saiten und Arrays haben viele Ähnlichkeiten. Sie haben viele Methoden und sind sehr ähnlich; Aber sie haben Unterschiede. Saiten sind unveränderliche Werte, sodass sie als schreibgeschützte Arrays angesehen werden können. Dieser Artikel vergleicht ähnliche Methoden von Strings und Arrays
Indexierbar
ECMascript5 definiert eine Methode zum Zugriff auf Zeichen mit quadratischen Klammern plus numerische Indizes, um auf bestimmte Zeichen in einer Zeichenfolge zuzugreifen
Der größte Vorteil indexierbarer Zeichenfolgen besteht darin, dass sie einfach sind und Charat () -Anrufe durch quadratische Klammern ersetzen, was prägniser, lesbar und möglicherweise effizienter ist. Nicht nur das, die Tatsache, dass Saiten sich wie Arrays verhalten
Wenn der Parameter außerhalb des Bereichs oder der Nan, undefinierte Ausgabe ist
var str = "hello"; console.log (str [0]); // hconsole.log (str [1]]); // econsole.log (stro [false]); // undefinedConsole.log (STR [-1]); // unddefinedConsole.Log (str [nan]).
var arr = ['H', 'E', 'L', 'L', 'O']; console.log (arr [0]); // Hconsole.log (arr [[1]]); // econsole.log (arr [false]); // un definedConsole.log (arr [-1]); // undefinedconsole.log (arr [nan]); // undefinedconsole.log (arr []); // Bericht Fehler
Konvertieren
Zeichenfolgen können mithilfe der Split () -Methode in Arrays konvertiert werden. Arrays können mit der join () -Methode in Zeichenfolgen umgewandelt werden
【Teilt()】
Die methode split () unterteilt eine Zeichenfolge in mehrere Zeichenfolgen basierend auf dem angegebenen Separator und legt das Ergebnis in ein Array auf. Der Trennzeichen kann eine Zeichenfolge oder ein regulärer Ausdruck sein
Diese Methode kann (optional) einen zweiten Parameter akzeptieren, um die Größe des Arrays anzugeben. Wenn der zweite Parameter ein Wert im Bereich von 0-Array.Length ist, Ausgabe entsprechend dem angegebenen Parameter und in anderen Fällen alle Ergebnisse ausgeben.
Wenn der angegebene Trennzeichen nicht in der Zeichenfolge angezeigt wird, wird der Wert der ursprünglichen Zeichenfolge als Array zurückgegeben.
var colortext = 'rot, blau, grün, gelb'; trsole "e", "l", "l", "l", "o", "w"] console.log (colortext.split (',')); // ["rot", "blau", "grün", "gelb"] console.log (colortext.Split (',', 2); "Blue"] console.log (colortext.split (',', 6); // ["rot", "blau", "grün", "gelb"] console "yellow"]console.log(colorText.split(/e/));//["r", "d,blue", ",gr", "", "n,y", "llow"]console.log(colorText.split(/[^/,]+/));//Change strings other than commas into separators ["", ",",", ",", "","], IE8- wird als [",", ",", ",", ",", ","] erkennen]【verbinden()】
Mit der Methode join () kann verschiedene Grenzwerte verwendet werden, um diese Zeichenfolge zu erstellen. Mit der Methode join () empfängt nur einen Parameter, der als Trennzeichen verwendet wird, und gibt dann eine Zeichenfolge zurück, die alle Array -Elemente enthält.
Wenn kein Wert an die join () -Methode übergeben wird, verwenden Sie ein Komma als Trennzeichen
var a = [1,2,3]; console.log (a.join ()); // '1,2,3'console.log (A.Join (' '); //' 1 2 3'console.log (A.Join (''); // '123'Var B = New New New'n New neu Array (10); B.Join ('-'); // '------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Wenn der Wert eines Elements im Array null oder undefiniert ist, wird der Wert als leerer Zeichenfolge im Ergebnis dargestellt, das von der join () -Methode zurückgegeben wird
var colors = [1, undefiniert, 2, null, 3]; console.log (colors.join ()); // '1,, 2,, 3'
Da Zeichenfolgen Array -Objekte sind, können Sie auch die Joy () -Methode verwenden
console.log (array.prototype.join.call ('hello', '-')); // "Hallo" var str = 'test'; var arr = str.split ('') // ["t", "e", "s", "t"] console.log (arr.join ('-'); // 'Tes-t'Spleißen
Saiten und Arrays teilen die Spleißmethode concat ()
var value = 'hello'; console.log (value.concat ('welt'); // 'helloWorld'console.log (value.concat ([' Welt ']); //' HelloWorld'console.log (value.concat (['Welt']))); var value = ['hello']; console.log (value.concat ('welt')); // ["hello", "world"] console.log (value.concat (['welt']); // ["Hallo", "Welt"] console.log (value.concat (['World'])); ["Welt"] console.log (value.concat (['Welt'])); // ["Hallo", ["Welt"]]erstellen
Beide Saiten und Arrays haben die Erstellungsmethode Slice (), mit der Substrings bzw. SubaRrays erstellt werden.
Die Slice () -Methode erstellt ein neues Array (oder eine Zeichenfolge) basierend auf einem oder mehreren Elementen im aktuellen Array (oder String), akzeptiert ein oder zwei Parameter, dh die Start- und Endpositionen des Elements zurückzugeben und schließlich das neue Array (oder die Zeichenfolge) zurückzugeben.
Die Slice -Methode (Start, End) erfordert zwei Parameter Start und End, die eine Subtarray (oder eine Zeichenfolge) von der Startposition zurückgeben, um in diesem Array (oder String) die Endposition (aber nicht) zu (aber nicht). Wenn das Ende nicht definiert ist oder nicht existiert, gibt es alle Elemente von der Startposition bis zum Ende des Arrays (oder der Zeichenfolge) zurück.
Wenn Start eine negative Zahl ist, start = max (Länge + Start, 0)
Wenn das Ende eine negative Zahl ist, End = max (Länge + Ende, 0)
Start und Ende können Positionen nicht tauschen
var numbers = [1,2,3,4,5]; console.log (Nummern.Slice (2)); // [3,4,5] Konsole.log (Nummern.Slice (2, undefined)); // [3,4,5] Consol E.Log (Nummern.Slice (2,3)); // [3] console.log (number.lice (2,1)); // [] console.log (Nummern.Slice (-3)); //-3+5 = 2 -> [3,4,5] console.log (number.slice (-8)); // max (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (Nummern.Slice (0, -3)); // -3 + 5 = 2 -> [1,2] console.log (nummern.slice (-2, -1)); //-2+5 = 3; -1+5 = 4; -> [4]
var StringValue = 'Hello World'; console.log (StringValue.slice ()); // 'Hello World'console.log (StringValue.Slice (2); //' llo World'console.log (StringValue.Slice (20); // 'console.log (StringValue.Slice (2); World'console.log (StringValue.slice (2, -5)); // 'llo' console.log (StringValue.slice (2, -20)); // '' console.log (StringValue.Slice (-2,2)); console.log (StringValue.slice (-2,20)); // 'ld'console.log (StringValue.slice (-20,2)); //' He'console.log (StringValue.slice (-20, -2)); // Hallo Worl '
Standort
Sowohl Zeichenfolgen als auch Arrays haben zwei Methoden, um Positionen zu finden: Indexof () und lastIndexof (). Die Positionsmethode ist genau das Gegenteil der Klammern [] Lesemethode. Einer besteht darin, den Index durch das Element zu finden, und der andere ist, den Element über den Index zu finden.
【Indexof ()】
Indexof (Search, Start) -Methode empfängt zwei Parametersuche und Start, um den Ort zurückzugeben, an dem die Suche zuerst angezeigt wird. Wenn sie nicht gefunden wird, gibt sie -1 zurück
Der Suchparameter in einer Zeichenfolge ruft die Funktion String () Transformation auf, um den Nicht-Stringwert des Parameters in eine Zeichenfolge umzuwandeln. Während der Suchparameter im Array mit dem strengen Gleichstellungsoperator verglichen wird (===)
Unabhängig davon, ob es sich um ein Array oder ein String handelt, wird der zweite Parameterstart die Number () -Transformationsfunktion implizit aufgerufen und start nicht numerische (außer undefinierte) in numerische Werte konvertiert. Wenn dieser Parameter ignoriert oder der Parameter undefiniert oder NAN ist, start = 0
Wenn der Startparameter eine negative Zahl ist, ist die Verarbeitung der Zeichenfolge zu starten = 0; Während die Verarbeitung des Arrays starten soll = max (0, start+Länge)
var String = 'Hallo Welt World '; console.log (String.Indexof (' ld ')); // 9console.log (String.Indexof (' ld ', undefiniert); // 9console.log (String.Indexof (' ld ', nan); // 9console.log (Indexof (' st ring.indexof ('ld',-1)); // 9console.log (string.indexof ('ld',-1)); // 9console.log (string.indexof ( 'ld',-1)); // 9console.log (string.indexof ('ld',-1)); // 9console.log (String.Indexof ('ld',-1)); // 9 console.log (string.indexof ('ld', 10)); // 15console.log (string.indexof ('ld', [10]); // 15console.log (String.Index Von ('true', [10])); //-1console.log (string.indexof (false, [10])); //-1console.log (String.Indexof (false, [10])); //-1 var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.indexof ('a', undefined)); // 0console.log (arr.indexof ('a', nan); // 0conol E.Log (arr.indexof ('a', 1)); // 5console.log (arr.indexof ('a', true)); // 5console.log (arr.indexof ('a',-1)); // max (0, -1+7) = 6; -1console.log (arr.indexof ('a',-5)); // max (0, -5+7) = 2; 5console.log (arr.indexof ('a',-50)); // max (0, -50+7) = 0; 0【LastIndexof ()】
Im Gegensatz zur Indexof () -Methode besteht die letzte Methode von LastIndexof () darin, von rechts nach links nachzuschlagen.
Die letzte Methode "LastIndexof (Such, Start) empfängt zwei Parametersuche und Start, wobei der Ort zurückgegeben wird, an dem die Suche zuerst angezeigt wird, und wenn sie nicht gefunden wird, gibt sie -1 zurück
In ähnlicher Weise ruft der Suchparameter in einer String die Funktion String () -Transformation auf, um den Nicht-Stringwert des Parameters in eine Zeichenfolge umzuwandeln. Während der Suchparameter im Array unter Verwendung des strengen Gleichstellungsoperators (===) verglichen wird
Unabhängig davon, ob es sich um ein Array oder ein String handelt, wird der zweite Parameterstart die Number () -Transformationsfunktion implizit aufgerufen und start nicht numerische Werte (außer undefiniert) in numerische Werte konvertiert.
Wenn dieser Parameter ignoriert oder der Parameter undefiniert oder NAN ist, ist die Verarbeitung der Zeichenfolgestart = Länge - 1; Während die Verarbeitung des Arrays start = 0 ist
Wenn der Startparameter eine negative Zahl ist, ist die Verarbeitung der Zeichenfolge zu starten = 0; Während die Verarbeitung des Arrays starten soll = max (0, start+Länge)
var String = 'Hallo Welt World '; Console.log (String.LastIndexof (' ld ')); // 15console.log (String.LastIndexof (' Ld ', undefiniert)); // 15console.log (Strin G. Lastindexof ('ld', nan)); // 15console.log (String.LastIndexof ('ld',-1)); //-1console.log (String.LastIndexof ('H',-1); // 0c Onsole.log (String.LastIndexof ('W', undefined)); // 12console.log (String.LastIndexof ('Ld', 10)); // 9console.log (String.Last Indexof ('ld', [10])); // 9console.log (string.lastindexof ('ld', [10])); //-1console.log (String.LastIndexof (Falsch, [10]); //-1 var arr = [1,2,3, '1', '2', '3']; console.log (arr.lastIndexof ('2'); // 4console.log (arr.lastIndexof (3)); // 2console.log (arr.lastIndexof (0)); //-1var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.lastindexof ('b'); // 6console.log (arr.lastindexof ('b', undefined); //-1conol.log (Arr.lastindexof ('A', u nDefined)); // 0console.log (arr.lastindexof ('B', nan)); //-1console.log (arr.lastindexof ('B', 1)); // 1console.log (arr.lastindexof ('B',-1); //mx (0, -1+7) = 6; 6console.log (arr.lastIndexof ('B',-5)); // max (0, -5+7) = 2; 1console.log (arr.lastIndexof ('B',-50)); // max (0, -50+7) = 0; -1Der obige Vergleich von Arrays und String -Methoden in JavaScript ist der gesamte Inhalt, den ich mit Ihnen teile. Ich hoffe, Sie können Ihnen eine Referenz geben und ich hoffe, Sie können wulin.com mehr unterstützen.