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

StackOverflow https://stackoverflow.com/questions/145509

  •  02-07-2019
  •  | 
  •  

Frage

Titel ist die ganze Frage. Kann mir jemand einen Grund, warum dies geschieht?

War es hilfreich?

Lösung

Ja - weil es mit dem leeren String beginnt. Tatsächlich tritt die leere Zeichenkette logisch zwischen jedem Paar von Zeichen.

Sagen wir es so: Welche Definition von „beginnt mit“ könnte man geben, dass dies ausschließen? Hier ist eine einfache Definition von „beginnt mit“ das bedeutet nicht:

"x beginnt mit y, wenn die ersten y.Length Zeichen von x Spiel von y jene."

Eine alternative (äquivalente) Definition:

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

Andere Tipps

Ich werde versuchen, auf auszuarbeiten, was Jon Skeet sagte.

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

Wenn wir z aufspalten z = x + y zu schreiben, das bedeutet, dass z mit x beginnt. Da kann jeder Zeichenfolge z z geteilt werden = „“ + z folgt daraus, dass jede Saite beginnt mit „“.

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

Dieses Verfahren vergleicht den Wert Parameter den Teilstring zu Beginn dieser Zeichenfolge, die die gleiche Länge wie Wert ist, und einen Wert zurückgibt, der gleich, ob sie anzeigt. Um gleich seinen Wert muss eine leere Zeichenfolge (Leer), ein Verweis auf diese gleiche Instanz oder den Beginn dieser Instanz entsprechen.

.NET String.StartsWith

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

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

Die leere Menge ist eine Teilmenge eines jeden Satzes.

Warum? Die Definition von Untergruppe besagt, dass A eine Teilmenge von B ist, wenn jeder Element A ist ein Element der B. Im Gegensatz dazu A ist nicht eine Teilmenge von B wenn es ein Element von A, der kein Element von B ist.

Jetzt fix einen Satz B. Ich werde feststellen, dass die leere Menge eine Teilmenge von B ist. Ich werde dies tun, indem sie zeigen, dass es nicht der Fall ist, die die leere Menge nicht eine Teilmenge von B ist. Wenn die leere Menge nicht eine Teilmenge von B war dann könnte ich ein Element der leeren Menge finden, die nicht in B ist. Aber die leere Menge hat keine Elemente und somit kann ich nicht ein Element finden, die nicht in B ist. Daher ist es nicht der Fall, dass die leere Menge nicht eine Teilmenge von B ist. Somit muss die leere Menge eine Teilmenge von B sein.

Eine beliebige Zeichenfolge beginnt mit dem leeren String zurück.

Zuerst müssen wir auf unsere Definition von zustimmen beginnt mit . Lassen Sie s und t strings seine Wir sagen, dass s beginnt mit t wenn s.Length >= t.Length und dem ersten t.Length Zeichen von t die s entsprechen. Das heißt, s.Length >= t.Length und für jeden Int32 index so dass 0 <= index < t.Length, s[index] == t[index] ist wahr. Im Gegensatz dazu würden wir sagen, dass s nicht mit t nicht gestartet werden, 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]

ist wahr. Im Klartext, ist s kürzer als t, oder, falls nicht, eine Figur in t es nicht ist, den Charakter als die gleiche Position in s entspricht.

Jetzt fix einen String s. Ich werde das s beginnt mit dem leeren String etablieren. Ich werde dies tun, indem sie zeigen, dass es nicht der Fall ist, die s nicht mit dem leeren String beginnen. Wenn s mit dem leeren String nicht startet 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 gleich Null ist, so ist es unmöglich, s.Length < String.Empty.Length wahr zu sein. Da in ähnlicher Weise `` String.Empty.Lengthis equal to zero, there is noInt32 indexsatisfying0 <= Index

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

ist falsch. Daher ist es nicht der Fall, dass s nicht mit dem leeren String beginnt. So s muss mit dem leeren String beginnen.

Das folgende ist eine Implementierung von beginnt mit als Erweiterung kodiert 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 Fakten sind Beispiele für vacuously wahre Aussagen . Sie sind wahr aufgrund der Tatsache, dass die Aussagen definieren sie ( Untergruppe und beginnt mit ) ist universal-Quantifizierungen über leere Universen. Es sind keine Elemente in der leeren Menge, so kann es keine Elemente der leeren Menge, nicht in einem anderen festen Satz. Es gibt keine Zeichen in dem leeren String, so können es keinen Charakter als eine Position in dem leeren String nicht MATCdas Zeichen in der gleichen Position in einem anderen festen String Hängt.

Sagen wir einfach, "abcd".StartsWith("") false zurück.

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 in anderen Worten ausgedrückt, beginnend die Teil von „ABCD“ an Position 0 und mit 0 Länge gleich der leeren String „“ . Ziemlich logische imo.

In C # ist dies, wie die Spezifikation es sagt zu reagieren;

  

gleich sein, Wert muss eine leere Zeichenkette (leer) sein, einen Verweis auf derselben Instanz oder den Beginn dieser Instanz übereinstimmen.

  

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

Die wirkliche Antwort:

Es hat so seine 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 haben, weil alle Banksoftware, die mit sich selbst zu gleichen Saiten hängt Start werden unsere Konten gemischt und plötzlich Bill Gates meinen Reichtum bekommen haben und ich würde sein müssen, und verdammt noch mal ! Das Schicksal ist einfach nicht diese Art zu mir.

Die ersten N Zeichen der beiden Strings identisch sind. Wobei N die Länge der zweiten Folge, das heißt Null.

Nur für das Protokoll, String.StartsWith() intern ruft die Methode System.Globalization.CultureInfo.IsPrefix(), die die folgenden Kontrolle macht ausdrücklich: 

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

Da eine Zeichenfolge beginnt gut mit "nichts".

Wenn Sie in regulären Ausdrücken Bedingungen daran zu denken, macht es Sinn. Jeder String (nicht nur "ABCD", auch "" und "sdf \ nff"), gibt true zurück, wenn den regulären Ausdruck von ‚beginnt mit leeren String‘ zu bewerten.

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

Wenn Sie die Quellcode rel="nofollow, Sie‘ ll finden spezifische Logik einen leeren String zu behandeln: 

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

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

    if (value.Length == 0)
    {
        return true;
    }
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top