Fragezeichenfolge für das ultimative JavaScript-Interview: Ist „105“ größer als „44“? Wie viel wird „123b“ in eine Zahl umgewandelt? Können negative Zahlen an Slice, Substring, Substr usw. übergeben werden?

Vorwort

String ist eine der Grundvariablen in JavaScript und verfügt auch über spezielle Eigenschaften. Seine Variablen können nicht geändert werden . Es gibt zwei Möglichkeiten, Objekte zu erstellen: Nicht-Objekte, zum Beispiel var x = „Bill“; Objekte, zum Beispiel var y = new String(“Bill“). Wenn eine Zeichenfolge mithilfe einer Nicht-Objekt-Methode erstellt wird, wird auf dem Stapel ein Zeiger gespeichert, der auf eine Konstante im String-Pool zeigt. Wenn eine Zeichenfolge mithilfe einer Objektmethode erstellt wird, wird auf dem Stapel ein Zeiger gespeichert, der auf ein String-Objekt zeigt im Haufen.
Hinweis: Führen Sie Vorgänge wie Hinzufügungen, Löschungen und Ersetzungen nicht häufig an einer Zeichenfolgenvariablen aus, da String eine unveränderliche Variable ist und Vorgänge wie Hinzufügungen, Löschungen und Ersetzungen im Wesentlichen die Erstellung und Zerstörung mehrerer Objekte darstellen. Häufige Vorgänge wirken sich darauf aus Leistung.

1. Vergleich von Saiten

1.Gleichheitsvergleich

var x = "Bill";             
var y = new String("Bill");
var z = "Bill";
x == y // true
x === y // false
x === z // true

Nichtobjektzeichenfolgen vergleichen die Werte im String-Konstantenpool, während Objektzeichenfolgen Zeigeradressen vergleichen.
Darüber hinaus verwenden Sie beim Erstellen von Zeichenfolgenvariablen diese bitte nicht newzum Erstellen, da dies die Ausführungsgeschwindigkeit verlangsamt.

2. Größenvergleich

Der Vergleich zwischen Zeichenfolgen besteht darin, zunächst die ASCII-Codes der Zeichenfolgen der Reihe nach zu nehmen und dann zu bestimmen, welcher ASCII-Code zuerst größer ist. Um Zeichen in ASCII-Code umzuwandeln: verwenden Sie charCodeAt(); um Zeichen in ASCII-Code umzuwandeln: verwenden Sie fromCharCode();

"105" > "44" // false
"1" > "0987" // true
"1.00004a" > "1.00004b" // false
"absffz" > "absffA" // true

Der Vergleich beginnt mit dem ASCII-Code des ersten Zeichens. Wenn der Vergleich nicht ermittelt werden kann, wird das zweite Zeichen verglichen und so weiter.
大写字母A 到Z 的值是从65 到90，小写a到z 是从91 到 122.
Den spezifischen Codestempel jedes Zeichens finden Sie hier .
Vergleiche zwischen Zeichenfolgen und Zahlen finden Sie in diesem Artikel

Beispiel: Wenn die Datumstypformate gleich sind, können Sie die Größe des Zeichenfolgenformats direkt vergleichen, um die Größe des Datums zu bestimmen, zum Beispiel: „2020-05-01“ > „2020-04-02“

2. Konvertieren Sie einen String in eine Zahl

Es stehen fünf Methoden zur Verfügung: Number(), parseInt(), parseFloat(), new Number(), * | / 1 Es wird
empfohlen, die automatische implizite Konvertierung in das digitale Format zu verwenden * | / 1, da diese am effizientesten ist. Die Verwendung wird nicht empfohlen Die neue Objekterstellungsmethode Number() ist die am wenigsten effiziente

var a = "123.01"
var b = "123.01abc"
var c = "a123.01bc"
var d = "abc123"
Number(a) // 123.01
Number(b) // NaN 
Number(c) // NaN
Number(d) // NaN
parseInt(a) // 123
parseInt(b) // 123
parseInt(c) // NaN
parseInt(d) // NaN
parseFloat(a) // 123.01
parseFloat(a) // 123.01
parseFloat(a) // NaN
parseFloat(a)// NaN

