Perché & # 8220; abcd & # 8221; .StartsWith (& # 8220; & # 8221;) restituisce vero?

Question

Il titolo è l'intera domanda. Qualcuno può darmi un motivo per cui questo accade?

Answer 1

Sì, perché inizia con la stringa vuota. In effetti, la stringa vuota si presenta logicamente tra ogni coppia di caratteri.

Detto in questo modo: quale definizione di " inizia con " potresti dare che lo precluderebbe? Ecco una semplice definizione di " inizia con " questo non:

" x inizia con y se i primi caratteri y.Length di x corrispondono a quelli di y. "

Una definizione alternativa (equivalente):

" x inizia con y se x.Substring (0, y.Length) .Equals (y) "

Answer 2

Cercherò di approfondire ciò che Jon Skeet ha detto.

Diciamo che x, y e z sono stringhe e + operatore è in effetti concatenazione, quindi:

Se possiamo dividere z per scrivere z = x + y significa che z inizia con x. Perché ogni stringa z può essere divisa in z = " " + z ne consegue che ogni stringa inizia con " " ;.

Quindi, perché ("quot" + "abcd") == "abcd" ne segue che "abcd" inizia con " "

Answer 3

Questo metodo confronta il parametro value con la sottostringa all'inizio di questa stringa che ha la stessa lunghezza del valore e restituisce un valore che indica se sono uguali. Per essere uguale, il valore deve essere una stringa vuota (Vuota), un riferimento a questa stessa istanza o corrispondere all'inizio di questa istanza.

.NET String.StartsWith

vero se la sequenza di caratteri rappresentata dall'argomento è un prefisso della sequenza di caratteri rappresentata da questa stringa; falso altrimenti. Nota anche che true verrà restituito se l'argomento è una stringa vuota o è uguale a questo oggetto String come determinato dal metodo equals (Object).

Java String.startsWith

Answer 4

Inizierò con un fatto correlato che è più facile da capire.

Il set vuoto è un sottoinsieme di ogni set.

Perché? La definizione di sottoinsieme afferma che A è un sottoinsieme di B se ogni elemento di A è un elemento di B . Al contrario, A non è un sottoinsieme di B se esiste un elemento di A che non è un elemento di B .

Ora correggi un set B . Stabilirò che l'insieme vuoto è un sottoinsieme di B . Lo farò mostrando che non è il caso che l'insieme vuoto non sia un sottoinsieme di B . Se il set vuoto non fosse un sottoinsieme di B , allora potrei trovare un elemento del set vuoto che non si trova in B . Ma l'insieme vuoto non ha alcun elemento e quindi non riesco a trovare un elemento che non sia in B . Pertanto, non è possibile che l'insieme vuoto non sia un sottoinsieme di B . Pertanto, l'insieme vuoto deve essere un sottoinsieme di B .

Qualsiasi stringa inizia con la stringa vuota.

Innanzitutto, dobbiamo concordare sulla nostra definizione di inizia con . Sia s e t essere stringa s Diciamo che s inizia con t se s.Length > = t.Length e i primi caratteri t.Length di t corrispondono a quelli di < code> s . Cioè, s.Length > = t.Length e per ogni indice Int32 tale che 0 < = index < t.Length , s [index] == t [index] è vero. Al contrario, diremmo che s non inizia con t se la dichiarazione

s.Length < t.Length o s.Length > = t.Length e c'è un indice Int32 tale che 0 < = index < t.Length e s [indice]! = t [indice]

è vero. In parole povere, s è più corto di t oppure, in caso contrario, in t è presente un carattere che non corrisponde al carattere della stessa posizione in s .

Ora correggi una stringa s . Stabilirò che s inizia con la stringa vuota. Lo farò mostrando che non è il caso che s non inizi con la stringa vuota. Se s non inizia con la stringa vuota, s.Length < String.Empty.Length o s.Length > = String.Empty.Length e esiste un indice Int32 tale che 0 < = indice < String.Empty.Length . Ma s.Length > = 0 e String.Empty.Length è uguale a zero, quindi è impossibile per s.Length < String.Empty.Length per essere vero. Allo stesso modo, poiché `` String.Empty.Length è uguale a zero, non esiste indice Int32 soddisfacente 0 < = index < String.Empty.Length`. Pertanto

s.Length < String.Empty.Length o s.Length > = String.Empty.Length e esiste un indice Int32 tale che 0 < = indice < String.Empty.Length

è falso. Pertanto, non è possibile che s non inizi con la stringa vuota. Pertanto, s deve iniziare con la stringa vuota.

Quella che segue è un'implementazione di inizia con codificato come estensione di stringa .

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;
}

I due fatti in grassetto sopra riportati sono esempi di affermazioni vagamente vere . Sono veri in virtù del fatto che le dichiarazioni che li definiscono ( sottoinsieme e iniziano con ) sono quantificazioni universali su universi vuoti. Non ci sono elementi nel set vuoto, quindi non possono esserci elementi del set vuoto in nessun altro set fisso. Non ci sono caratteri nella stringa vuota, quindi non può esserci un carattere poiché una posizione nella stringa vuota non corrisponde al carattere nella stessa posizione in un'altra stringa fissa.

Answer 5

Diciamo solo " abcd " .StartsWith (" ") restituisce false.

in caso affermativo, quindi a cosa viene valutata la seguente espressione, vero o falso:

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

si scopre che il valore diventa vero, quindi la stringa inizia con la stringa vuota ;-), o in altre parole, la sottostringa di " abcd " a partire dalla posizione 0 e con lunghezza 0 equivale alla stringa vuota "quot". Imo abbastanza logico.

Answer 6

In C # questo è il modo in cui la specifica le dice di reagire;

  

Per essere uguale, valore deve essere una stringa vuota (Vuota), un riferimento a questa stessa istanza o corrispondere all'inizio di questa istanza.

Answer 7

  

Perché "abcd" .StartsWith ("") restituisce true?

LA RISPOSTA REALE:

Dovrebbe essere così, altrimenti avresti il ??caso in cui

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

    but yet

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

e poi avremmo di nuovo Y2K perché tutto il software bancario che dipende da stringhe uguali a partire da loro stessi confonderà i nostri conti e improvvisamente Bill Gates avrà la mia ricchezza e io avrei la sua, e dannazione ! Il destino non è così gentile con me.

Answer 8

I primi N caratteri delle due stringhe sono identici. N è la lunghezza della seconda stringa, ovvero zero.

Answer 9

Solo per la cronaca, String.StartsWith () chiama internamente il metodo System.Globalization.CultureInfo.IsPrefix () che effettua esplicitamente il seguente controllo:

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

Answer 10

Perché una stringa inizia bene con " niente " ;.

Answer 11

Se lo pensi in termini di espressioni regolari, ha senso. Ogni stringa (non solo " abcd " ;, anche " " e " sdf \ nff "), restituisce true quando si valuta l'espressione regolare di "inizia con una stringa vuota".

Answer 12

In C #, il motivo per cui restituisce true è che gli sviluppatori hanno appositamente codificato per questo.

Se dai un'occhiata al codice sorgente , tu ' Troverò una logica specifica per gestire una stringa vuota:

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

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

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