Vérification du contenu de la chaîne? Chaîne Longueur Vs Chaîne vide

Qui est plus efficace pour le compilateur et la meilleure pratique pour vérifier si une chaîne est vide?

Vérifier si la longueur de la chaîne == 0
Vérifier si la chaîne est vide (strVar == "")

Aussi, la réponse dépend de la langue?

15

Oui, il dépend de la langue, puisque la chaîne de stockage diffère entre les langues.
- Pascal-type de cordes: Length = 0.
- C-style chaînes: [0] == 0.
- .NET: .IsNullOrEmpty.
Etc.
13

Dans les langues qui utilisent de style C (null) les chaînes de caractères, en les comparant à "" sera plus rapide. C'est un O(1), tout en prenant la longueur d'une chaîne de style est O(n).

Dans des langues qui stockent longueur de la partie de la chaîne de l'objet (C#, Java, ...) la vérification de la longueur est également en O(1). Dans ce cas, de vérifier directement la longueur est plus rapide, car il évite la surcharge de la construction de la nouvelle chaîne vide.
2

.Net:
```
string.IsNullOrEmpty( nystr );
```
chaînes peuvent être nulles, donc .Longueur parfois, déclenche une exception NullReferenceException

Dans les langues qui utilisent de style C (null) les chaînes de caractères, en les comparant à des " sera plus rapide

En fait, il peut être préférable de vérifier si le premier caractère de la chaîne est '\0':

