Pourquoi "abcd" .StartsWith ("") renvoie true?
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 se produit logiquement entre chaque paire de caractères.
Autrement dit: 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.Length caractè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. Parce que 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 de valeur à la sous-chaîne au début de cette chaîne qui est de la même longueur que la valeur et renvoie 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.
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).
Je vais commencer par un fait connexe qui est plus facile à comprendre.
L'ensemble vide est un sous-ensemble de chaque ensemble.
Pourquoi? Le 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.
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 n'est pas un sous-ensemble de B. Si l'ensemble vide n'était pas un sous-ensemble de B alors je pourrais trouver un élément de l'ensemble vide qui n'est pas dans B. Mais l'ensemble vide n'a aucun élément et donc je ne trouve pas d'élément qui n'est pas dans B. Par conséquent, ce n'est pas le cas que 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 nous mettre d'accord sur notre définition de commence par. Soit s et t être strings Nous disons que s commence part if s.Length >= t.Length et le premier t.Length les caractères de t correspondent à ceux de s. C'est, s.Length >= t.Length et pour chaque Int32 index tel que 0 <= index < t.Length, s[index] == t[index] est vrai. Inversement, nous dirions que s ne commence pas par t si l'instruction
s.Length < t.Length ou s.Length >= t.Length et il y a un Int32 index tel que 0 <= index < t.Length et s[index] != t[index]
est vrai. En anglais ordinaire, s est plus court que t, ou sinon, il y a un caractère dans t ne correspondant pas au caractère comme la même position dans s.
Maintenant, corrigez une chaîne s. Je vais établir que s 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, alors s.Length < String.Empty.Length ou s.Length >= String.Empty.Length et il y a un Int32 index 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 vrai. De même, puisque `` String.Empty.Lengthis equal to zero, there is noInt32 index satisfying0 <= index <String.Empty.Length`. Par conséquent
s.Length < String.Empty.Length ou s.Length >= String.Empty.Length et il y a 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 démarre pas avec 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 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 de déclarations vides de vérité . Ils sont vrais en raison du fait que les déclarations les définissant ( sous-ensemble et commence par) sont 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 pas de caractères 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 dans la même position dans une autre chaîne fixe.
Disons simplement que "abcd".StartsWith("") renvoie false.
si oui, que signifie l'expression suivante, true ou false:
("abcd".Substring(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 une longueur é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.
Pourquoi “abcd” .StartsWith (“”) renvoie vrai?
LA RÉPONSE RÉELLE:
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 Y2K 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 richesse et j'aurais la sienne, et bon sang! Le destin n'est pas ce genre 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;
}
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.
Parce qu'une chaîne commence bien par "rien".
Si vous y pensez en termes d'expressions régulières, cela a du sens. Chaque chaîne (pas seulement "abcd", également "" et "sdf\nff"), renvoie true lors de l'évaluation de l'expression régulière de 'commence par une chaîne vide'.