Pourquoi “abcd” .StartsWith (“”) renvoie true?

Titre est la question entière. 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.

    En d’autres termes: quelle définition de “commence par” pourriez-vous donner cela empêcherait cela? Voici une définition simple de “commence par” qui ne comprend pas:

    “x commence par y si le premier y.Length caractères de y.Length de x correspondent à ceux de y.”

    Une définition alternative (équivalente):

    “x commence par y si x.Subssortingng(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 en résulte 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 de même longueur que value et renvoie une valeur indiquant si elles sont égales. Pour être égale, la valeur doit être une chaîne vide (Empty), une référence à cette même instance ou correspondre au début de cette instance.

    .NET Ssortingng.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 renvoyé si l’argument est une chaîne vide ou est égal à cet object Ssortingng, déterminé par la méthode equals (Object).

    Java Ssortingng.startsAvec

    Je commencerai par un fait connexe plus facile à comprendre.

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

    Pourquoi? La définition de sousensemble indique que A est un sous-ensemble de B si chaque élément de A est un élément de B A l’inverse, A n’est pas un sous-ensemble de B s’il existe un élément de A qui n’est pas un élément de B

    Fixez maintenant 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 si l’ensemble vide n’est pas un sous-ensemble de B Si l’ensemble vide n’était pas un sous-ensemble de B je pourrais trouver un élément de l’ensemble vide qui ne figure pas dans B Mais l’ensemble vide n’a pas d’éléments et je ne peux donc pas trouver un élément qui ne soit pas dans B Par conséquent, le jeu vide n’est 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.

    Tout d’abord, nous devons être d’accord sur notre définition de départ avec . Soit s et t la ssortingng s On dit que s commence par t si s.Length >= t.Length et le premier t.Length caractères de t.Length de t correspondent à ceux de s . C’est-à-dire s.Length >= t.Length et pour chaque Int32 index tel que 0 <= index < t.Length , s[index] == t[index] est vrai. Inversement, on dirait que s ne commence pas par t si la déclaration

    s.Length < t.Length ou s.Length >= t.Length et qu'il existe un Int32 index tel que 0 <= index < t.Length et s[index] != t[index]

    est vrai. En clair, s est plus court que t ou, sinon, il y a un caractère dans t ne correspond pas au caractère de la même position dans s .

    Maintenant, corrigez une chaîne s . Je vais établir que ça commence par la chaîne vide. Je vais le faire en montrant que ce n'est pas le cas que s ne commence pas par la chaîne vide. Si s ne commence pas par la chaîne vide, s.Length < String.Empty.Length ou s.Length >= Ssortingng.Empty.Length et qu'il existe un Int32 index tel que 0 <= index < String.Empty.Length . Mais s.Length >= 0 et Ssortingng.Empty.Length est égal à zéro, il est donc impossible que s.Length < String.Empty.Length soit vrai. De même, puisque Ssortingng.Empty.Length is equal to zero, there is no index Int32 satisfying 0 <= index

    s.Length < String.Empty.Length ou s.Length >= Ssortingng.Empty.Length et qu'il existe un Int32 index tel que 0 <= index < String.Empty.Length

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

    Ce qui suit est une implémentation de start avec codé comme une extension à ssortingng .

     public static bool DoStartsWith(this ssortingng s, ssortingng 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 de déclarations faussement vraies . Ils sont vrais parce que les déclarations qui les définissent ( sous - ensemble et commence par ) sont des quantifications universelles sur des univers vides. Il n'y a pas d'éléments dans l'ensemble vide, il ne peut donc y avoir aucun élément de l'ensemble vide dans un autre ensemble fixe. Il n'y a pas de caractères dans la chaîne vide, il ne peut donc y avoir de caractère dans la chaîne vide qui ne correspond pas au même caractère dans une autre chaîne fixe.

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

    si oui, alors quelle est l’expression suivante eval to, true ou false:

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

    il s’avère que evals à true, donc la chaîne commence par la chaîne vide 😉 ou, en d’autres termes, la sous-chaîne de “abcd” commençant à la position 0 et ayant la longueur 0 est égale à la chaîne vide “”. Assez logique imo.

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

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

    Pourquoi “abcd” .StartsWith (“”) renvoie true?

    LA RÉPONSE RÉELLE:

    Cela doit être comme ça sinon vous auriez le cas où

      "".startsWith("") == false "".equals("") == true but yet "a".startsWith("a") == true "a".equals("a") == true 

    et puis nous aurions recommencé l’an 2000 parce que tous les logiciels bancaires qui dépendent de chaînes égales commençant par eux-mêmes vont mélanger nos comptes et soudainement, Bill Gates aura ma fortune et j’aurai le sien! Le destin n’est pas si gentil avec moi.

    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.

    Juste pour l’enregistrement, Ssortingng.StartsWith() appelle en interne la méthode System.Globalization.CultureInfo.IsPrefix() qui vérifie explicitement ce qui suit:

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

    Parce qu’une chaîne commence bien avec “rien”.

    Si vous y pensez en termes d’expressions régulières, cela a du sens. Chaque chaîne (pas seulement “abcd”, aussi “” et “sdf \ nff”), renvoie true lorsque l’on évalue l’expression régulière de ‘commence par une chaîne vide’.

    En C #, la raison pour laquelle il retourne true est que les développeurs l’ont spécifiquement codé.

    Si vous extrayez le code source , vous trouverez une logique spécifique pour gérer une chaîne vide:

     public Boolean StartsWith(Ssortingng value) { return StartsWith(value, SsortingngComparison.CurrentCulture); } public Boolean StartsWith(Ssortingng value, SsortingngComparison comparisonType) { ... if (value.Length == 0) { return true; }