char *mystring;
/* do something with the string */
if ((mystring != NULL) && (mystring[0] == 'char *mystring;
/* do something with the string */
if ((mystring != NULL) && (mystring[0] == '\0')) {
/* the string is empty */
}
')) {
    /* the string is empty */
}

En Perl, il y a une troisième option, que la chaîne n'est pas défini. C'est un peu différent à partir d'un pointeur NULL en C, si seulement parce que vous n'obtenez pas une faute de segmentation pour l'accès à une indéfini de la chaîne.

1

Dans la version 1.6 de Java, la classe String possède une nouvelle méthode isEmpty

Il y a aussi le Jakarta commons library, qui a la isBlank méthode. Vide est défini comme une chaîne qui ne contient que des espaces.

En supposant que votre question est .NET:

Si vous souhaitez valider votre chaîne de contre nullité ainsi utiliser IsNullOrEmpty, si vous savez déjà que votre chaîne n'est pas null, par exemple lors du contrôle de zone de texte.Texte etc., ne pas utiliser IsNullOrEmpty, et puis vient dans votre question.

Donc, à mon avis de la Chaîne.La longueur est de moins en moins de perfomance de comparaison de chaînes de caractères.

Je l'événement testé (j'ai aussi testé avec le C#, le même résultat):

Module Module1
  Sub Main()
    Dim myString = ""


    Dim a, b, c, d As Long

    Console.WriteLine("Way 1...")

    a = Now.Ticks
    For index = 0 To 10000000
      Dim isEmpty = myString = ""
    Next
    b = Now.Ticks

    Console.WriteLine("Way 2...")

    c = Now.Ticks
    For index = 0 To 10000000
      Dim isEmpty = myString.Length = 0
    Next
    d = Now.Ticks

    Dim way1 = b - a, way2 = d - c

    Console.WriteLine("way 1 took {0} ticks", way1)
    Console.WriteLine("way 2 took {0} ticks", way2)
    Console.WriteLine("way 1 took {0} ticks more than way 2", way1 - way2)
    Console.Read()
  End Sub
End Module

Résultat:

Way 1...
Way 2...
way 1 took 624001 ticks
way 2 took 468001 ticks
way 1 took 156000 ticks more than way 2

Qui signifie comparaison prend plus que la longueur de la chaîne vérifier.

1

String.IsNullOrEmpty() ne fonctionne que sur .net 2.0 et au-dessus, par .net 1/1.1, j'ai tendance à utiliser:
```
if (inputString == null || inputString == String.Empty)
{
    //String is null or empty, do something clever here. Or just expload.
}
```
Je utiliser des chaînes de caractères.Vide, par opposition à "" parce que", " va créer un objet, tandis que la Chaîne.Vide habitude - je sais que c'est quelque chose de petit et insignifiant, mais id toujours pas plutôt créer des objets quand je n'ai pas besoin d'eux! (Source)
0

En fait, de l'OMI, la meilleure façon de déterminer qui est le IsNullOrEmpty() la méthode de la classe string.

http://msdn.microsoft.com/en-us/library/system.string.isnullorempty.

Mise à jour: j'ai supposé .Net, dans d'autres langues, ce pourrait être différent.
0

Dans ce cas, de vérifier directement la longueur est plus rapide, car il évite la surcharge de la construction de la nouvelle chaîne vide.

@DerekPark: ce n'est pas toujours vrai. "" est un littéral de chaîne si, en Java, il sera presque certainement déjà être interné.
0

Pour les chaînes C,
```
if (s[0] == 0)
```
sera plus rapide que l'
```
if (strlen(s) == 0)
```
ou
```
if (strcmp(s, "") == 0)
```
parce que vous permettra d'éviter la surcharge d'un appel de fonction.
0

@Nathan

En fait, il peut être préférable de vérifier si le premier caractère de la chaîne est '\0':

J'ai presque mentionné que, mais finit par le quitter, puisque l'appel de strcmp() avec la chaîne vide et de vérifier directement du premier caractère de la chaîne sont les deux O(1). En gros, vous avez seulement à payer un supplément appel de fonction, ce qui est assez bon marché. Si vous vraiment besoin de la meilleure absolue de la vitesse, bien que, certainement aller avec un direct du premier char à 0 comparaison.

Honnêtement, j'ai toujours utiliser strlen() == 0parce que j'ai jamais écrit un programme où ce fut effectivement un problème de performance mesurables, et je pense que c'est plus lisible pour exprimer le vérifier.
0

De nouveau, sans connaître la langue, il est impossible de le dire.

Cependant, je vous recommande de choisir la technique qui fait le plus de sens pour l'entretien programmeur qui suit en plus de conserver votre travail.

Je recommande d'écrire une fonction qui, explicitement fait ce que vous voulez, comme
```
#define IS_EMPTY(s) ((s)[0]==0)
```
ou comparables. Maintenant, il n'y a pas de doute, vous êtes vérification.
0

Après que j'ai lu ce fil, j'ai mené une petite expérience, qui a abouti à deux distincts, et intéressant, les résultats.

Considérons l'exemple suivant.
```
strInstallString    "1" string
```
Ci-dessus est copié à partir de la fenêtre variables locales du débogueur Visual Studio. La même valeur est utilisée dans les trois exemples suivants.

si ( strInstallString == "" ) === si ( strInstallString == chaîne de caractères.Vide )

Voici le code affiché dans le démontage de la fenêtre de Visual Studio 2013 débogueur pour ces deux fondamentalement des cas identiques.
```
if ( strInstallString == "" )
003126FB  mov         edx,dword ptr ds:[31B2184h]
00312701  mov         ecx,dword ptr [ebp-50h]
00312704  call        59DEC0B0            ; On return, EAX = 0x00000000.
00312709  mov         dword ptr [ebp-9Ch],eax
0031270F  cmp         dword ptr [ebp-9Ch],0
00312716  sete        al
00312719  movzx       eax,al
0031271C  mov         dword ptr [ebp-64h],eax
0031271F  cmp         dword ptr [ebp-64h],0
00312723  jne         00312750

if ( strInstallString == string.Empty )
00452443  mov         edx,dword ptr ds:[3282184h]
00452449  mov         ecx,dword ptr [ebp-50h]
0045244C  call        59DEC0B0        ; On return, EAX = 0x00000000.
00452451  mov         dword ptr [ebp-9Ch],eax
00452457  cmp         dword ptr [ebp-9Ch],0
0045245E  sete        al
00452461  movzx       eax,al
00452464  mov         dword ptr [ebp-64h],eax
00452467  cmp         dword ptr [ebp-64h],0
0045246B  jne         00452498
```
si ( strInstallString == chaîne de caractères.Vide ) N'est pas Significativement Différente
```
if ( strInstallString.Length == 0 )
003E284B  mov         ecx,dword ptr [ebp-50h]
003E284E  cmp         dword ptr [ecx],ecx
003E2850  call        5ACBC87E        ; On return, EAX = 0x00000001.
003E2855  mov         dword ptr [ebp-9Ch],eax
003E285B  cmp         dword ptr [ebp-9Ch],0
003E2862  setne       al
003E2865  movzx       eax,al
003E2868  mov         dword ptr [ebp-64h],eax
003E286B  cmp         dword ptr [ebp-64h],0
003E286F  jne         003E289C
```
À partir du dessus de la machine listes de code, généré par le NGEN module de la .NET Framework, version 4.5, je tire les conclusions suivantes.
1. De test pour l'égalité contre le vide littéral de chaîne et de la chaîne statique.Vide bien sur le Système.classe string sont, à toutes fins pratiques identiques. La seule différence entre les deux fragments de code est la source de la première instruction, et les deux sont des décalages par rapport à la ds, ce qui implique que les deux font référence au four constantes.
2. Les essais de l'égalité contre la chaîne vide, soit un littéral ou de la chaîne.Vide de la propriété, met en place une à deux arguments de l'appel de fonction, ce qui indique inégalité par un retour de zéro. Je fonde cette conclusion sur d'autres tests que j'ai effectué il y a quelques mois, où j'ai suivi une partie de mon code à travers les sites gérés et non gérés diviser et à l'arrière. Dans tous les cas, tout appel qui a nécessité deux ou plusieurs arguments, le premier argument dans le registre ECX, et le deuxième dans le registre EDX. Je ne me souviens pas comment les arguments suivants ont été adoptés. Néanmoins, la configuration de l'appel ressemblait plus à __fastcall qu' __stdcall. De même, le rendement attendu des valeurs toujours montré dans le registre EAX, ce qui est presque universel.
3. Test de la longueur de la chaîne met en place un argument appel de fonction qui renvoie 1 (registre EAX), qui se trouve être la longueur de la chaîne en cours d'essai.
4. Étant donné que l'immédiatement visible code machine est presque identique, la seule raison que je peux imaginer que représenterait la meilleure performance de la chaîne de l'égalité au cours de la piqûre longueur rapporté par Shinny est que les deux arguments de la fonction qui effectue la comparaison est nettement mieux optimisé que l'argument une fonction qui lit la longueur hors la chaîne d'instance.
Conclusion

Comme une question de principe, j'évite de comparer par rapport à la chaîne vide comme une chaîne littérale, parce que le littéral de chaîne vide peut apparaître ambiguë dans le code source. À cette fin, mon .NET helper classes ont longtemps défini la chaîne vide comme une constante. Bien que j'utilise le chaîne.Vide direct, en ligne comparaisons, la constante qui gagne sa vie pour la définition des autres constantes dont la valeur est la chaîne vide, car une constante ne peut être attribué chaîne.Vide de sa valeur.

Cet exercice s'installe, une fois pour toutes, de tout souci que je peut avoir sur le coût, le cas échéant, de comparaison contre chaîne.Vide ou la constante définie par mon helper classes.

Cependant, cela soulève aussi une question déroutante pour le remplacer; pourquoi comparer par rapport à chaîne.Vide plus efficace que de tester la longueur de la chaîne? Ou est le test utilisé par Shinny invalidé parce que par la façon dont la boucle est mis en œuvre? (Je trouve cela difficile à croire, mais, là encore, j'ai été dupé avant, je suis sûr que vous avez, aussi!)

J'ai longtemps supposé que les système.chaîne objets ont été comptés à cordes, fondamentalement semblable à la Chaîne de Base (BSTR) que nous avons connu depuis longtemps de COM.

Vous devez vous connecter pour publier un commentaire.