string.indexOf() unter der Haube

Hallo Entwickler!

Heute habe ich versucht, die indexOf()Methode von Grund auf zu implementieren. Bisher habe ich Folgendes gefunden:

<code class="language-javascript">function myIndexOf(string, target, start = 0) {
    let l = target.length;

    // 调整起始索引，如果它是负数
    if (start < 0) {
        start = string.length + start;
    }

    // 确保起始索引在字符串长度范围内
    if (start < 0) {
        start = 0;
    } else if (start >= string.length) {
        return -1; // 目标索引超出字符串范围
    }

    // 循环遍历字符串
    for (let i = start; i <= string.length - l; i++) {
        if (string.substring(i, i + l) === target) {
            return i; // 找到目标子串
        }
    }

    return -1; // 未找到目标子串
}</code>

Code-Erklärung:

Die Methode

indexOf() akzeptiert drei Parameter:

1. string: Die Zeichenfolge, nach der gesucht werden soll.
2. target: Die zu suchende Teilzeichenfolge.
3. start: Der Index, bei dem die Suche beginnt (Standard 0).

Mein erster Versuch:

Meine ursprüngliche Idee war einfach: Durchlaufen Sie die Zeichenfolge und geben Sie string[i] === target zurück, wenn ich i finde. Wenn am Ende der Schleife keine Übereinstimmung gefunden wird, wird -1 zurückgegeben. Der Code lautet wie folgt:

<code class="language-javascript">// 此方法仅适用于单个字符的目标</code>

Diese Methode funktioniert jedoch nur, wenn target ein einzelnes Zeichen ist, da wir Zeichen für Zeichen vergleichen.

Mein zweiter Versuch:

Dann wurde mir klar, dass ich Teilzeichenfolgen vergleichen muss, wenn target länger als ein Zeichen ist. Ich verwende die Methode substr(), um Teilzeichenfolgen zu vergleichen, die dieselbe Länge wie target haben. Die Schleife wird so angepasst, dass sie stoppt, wenn in der Zeichenfolge noch genügend Zeichen für den Vergleich vorhanden sind:

<code class="language-javascript">// 此方法处理多字符目标，但未处理start参数</code>

Mein dritter Versuch:

Als nächstes muss ich den Parameter start bearbeiten, der negativ sein kann. Die integrierte indexOf()-Methode beginnt mit der Suche ab start, wenn string.length start negativ ist. Wenn die Zeichenfolgenlänge beispielsweise 10 beträgt und start -4 ist, beginnt die Suche bei Index 6 (d. h. 10 - 4).

Um dies zu beheben, habe ich den Code aktualisiert, um negative start-Werte zu verarbeiten:

<code class="language-javascript">function myIndexOf(string, target, start = 0) {
    let l = target.length;

    if (start < 0) {
        start = string.length + start;
    }

    // ... (其余代码与第二次尝试相同)
}</code>

Endgültige Version:

Aus Neugier wollte ich start-Werte verarbeiten, die größer als die Zeichenfolgenlänge sind, und habe beschlossen, die Funktion so zu ändern, dass, wenn start die Zeichenfolgenlänge überschreitet, sie weiterhin „umbrochen“ wird Zeichenfolge. Auf diese Weise setzt die Funktion nach dem Umbrechen die Suche ab dem entsprechenden Index fort. Die endgültige Lösung verwendet diese Formel, um den Startindex anzupassen:

<code class="language-javascript">start = (string.length + start) % string.length;</code>

So funktioniert es:

Der
• Modulo-Operatorstart % string.length stellt sicher, dass start im Bereich -string.length bis string.length liegt.
• Hinzugefügt string.length, um sicherzustellen, dass alle negativen Ergebnisse positiv werden.
Die abschließende Modulo-Operation von
• stellt sicher, dass der Wert von start umbrochen wird und innerhalb gültiger Indexgrenzen liegt.

Als nächstes möchte ich die binäre Suche anstelle der linearen Suche verwenden. Was denken Sie?

Das obige ist der detaillierte Inhalt vonstring.indexOf() unter der Haube. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!