Pourquoi «abcd» .StartsWith («») renvoie-t-il vrai?

Le titre est toute la question. Quelqu'un peut-il me donner une raison pour laquelle cela se produit?

Oui - car il commence par la chaîne vide. En effet, la chaîne vide apparaît logiquement entre chaque paire de caractères.

Dites-le ainsi: quelle définition de «commence par» pourriez-vous donner qui empêcherait cela? Voici une définition simple de «commence par» qui ne le fait pas:

"x commence par y si les premiers y.Lengthcaractères de x correspondent à ceux de y."

Une définition alternative (équivalente):

"x commence par y si x.Substring(0, y.Length).Equals(y)"

Je vais essayer de développer ce que Jon Skeet a dit.

Disons que x, y et z sont des chaînes et que l'opérateur + est en fait une concaténation, alors:

Si nous pouvons diviser z pour écrire z = x + y, cela signifie que z commence par x. Comme chaque chaîne z peut être divisée en z = "" + z, il s'ensuit que chaque chaîne commence par "".

Donc, parce que ("" + "abcd") == "abcd" il s'ensuit que "abcd" commence par ""

Cette méthode compare le paramètre value à la sous-chaîne au début de cette chaîne qui a la même longueur que value et retourne une valeur qui indique si elles sont égales. Pour être égale, la valeur doit être une chaîne vide (Vide), une référence à cette même instance ou correspondre au début de cette instance.

.NET String.StartsWith

true si la séquence de caractères représentée par l'argument est un préfixe de la séquence de caractères représentée par cette chaîne; faux sinon. Notez également que true sera retourné si l'argument est une chaîne vide ou est égal à cet objet String tel que déterminé par la méthode equals (Object).

Java String.startsWith

Je vais commencer par un fait connexe qui est plus facile à comprendre.

L'ensemble vide est un sous-ensemble de chaque ensemble.

Pourquoi? La définition de sous - ensemble indique qui Aest un sous-ensemble de Bsi chaque élément de Aest un élément de B. Inversement, An'est pas un sous-ensemble de Bs'il y a un élément de Aqui n'est pas un élément de B.

Maintenant, corrigez un ensemble B. Je vais établir que l'ensemble vide est un sous-ensemble de B. Je vais le faire en montrant que ce n'est pas le cas que l'ensemble vide ne soit pas un sous-ensemble de B. Si l'ensemble vide n'était pas un sous-ensemble de, Bje pourrais trouver un élément de l'ensemble vide qui n'est pas dans B. Mais l'ensemble vide ne contient aucun élément et je ne peux donc pas trouver un élément qui ne soit pas dedans B. Par conséquent, il n'est pas vrai que l'ensemble vide ne soit pas un sous-ensemble de B. Ainsi, l'ensemble vide doit être un sous-ensemble de B.

Toute chaîne commence par la chaîne vide.

Premièrement, nous devons nous entendre sur notre définition de commence par . Let sand tbe strings On dit que ça s commence par t if s.Length >= t.Lengthet les premiers t.Lengthcaractères de tcorrespondent à ceux de s. C'est vrai, s.Length >= t.Lengthet pour tout Int32 indexcela 0 <= index < t.Length, s[index] == t[index]c'est vrai. À l'inverse, nous dirions que scela ne commence pas par tsi l'instruction

s.Length < t.Lengthou s.Length >= t.Lengthet il y a un Int32 indextel que 0 <= index < t.Lengthets[index] != t[index]

est vrai. En anglais simple, sest plus court que t, sinon, il y a un caractère qui tne correspond pas au caractère à la même position dans s.

Maintenant, corrigez une chaîne s. Je vais établir que scommence par la chaîne vide. Je vais le faire en montrant que ce n'est pas le cas qui sne commence pas par la chaîne vide. Si sne démarre pas avec la chaîne vide, s.Length < String.Empty.Lengthou s.Length >= String.Empty.Lengthet il y a une Int32 indextelle que 0 <= index < String.Empty.Length. Mais s.Length >= 0et String.Empty.Lengthest égal à zéro, il est donc impossible s.Length < String.Empty.Lengthd'être vrai. De même, depuis `` String.Empty.Length is equal to zero, there is noInt32 index satisfying0 <= index <String.Empty.Length`. Donc

s.Length < String.Empty.Lengthou s.Length >= String.Empty.Lengthet il y a un Int32 indextel que0 <= index < String.Empty.Length

c'est faux. Par conséquent, ce n'est pas le cas qui sne commence pas par la chaîne vide. Ainsi, sdoit commencer par la chaîne vide.

Ce qui suit est une implémentation de commence par codé comme une extension de 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;
}

Les deux faits en gras ci-dessus sont des exemples d' énoncés vaguement vrais . Elles sont vraies en vertu du fait que les énoncés les définissant ( sous - ensemble et commence par ) sont des quantifications universelles sur des univers vides. Il n'y a aucun élément dans l'ensemble vide, donc il ne peut y avoir aucun élément de l'ensemble vide pas dans un autre ensemble fixe. Il n'y a aucun caractère dans la chaîne vide, donc il ne peut pas y avoir de caractère car une position dans la chaîne vide ne correspond pas au caractère à la même position dans une autre chaîne fixe.

Disons simplement que "abcd".StartsWith("")renvoie false.

si tel est le cas, qu'est-ce que l'expression suivante évalue, true ou false:

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

il s'avère que l'évalue à true, donc la chaîne commence par la chaîne vide ;-), ou met en d'autres termes, la sous-chaîne de "abcd" commençant à la position 0 et ayant une longueur de 0 égale la chaîne vide "". Imo assez logique.

En C #, c'est ainsi que la spécification lui dit de réagir;

Pour être égale, la valeur doit être une chaîne vide (Vide), une référence à cette même instance ou correspondre au début de cette instance.

Les N premiers caractères des deux chaînes sont identiques. N étant la longueur de la deuxième chaîne, c'est-à-dire zéro.

Pourquoi «abcd» .StartsWith («») renvoie-t-il vrai?

LA VRAIE RÉPONSE:

Il doit en être ainsi sinon vous auriez le cas où

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

    but yet

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

et puis nous aurions à nouveau l'an 2000 parce que tous les logiciels bancaires qui dépendent de chaînes égales commençant par eux-mêmes mélangeront nos comptes et soudain, Bill Gates aura ma richesse et j'aurai la sienne, et bon sang! Le destin n'est pas ce genre de chose pour moi.

Pour mémoire, String.StartsWith()appelle en interne la méthode System.Globalization.CultureInfo.IsPrefix()qui effectue explicitement la vérification suivante:

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

Parce qu'une chaîne commence bien par "rien".

Si vous pensez à cela en termes d'expressions régulières, cela a du sens. Chaque chaîne (pas seulement «abcd», mais également «» et «sdf \ nff»), renvoie true lors de l'évaluation de l'expression régulière de «commence par une chaîne vide».