Warum gibt "abcd" .StartsWith ("") true zurück?

Titel ist die gesamte Frage. Kann mir jemand einen Grund nennen, warum dies passiert?

Ja - weil es mit der leeren Zeichenfolge beginnt. In der Tat tritt die leere Zeichenfolge logischerweise zwischen jedem Zeichenpaar auf.

Sagen wir es so: Welche Definition von "beginnt mit" könnten Sie geben, die dies ausschließen würde? Hier ist eine einfache Definition von "beginnt mit", die dies nicht tut:

"x beginnt mit y, wenn die ersten y.LengthZeichen von x mit denen von y übereinstimmen."

Eine alternative (äquivalente) Definition:

"x beginnt mit y wenn x.Substring(0, y.Length).Equals(y)"

Ich werde versuchen, näher auf das einzugehen, was Jon Skeet gesagt hat.

Angenommen, x, y und z sind Zeichenfolgen, und der Operator + ist tatsächlich eine Verkettung.

Wenn wir z teilen können, um z = x + y zu schreiben, bedeutet dies, dass z mit x beginnt. Da jede Zeichenfolge z in z = "" + z aufgeteilt werden kann, beginnt jede Zeichenfolge mit "".

Also, weil ("" + "abcd") == "abcd" folgt, dass "abcd" mit "" beginnt

Diese Methode vergleicht den Wertparameter mit der Teilzeichenfolge am Anfang dieser Zeichenfolge, die dieselbe Länge wie der Wert hat, und gibt einen Wert zurück, der angibt, ob sie gleich sind. Um gleich zu sein, muss der Wert eine leere Zeichenfolge (leer) sein, ein Verweis auf dieselbe Instanz oder mit dem Anfang dieser Instanz übereinstimmen.

.NET String.StartsWith

true, wenn die durch das Argument dargestellte Zeichenfolge ein Präfix der durch diese Zeichenfolge dargestellten Zeichenfolge ist; sonst falsch. Beachten Sie auch, dass true zurückgegeben wird, wenn das Argument eine leere Zeichenfolge ist oder diesem Zeichenfolgenobjekt entspricht, wie durch die Methode equals (Object) bestimmt.

Java String.startsWith

Ich beginne mit einer verwandten Tatsache, die leichter zu verstehen ist.

Die leere Menge ist eine Teilmenge jeder Menge.

Warum? Die Definition der Teilmenge gibt an, dass Aes sich um eine Teilmenge handelt, Bwenn jedes Element von Aein Element von ist B. Umgekehrt Aist keine Teilmenge von, Bwenn es ein Element gibt A, das kein Element von ist B.

Korrigieren Sie jetzt einen Satz B. Ich werde feststellen, dass die leere Menge eine Teilmenge von ist B. Ich werde dies tun, indem ich zeige, dass es nicht so ist, dass die leere Menge keine Teilmenge von ist B. Wenn die leere Menge keine Teilmenge von wäre, Bkönnte ich ein Element der leeren Menge finden, das nicht enthalten ist B. Aber die leere Menge hat keine Elemente und daher kann ich kein Element finden, das nicht in ist B. Daher ist es nicht der Fall, dass die leere Menge keine Teilmenge von ist B. Daher muss die leere Menge eine Teilmenge von sein B.

Jede Zeichenfolge beginnt mit der leeren Zeichenfolge.

Zunächst müssen wir uns auf unsere Definition von Starts mit einigen . Lass sund tsei strings Wir sagen, dass das s mit t if beginnts.Length >= t.Length und die ersten t.LengthZeichen tmit denen von übereinstimmen s. Das heißt, s.Length >= t.Lengthund für jeden , Int32 indexso dass 0 <= index < t.Length, s[index] == t[index]wahr ist . Umgekehrt würden wir sagen, dass sdas nicht mit tder Aussage beginnt

s.Length < t.Lengthoder s.Length >= t.Lengthund es gibt eine Int32 indexsolche, dass 0 <= index < t.Lengthunds[index] != t[index]

ist wahr. Ist im Klartext skürzer als toder, falls nicht, gibt es ein Zeichen, das tnicht mit dem Zeichen an derselben Position übereinstimmt s.

