Pourquoi “abcd” .StartsWith (“”) retourne-t-il vrai?

Question

Titre est la question entière. Quelqu'un peut-il me donner une raison pour que cela se produise?

Answer 1

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 termes simples, quelle définition de " commence par " pourriez-vous donner que cela empêcherait cela? Voici une définition simple de " commence par " cela ne veut pas:

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

Définition alternative (équivalente):

"x commence par y si x.Sous-chaîne (0, y.Longueur). Équals (y) "

Answer 2

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 scinder z pour écrire z = x + y, cela signifie que z commence par x. Parce que chaque chaîne z peut être fractionnée en z = " " + z il s'ensuit que chaque chaîne commence par """.

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

Answer 3

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 renvoie une valeur indiquant si elles sont égales. Pour être identique, 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 renvoyé 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

Answer 4

Je commencerai par un fait connexe plus facile à comprendre.

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

Pourquoi? La définition de sous-ensemble indique que A est un sous-ensemble de B si chaque élément de A est un élément de B . Inversement, 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 .

Corrigez maintenant un ensemble B . Je vais établir que l'ensemble vide est un sous-ensemble de B . Je ferai cela en montrant que ce n'est pas le cas que 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 se trouve pas dans B . Mais l'ensemble vide ne contient aucun élément et je ne peux donc pas trouver un élément qui ne se trouve pas dans B . Par conséquent, l'ensemble 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 convenir de notre définition de commence par . Soit s et t une chaîne s Nous disons que s commence par t si s.Length > = t.Length et les premiers caractères t.Length de t correspondent à ceux de < code> s . Autrement dit, s.Length > = t.Length et pour chaque index Int32 tel que 0 < = index < t.Length , s [index] == t [index] est vrai. Inversement, nous dirions que s ne commence pas par t si la déclaration

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

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

Corrigez maintenant une chaîne s . Je vais établir que s commence par la chaîne vide. Je ferai cela 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, alors s.Length < String.Empty.Length ou s.Length > = String.Empty.Length et il existe un index Int32 tel que 0 < = index < String.Empty.Length . Mais s.Length > = 0 et String.Empty.Length est égal à zéro, il est donc impossible pour s.Length < String.Empty.Length pour être true. De même, puisque `` String.Empty.Length est égal à zéro, il n'y a pas index Int32 satisfaisant 0 < = index < String.Empty.Length`. Donc

à la longueur < String.Empty.Length ou s.Length > = String.Empty.Length et il existe un index Int32 tel que 0 < = index < String.Empty.Length

est faux. Par conséquent, 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 commence par codé comme une extension de chaîne .

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 caractères gras ci-dessus sont des exemples de déclarations véridiquement véridiques . Ils sont vrais en raison du fait que les instructions qui les définissent ( sous-ensemble et commencent par ) sont quantifications universelles sur des univers vides. Il n'y a pas d'éléments dans le jeu vide, il ne peut donc y avoir aucun élément du jeu vide qui ne soit dans un autre jeu fixe. Il n'y a pas de caractères dans la chaîne vide, il ne peut donc pas y en avoir car une position dans la chaîne vide ne correspond pas au caractère situé à la même position dans une autre chaîne fixe.

Answer 5

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

Si tel est le cas, en quoi consiste l'expression suivante: vrai ou faux:

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

il s'avère que evals est à true, la chaîne commence donc par la chaîne vide ;-), ou, autrement dit, la sous-chaîne de "abcd". en partant de la position 0 et ayant une longueur égale à 0, la chaîne vide "". Assez logique imo.

Answer 6

En C #, voici comment la spécification lui dit de réagir;

  

Pour être identique, 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.

Answer 7

  

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

LA RÉPONSE RÉELLE:

Cela doit ê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 encore l'an 2000 à nouveau parce que tout le logiciel de banque qui dépend de chaînes égales commençant par eux-mêmes obtiendra nos comptes mélangés et tout à coup Bill Gates aura mon patrimoine et j'aurais le sien, et bon sang ! Le destin ne me convient tout simplement pas.

Answer 8

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.

Answer 9

Juste pour l'enregistrement, 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;
}

Answer 10

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

Answer 11

Si vous y réfléchissez en termes d'expressions régulières, cela a du sens. Chaque chaîne (pas seulement "abcd", aussi "" et "sdf \ nff"), renvoie vrai lors de l'évaluation de l'expression régulière de 'commence par une chaîne vide'.

Answer 12

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

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

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

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

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