Number(" 123 ") // 123
parseInt(" 123 ") // 123
parseFloat(" 123  ") // 123
// * | /
a*1 , a/1 // 和Number结果一致

Zusammenfassung: Number konvertiert Zeichen mit nicht leeren und nicht numerischen Zeichen in NaN. parseInt und parseFloat analysieren Zeichen, die nicht leer und nicht numerisch sind, und konvertieren sie gleichzeitig in NaN. Der Unterschied besteht darin, dass sie die Zeichen abfangen Wert der vorherigen Zahl. * | / 1 hat das gleiche Ergebnis wie Number.

3. Strings addieren und subtrahieren

1.Hinzufügen

"ab" + "b" // abb
"ab" + "cd" // abcd

2. Subtraktion

"ab" - "b" // NaN
"ab" - "cd" // NaN
"123" - "12" // 111

Addition und Subtraktion mit Nicht-Strings können ☞Siehe diesen Artikel

4. Häufige Betriebsszenarien wie das Abfangen und Ersetzen von Zeichenfolgen

1. Szene 1, Abfangen

(1) Scheibe

Syntax: stringObject.slice(start,end)
start Der Startindex des zu extrahierenden Slice. Wenn es sich um eine negative Zahl handelt, gibt dieser Parameter die Position ab dem Ende der Zeichenfolge an. Das heißt, -1 bezieht sich auf das letzte Zeichen der Zeichenfolge, -2 bezieht sich auf das vorletzte Zeichen und so weiter. end Der Index
unmittelbar nach dem Ende des zu extrahierenden Segments . Wenn dieser Parameter nicht angegeben ist, umfasst die zu extrahierende Teilzeichenfolge die Zeichenfolge vom Anfang bis zum Ende der ursprünglichen Zeichenfolge. Wenn dieser Parameter negativ ist, gibt er die Position vom Ende der Zeichenfolge an.

// 正数
"abcd".slice(0) //"abcd"
"abcd".slice() //"abcd"
"abcd".slice(1,5) //"bcd"
"abcd".slice(5,1) //""
// 负数时从右向左数数
//start=-1从d开始，最后一位，end接受正数大于0，或者不传，其他为空
"abcd".slice(-1) // "d"
"abcd".slice(-1,1) //"d"
"abcd".slice(-1,2) //"d"
"abcd".slice(-1,-1) // "" 
"abcd".slice(-1,-2) // ""
//start=-3从b开始，end接受负数>=-2正数大于1，其他为空
"abcd".slice(-3,-2) // "b"
"abcd".slice(-3,-1) // "bc"
"abcd".slice(-3,2) // "b"
"abcd".slice(-3,3) // "bc"
//start=1从b开始，end接受负数>=-2正数大于1，其他为空（和上面的例子原理一样）
"abcd".slice(1,-2) // "b"
"abcd".slice(1,-1) // "bc"
"abcd".slice(1,2) // "b"
"abcd".slice(1,3) // "bc"

Beschreibung:
Die Methode „slice()“ kann einen bestimmten Teil einer Zeichenfolge extrahieren und den extrahierten Teil als neue Zeichenfolge zurückgeben.
Die String-Objektmethoden „slice()“, „substring()“ und „substr()“ (veraltet) geben alle einen angegebenen Teil eines Strings zurück. Slice() ist flexibler als Substring(), da es negative Zahlen als Argumente zulässt. Slice() unterscheidet sich von substr() dadurch, dass es zwei Zeichenpositionen verwendet, um eine Teilzeichenfolge anzugeben, während substr() Zeichenpositionen und Länge verwendet, um eine Teilzeichenfolge anzugeben.
Beachten Sie auch, dass String.slice() Array.slice() ähnelt.

(2) Teilzeichenfolge