Korrigieren Sie nun eine Zeichenfolge s. Ich werde feststellen, dass dies smit der leeren Zeichenfolge beginnt. Ich werde dies tun, indem ich zeige, dass es nicht der Fall ist, sder nicht mit der leeren Zeichenfolge beginnt. Wenn snicht mit der leeren Zeichenfolge beginnt, danns.Length < String.Empty.Length oder s.Length >= String.Empty.Lengthund es gibt eine Int32 indexsolche, dass 0 <= index < String.Empty.Length. Aber s.Length >= 0und String.Empty.Lengthist gleich Null, so dass es unmöglich ist s.Length < String.Empty.Length, wahr zu sein. In ähnlicher Weise, da `` String.Empty.Length is equal to zero, there is noInt32 Index satisfying0 <= Index <String.Empty.Length`. Deshalb

s.Length < String.Empty.Lengthoder s.Length >= String.Empty.Lengthund es gibt eine Int32 indexsolche, dass0 <= index < String.Empty.Length

ist falsch. Daher ist es nicht der Fall, dass snicht mit der leeren Zeichenfolge begonnen wird. Daher smuss mit der leeren Zeichenfolge beginnen.

Das Folgende ist eine Implementierung von Starts mit codiert als Erweiterung von string.

public static bool DoStartsWith(this string s, string t) {
    if (s.Length >= t.Length) {
        for (int index = 0; index < t.Length; index++) {
            if (s[index] != t[index]) {
                return false;
            }
        }
        return true;
    }
    return false;
}

Die obigen zwei fettgedruckten Tatsachen sind Beispiele für vakuumgetreue Aussagen . Sie sind wahr aufgrund der Tatsache, dass die Aussagen, die sie definieren ( Teilmenge und Beginn mit ), universelle Quantifizierungen über leere Universen sind. Es gibt keine Elemente in der leeren Menge, daher kann es keine Elemente der leeren Menge geben, die nicht in einer anderen festen Menge enthalten sind. Die leere Zeichenfolge enthält keine Zeichen, daher kann es kein Zeichen geben, da eine Position in der leeren Zeichenfolge nicht mit dem Zeichen an derselben Position in einer anderen festen Zeichenfolge übereinstimmt.

Lass uns einfach sagen "abcd".StartsWith("") gibt false zurück.

Wenn ja, was bedeutet der folgende Ausdruck, wahr oder falsch:

 ("abcd".Substring(0,0) == "")

es stellt sich heraus, dass evals true ist, also beginnt die Zeichenfolge mit der leeren Zeichenfolge ;-) oder mit anderen Worten, der Teilstring von "abcd", der an Position 0 beginnt und eine Länge von 0 hat, entspricht der leeren Zeichenfolge "". Ziemlich logisch imo.

In C # sagt die Spezifikation, dass es reagieren soll;

Um gleich zu sein, muss der Wert eine leere Zeichenfolge (leer) sein, ein Verweis auf dieselbe Instanz oder mit dem Anfang dieser Instanz übereinstimmen.

Warum gibt "abcd" .StartsWith ("") true zurück?

DIE WIRKLICHE ANTWORT:

Es muss so sein, sonst hätten Sie den Fall wo

    "".startsWith("") == false 
    "".equals("") == true

    but yet

    "a".startsWith("a") == true
    "a".equals("a") == true

und dann hätten wir wieder Y2K, weil all die Bankensoftware, die von gleichen Zeichenfolgen abhängt, die mit sich selbst beginnen, unsere Konten durcheinander bringt und plötzlich Bill Gates mein Vermögen hat und ich seins haben würde, und verdammt! Das Schicksal ist einfach nicht so nett zu mir.

Die ersten N Zeichen der beiden Zeichenfolgen sind identisch. N ist die Länge der zweiten Zeichenkette, dh Null.

Ruft nur für den Datensatz String.StartsWith()intern die Methode auf System.Globalization.CultureInfo.IsPrefix(), die die folgende Überprüfung explizit durchführt:

if (prefix.Length == 0)
{
    return true;
}

Weil eine Zeichenfolge gut mit "nichts" beginnt.

Wenn Sie es in regulären Ausdrücken betrachten, ist es sinnvoll. Jede Zeichenfolge (nicht nur "abcd", sondern auch "" und "sdf \ nff") gibt true zurück, wenn der reguläre Ausdruck "beginnt mit leerer Zeichenfolge" ausgewertet wird.