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

Question

Titel ist die ganze Frage. Kann mir jemand einen Grund geben, warum das passiert?

Answer 1

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

Sagen Sie 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 nicht:

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

Eine alternative (äquivalente) Definition:

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

Answer 2

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

.NET String.StartsWith

wahr, wenn die Zeichensequenz durch das Argument repräsentierte ein Präfix der Zeichensequenz durch diese Zeichenfolge dargestellt ist; sonst falsch. Beachten Sie auch, dass true zurückgegeben wird, wenn das Argument eine leere Zeichenfolge ist oder gleich diesem String-Objekt ist, wie durch die Methode equals (Object) festgelegt.

Java String.startsWith

Answer 3

die ersten N Zeichen der beiden Strings identisch sind. N ist die Länge der zweiten Kette, d. H. Null.

Answer 4

In C# ist dies die specification sagt es zu reagieren;

Um gleich zu sein, muss value eine leere Zeichenfolge (Empty), eine Referenz auf dieselbe Instanz oder der Anfang dieser Instanz sein.

Answer 5

Weil eine Zeichenfolge gut mit "nichts" beginnt.

Answer 6

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

Answer 7

Ich werde versuchen, auf das, was Jon Skeet sagte, zu erarbeiten.

Lasst uns sagen, x, y und z sind Strings und + Operator ist in der Tat Verkettung, dann gilt:

Wenn wir z aufspalten z = x + y zu schreiben, das bedeutet, dass z mit x beginnt. Da jede Zeichenfolge z in z = "" + z aufgeteilt werden kann, beginnt jede Zeichenfolge mit "".

Also, weil ("" + "abcd") == "ABCD" folgt daraus, daß "ABCD" beginnt mit ""

Answer 8

Lassen Sie uns gerade "abcd".StartsWith("") false zurück sagen.

wenn ja was bedeutet dann der folgende Ausdruck eval, wahr oder falsch:

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

es stellt sich heraus, dass evals auf true, so dass die Zeichenfolge mit dem leeren String startet ;-), oder setzen in Mit anderen Worten, der Teilstring von "abcd", der an der Position 0 beginnt und die Länge 0 hat, ist gleich der leeren Zeichenkette "". Ziemlich logisch imo.

Answer 9

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

Der leere Satz ist eine Teilmenge jedes Satzes.

Warum? Die definition der Untergruppe gibt an, dass A eine Teilmenge von B ist, wenn jedes Element von A ein Element von B ist. Umgekehrt ist A keine Untermenge von B, wenn es ein Element von A gibt, das kein Element von B ist.

Jetzt beheben Sie einen Satz B. Ich werde feststellen, dass die leere Menge eine Teilmenge von B ist. Ich mache das, indem ich zeige, dass es nicht der Fall ist, dass die leere Menge keine Untermenge von B ist. Wenn die leere Menge keine Untermenge von B wäre, dann könnte ich ein Element der leeren Menge finden, das nicht in B ist. Aber die leere Menge hat keine Elemente und daher kann ich kein Element finden, das nicht in B ist. Daher ist die leere Menge keine Untermenge von B. Daher muss die leere Menge eine Teilmenge von B sein.

Jede Zeichenfolge beginnt mit der leeren Zeichenfolge.

Zuerst müssen wir uns auf unsere Definition von beginnt mit. Lassen Sie s und t sein string s Wir sagen, dass sbeginnt mitt wenn s.Length >= t.Length und die ersten t.Length Zeichen von t Match denen s. Das heißt, s.Length >= t.Length und für jeden Int32 index, dass 0 <= index < t.Length, s[index] == t[index] gilt. Im Gegensatz dazu würden wir sagen, dass s nicht mit t startet, wenn die Anweisung

s.Length < t.Length oder s.Length >= t.Length und es gibt eine Int32 index so dass 0 <= index < t.Length und s[index] != t[index]

wahr ist. In normalem Englisch ist s kürzer als t, oder, wenn nicht, gibt es ein Zeichen in t, das nicht mit dem Zeichen als der gleichen Position in s übereinstimmt.

Jetzt beheben Sie eine Zeichenfolge s. Ich werde feststellen, dass s mit der leeren Zeichenfolge beginnt. Ich mache das, indem ich zeige, dass es nicht der Fall ist, dass s nicht mit der leeren Zeichenfolge beginnt. Wenn s nicht mit der leeren Zeichenfolge beginnt, dann s.Length < String.Empty.Length oder s.Length >= String.Empty.Length und es gibt eine Int32 index, so dass 0 <= index < String.Empty.Length. Aber s.Length >= 0 und String.Empty.Length ist gleich Null, so dass es unmöglich ist für s.Length < String.Empty.Length wahr zu sein. Ähnlich, seit `` String.Empty.Länge is equal to zero, there is no Int32 Index = Index < String.Empty.Length`. Daher

s.Length < String.Empty.Length oder s.Length >= String.Empty.Length und es gibt eine Int32 index so dass 0 <= index < String.Empty.Length

falsch ist. Es ist daher nicht der Fall, dass s nicht mit der leeren Zeichenfolge beginnt. Daher muss s mit der leeren Zeichenfolge beginnen.

Das folgende ist eine Implementierung von beginnt mit codiert als eine Erweiterung zu 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 beiden oben genannten bolded Tatsachen sind Beispiele für vacuously true statements. Sie sind wahr aufgrund der Tatsache, dass die sie definierenden Anweisungen (Teilmenge und beginnt mit) universal quantifications ü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. Es gibt keine Zeichen in der leeren Zeichenfolge, daher kann es kein Zeichen geben, da eine Position in der leeren Zeichenfolge nicht mit dem Zeichen in derselben Position in einer anderen festen Zeichenfolge übereinstimmt.

Answer 10

Nur für das Protokoll, ruft String.StartsWith() intern die Methode System.Globalization.CultureInfo.IsPrefix(), die explizit die folgende Überprüfung macht:

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

Answer 11

Warum „ABCD“ .StartsWith („“) return true?

die wirkliche Antwort:

es so sein muss, sonst hat man den Fall haben würde, wo

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

    but yet 

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

und dann würden wir Y2K alle immer wieder, weil alle der Bank Software, die von gleichen Strings abhängt, die mit sich selbst beginnen, wird unsere Konten durcheinander bringen und plötzlich wird Bill Gates meinen Reichtum haben und ich würde seinen haben, und verdammt! Das Schicksal ist nicht so freundlich zu mir.

Answer 12

In C#, der Grund, warum es true zurückgibt, ist, dass die Entwickler speziell dafür codiert.

Wenn Sie die source code Check-out, Sie bestimmte Logik eine leere Zeichenfolge finden zu handhaben:

public Boolean StartsWith(String value) 
{ 
    return StartsWith(value, StringComparison.CurrentCulture); 
} 

public Boolean StartsWith(String value, StringComparison comparisonType) 
{ 
    ... 

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