Syntax: stringObject.substring(start,stop)
start Erforderlich. Eine nicht negative Ganzzahl, die die Position des ersten Zeichens der Teilzeichenfolge angibt, die in stringObject extrahiert werden soll. Es wurde festgestellt, dass negative Zahlen dem Übergeben von 0 entsprechen , was bedeutungslos ist.
Stopp
ist optional. Eine nicht negative Ganzzahl, die um 1 größer ist als das letzte Zeichen der Teilzeichenfolge, die in stringObject extrahiert werden soll.
Wenn dieser Parameter weggelassen wird, wird die zurückgegebene Teilzeichenfolge an das Ende der Zeichenfolge verschoben. Es wurde festgestellt, dass negative Zahlen dem Übergeben von 0 entsprechen , was bedeutungslos ist.

// 正数
"abcd".substring(0) //"abcd"
"abcd".substring() //"abcd"
"abcd".substring(1,5) //"bcd"
"abcd".substring(1,2) // "b"
"abcd".substring(5,1) //"bcd"
"abcd".substring(4,2) //"cd"
// 传负数时不报错，但结果非臆想的,相当于0
"abcd".substring(-1) //"abcd"
"abcd".substring(-1,5) //"abcd"
"abcd".substring(1,-5) // "a"
"abcd".substring(1,0) //"a"
"abcd".substring(-1,-5) // ""
"abcd".substring(0,0) // ""

(3)substr

Syntax: stringObject.substr(start,length)
start Erforderlich. Der Startindex der zu extrahierenden Teilzeichenfolge. Muss ein numerischer Wert sein. Wenn dieser Parameter negativ ist, deklariert er die Position ab dem Ende der Zeichenfolge. Das heißt, -1 bezieht sich auf das letzte Zeichen in der Zeichenfolge, -2 bezieht sich auf das vorletzte Zeichen und so weiter.
Die Länge ist optional. Die Anzahl der Zeichen in der Teilzeichenfolge. Muss ein numerischer Wert sein. Wenn dieser Parameter weggelassen wird, wird die Zeichenfolge vom Anfang bis zum Ende von stringObject zurückgegeben. Gibt eine leere Zeichenfolge zurück, wenn es sich um eine negative Zahl handelt

// 正数
"abcd".substr(0) //"abcd"
"abcd".substr() //"abcd"
"abcd".substr(1,5) //"bcd"
// 负数
"abcd".substr(-1) //"d"
"abcd".substr(-1,5) //"d"
"abcd".substr(-2,1) // "c"
"abcd".substr(-2,-1) // ""
"abcd".substr(2,-1) // ""

Hinweis:
Die Parameter von substr() geben die Startposition und Länge des Teilstrings an, sodass er anstelle von substring() und Slice() verwendet werden kann. start kann sinnvollerweise eine negative Zahl sein.
Wichtig: ECMAscript standardisiert diese Methode nicht und rät daher von ihrer Verwendung ab.
Wichtig: In IE 4 ist der Wert des Parameters start ungültig. In diesem BUG gibt start die Position des 0. Zeichens an. In späteren Versionen wurde dieser Fehler behoben.

Zusammenfassung (ich verstehe es klar, nachdem ich es gelesen habe):

1.slice第一个参数和第二个参数都是字符串的索引值，都可为负数，代表反向的；其返回的子字符串必须是从左到有的，即第二个参数的索引不可以在第一个索引的前面，否则为空
2.substring第一个参数和第二个参数都是字符串的索引值，但是负数特殊相当于0，不代表反向的索引；比slice而言第二个索引可以在第一个索引前面 3.substr ECMAscript标准化没有标准化，不建议用；第一个参数为字符串的索引值，可以为负数，代表反向的索引，第二个参数为截取字符串的长度，因此为负数时相当于0，返回空字符串

2. Szenario 2. Ersatz

Ersetzungssyntax: stringObject.replace(regexp/substr,replacement)
regexp/substr
ist erforderlich. Ein RegExp-Objekt, das die zu ersetzende Teilzeichenfolge oder das zu ersetzende Muster angibt.
Beachten Sie, dass der Wert, wenn er eine Zeichenfolge ist, als literales Textmuster abgerufen wird und nicht zunächst in ein RegExp-Objekt konvertiert wird.
Ersatz erforderlich. Ein Zeichenfolgenwert. Gibt Funktionen zum Ersetzen von Text oder zum Generieren von Ersatztext an.

// 将把 "Doe, John" 转换为 "John Doe" 的形式
let name = "Doe, John";
name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1");
// 将把所有的花引号替换为直引号：
name = '"a", "b"';
name.replace(/"([^"]*)"/g, "'$1'");
// 把字符串中所有单词的首字母都转换为大写：
name = 'aaa bbb ccc';
uw=name.replace(/\b\w+\b/g, function(word){
    
    
  return word.substring(0,1).toUpperCase()+word.substring(1);}
  );

Groß-/Kleinschreibung: String in Kamel-Groß-/Kleinschreibung umwandeln

var str="border-bottom-color";
function convertToCamelCase(str) {
    
    
 return str.replace(/-(\w)/g, function($0, $1) {
    
    
    return $1.toUpperCase();
  });
};
convertToCamelCase(str);

Hinweis:
Ersetzung kann eine Zeichenfolge oder eine Funktion sein. Wenn es sich um eine Zeichenfolge handelt, wird jede Übereinstimmung durch die Zeichenfolge ersetzt. Aber das ersetzende $-Zeichen hat eine bestimmte Bedeutung. Wie in der folgenden Tabelle dargestellt, wird veranschaulicht, dass die aus dem Mustervergleich erhaltene Zeichenfolge zum Ersetzen verwendet wird.

Charakter	Ersatztext
1 $、2 $、…、99 $	Text, der den Unterausdrücken 1 bis 99 im regulären Ausdruck entspricht.
$&	Teilzeichenfolge, die mit regulärem Ausdruck übereinstimmt.
$`	Der Text links von der übereinstimmenden Teilzeichenfolge.
$'	Der Text rechts neben der übereinstimmenden Teilzeichenfolge.
$$	Direktes Mengensymbol.

3. Szenario 3, Objekt- und String-Konvertierung

var obj={
    
    "a":"dt","b":"yuiyi"}
var obj1={
    
    "a":"dt","b":{
    
    "a":"dt"}}
var str = JSON.stringify(obj) // '{"a":"dt","b":"yuiyi"}'
var str1 = JSON.stringify(obj1) //'{"a":"dt","b":{"a":"dt"}}'
JSON.parse(str) // {a: "dt", b: "yuiyi"}
JSON.parse(str1) //{a: "dt", b: {…}}

Es kann zum flachen Kopieren von Objekten und zur serialisierten Parameterübergabe von Objekten verwendet werden, beispielsweise zum Weiterleiten von Abfrageparametern in Vue.

4. Szenario 4, String-Regularisierung

Strings unterstützen 4 reguläre Methoden

API	beschreiben
übereinstimmen()	Findet eine Übereinstimmung für einen oder mehrere reguläre Ausdrücke.
ersetzen()	Ersetzt einen Teilstring, der einem regulären Ausdruck entspricht.
suchen()	Rufen Sie Werte ab, die einem regulären Ausdruck entsprechen.
Teilt()	String in String-Array aufteilen

Informationen zur spezifischen Verwendung finden Sie unter w3school

5. Szenario 5. Übersetzung

1. Escape-Zeichen in einer Zeichenfolge nicht unnötig maskieren, warum? Backslashes beeinträchtigen die Lesbarkeit und sollten daher nur bei Bedarf angezeigt werden.

// bad
const foo = '\'this\' \i\s \"quoted\"';

// good
const foo = '\'this\' is "quoted"';
const foo = `my name is '${
      
      name}'`;

2. Bei regulären Ausdrücken und Sonderzeichenverwendungen wie \nline Feed, \ttab usw. muss Escapezeichen hinzugefügt werden.

Code	Ergebnis
\B	Rücktaste
\F	Seitenwechsel
\N	neue Bank
\r Geben Sie ein
\T	horizontale Registerkarte
\v	vertikale Registerkarte

// 包含千分位的数字校验
let reg = /^\d{1,3}(,\d{3})*(\.\d{1,2})?$/
// 包含斜杆或者反斜杆校验
let reg1 = /\/|\\/
reg1.test("\\") // true

Referenzen:
https://github.com/airbnb/javascript#strings
https://www.w3school.com.cn/js/js_strings.asp
http://c.biancheng.net/c/ascii/