Comment puis-je rechercher une chaîne vide / non définie / nulle en JavaScript?


2853

J'ai vu cette question , mais je n'ai pas vu d'exemple spécifique à JavaScript. Existe-t-il un simple string.Emptydisponible en JavaScript, ou s'agit-il simplement d'une vérification ""?


2
juste pour info, je pense que les API les plus utiles pour la classe String sont au kit Mozilla et javascript . [elated.com] ( elated.com/articles/working-with-strings ) a un tutoriel sur toutes les propriétés, méthodes, ... Veuillez noter: le lien Mozilla a été mis à jour vers developer.mozilla.org/en/ JavaScript / Référence / Global_Objects /…
Gene T


Il serait très utile que l'exigence soit clairement spécifiée. Pour quelles valeurs isEmpty doit- il renvoyer true? La vérification de "" indique qu'elle ne doit renvoyer la valeur true que si la valeur est Type string et length 0. De nombreuses réponses ici supposent qu'elle devrait également renvoyer true pour certaines ou toutes les valeurs de falsey.
RobG

Réponses:


3573

Si vous voulez simplement vérifier s'il y a une valeur, vous pouvez le faire

if (strValue) {
    //do something
}

Si vous devez vérifier spécifiquement une chaîne vide par rapport à null, je pense que la vérification contre ""est votre meilleur pari, en utilisant l' ===opérateur (afin que vous sachiez qu'il s'agit en fait d'une chaîne que vous comparez).

if (strValue === "") {
    //...
}

174
Le test de la propriété length peut en fait être plus rapide que le test de la chaîne par rapport à "", car l'interpréteur n'aura pas à créer un objet String à partir du littéral de chaîne.
Vincent Robert

26
@Vincent faisant du profilage naïf dans les outils de développement Chrome, les tests === ''vs .lengthn'ont montré aucune amélioration perceptible (et n'utilisent .lengthque des travaux si vous pouvez supposer que vous avez une chaîne)
bdukes

26
@bdukes lorsque vous commencez à vous soucier de ce type de micro-optimisations, je ne pense pas que Chrome soit le navigateur où vous rencontrez le plus de problèmes de performances ...
Vincent Robert

15
Juste pour noter, si votre définition de "chaîne vide" inclut des espaces, alors cette solution n'est pas appropriée. Une chaîne de 1 ou plusieurs espaces renvoie vrai ci-dessus. Si vous utilisez JQuery, vous pouvez simplement utiliser ceci: if ($ .trim (ref) .length === 0) - selon cette réponse à une question similaire: stackoverflow.com/questions/2031085/…
CodeClimber

115
Comme prévu, .length > 0c'est en fait beaucoup plus rapide que de le comparer à un littéral de chaîne! Découvrez ce jsPerf
Tchad

1128

Pour vérifier si une chaîne est vide, nulle ou non définie, j'utilise:

function isEmpty(str) {
    return (!str || 0 === str.length);
}

Pour vérifier si une chaîne est vide, nulle ou non définie, j'utilise:

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

Pour vérifier si une chaîne est vide ou ne contient que des espaces blancs:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

21
pourquoi 0 === str.length au lieu de str.length === 0?
Vincent

66
Les conditions @Vincent sont souvent écrites comme ceci if (variable == constant value)et si vous oubliez un '=', vous affectez la valeur constante à la variable au lieu de tester. Le code fonctionnera toujours car vous pouvez attribuer une variable dans un if. Une manière plus sûre d'écrire cette condition consiste donc à inverser la valeur constante et la variable. De cette façon, lorsque vous testez votre code, vous verrez une erreur (côté gauche non valide dans l'affectation). Vous pouvez également utiliser quelque chose comme JSHint pour interdire l'affectation dans des conditions et être averti lorsque vous en écrivez une.
florian

2
dommage que ce /^\s*$/.test(str)ne soit pas vraiment lisible - peut-être que supprimer des espaces en utilisant du code plus simple ou des expressions rationnelles serait mieux? voir stackoverflow.com/questions/6623231/… et aussi stackoverflow.com/questions/10800355/…
Adrien Be

6
/^\s*$/.test(str) peut être remplacé par str.trim (). length === 0
Schadenfreude

21
@Vincent, cela s'appelle aussi "Conditions Yoda", comme if blue is the sky. Voir dodgycoder.net/2011/11/11/yoda-conditions-pokemon-exception.html
AZ.

316

Toutes les réponses précédentes sont bonnes, mais ce sera encore mieux. Utilisez l' opérateur !!( pas non ).

if(!!str){
    // Some code here
}

Ou utilisez le casting de type:

if(Boolean(str)){
    // Code here
}

Les deux remplissent la même fonction. Typecast la variable en booléen, où strest une variable.
Il revient falsepour null,undefined,0,000,"",false.
Il renvoie la truechaîne "0" et les espaces "".


61
Pourquoi est-ce "encore mieux"?
Mene

33
Y a-t-il une différence entre le comportement de if(str)et if(!!str)?
Peter Olson

6
@PeterOlson si vous essayez d'enregistrer une variable comme un booléen qui vérifie plusieurs chaînes pour le contenu alors vous voulez le faire .. aka la var any = (!!str1 && !!str2 && !!str3)manipulation s'il y a un certain nombre là aussi
John Ruddell

23
C'est la solution que j'utilise toujours. !!str.trim()pour vous assurer que la chaîne n'est pas faite uniquement d'espaces.
Dario Oddenino

5
Ne ressemble pas à un hack, Boolean(str)est beaucoup plus lisible et moins "wtfish".
shinzou

105

La chose la plus proche à laquelle vous pouvez accéder str.Empty(avec la condition préalable que str est une chaîne) est:

if (!str.length) { ...

9
Cela ne déclencherait-il pas une exception si str est nul?
Pic Mickael

3
@PicMickael Oui! Il en serait de même str.Empty.
Ates Goral du

99

Si vous devez vous assurer que la chaîne n'est pas juste un tas d'espaces vides (je suppose que c'est pour la validation du formulaire), vous devez faire un remplacement sur les espaces.

if(str.replace(/\s/g,"") == ""){
}

8
Mais fait le travail si ce que vous voulez réellement tester est une chaîne avec un contenu non-espace. Existe-t-il un moyen moins coûteux de tester cela?
flash

4
Que diriez-vous de la propriété de longueur?
driAn

27
Au lieu de supprimer tous les espaces, pourquoi ne pas simplement vérifier s'il n'y a pas d'espace? A 2 avantages qu'il peut renflouer tôt s'il y a un caractère non-espace, et il n'a pas à renvoyer une nouvelle chaîne que vous vérifiez ensuite. if(str.match(/\S/g)){}
mpen

34
@Mark FYI, vous n'auriez pas besoin du modificateur global, car la correspondance de la première occurrence d'un caractère non spatial signifierait que la chaîne n'est pas vide:str.match(/\S/)
neezer

1
pourquoi c'est cher? Si c'est vraiment le cas, alors pourquoi jQuery utilise cette méthode? Vous pouvez le trouver dans la source de jQueryvar trimLeft = /^\s+/, trimRight = /\s+$/;
Marecky

66

J'utilise:

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof(e) == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

5
Cette solution est plus indépendante de la langue. La seule fonctionnalité JavaScript sur laquelle il s'appuie est typeof. C'est donc un bon exemple de solution que vous pouvez utiliser lorsque vous ne faites pas confiance aux implémentations dans différents navigateurs et que vous n'avez pas le temps de trouver une meilleure solution. (IE, pas d'accès Internet). C'est quelque chose comme une preuve. Pas le plus propre mais vous pouvez être sûr que cela fonctionnera sans en savoir trop sur JavaScript.
Jeff Davis

2
J'irais même un peu plus loin et le clouerais avec un opérateur === pour le cas indéfini. Sinon, c'est tout simplement la réponse parfaite.
xarlymg89

Le typeofdans le switchne fonctionnait pas pour moi. J'ai ajouté un if (typeof e == "undefined")test et ça marche. Pourquoi?
Lucas

1
@Lucas Parce que c'était une faute de frappe ou une erreur. Votre modification est la bonne approche. (l'original fait référence au contexte de la fonction vide, pas au paramètre e, qui est ce que la fonction est censée vérifier)
beeThree

Pourrions-nous utiliser à la case undefined:place de case typeof(e) == "undefined":?
Boris J.27

43

Vous pouvez utiliser lodash : _.isEmpty (valeur).

Il couvre beaucoup de cas comme {}, '', null,undefined , etc.

Mais elle retourne toujours truepour le Numbertype de JavaScript types de données primitives comme _.isEmpty(10)ou les _.isEmpty(Number.MAX_VALUE)deux déclarations true.


_.isEmpty(" "); // => false
Erich

1
@Erich Parce que " "n'est pas vide. _.isEmpty("");renvoie vrai.
Moshii à 7h34

1
tout à fait vrai - je l'ai mentionné parce que quelques-unes des autres réponses impliquent ici la validation du formulaire et la vérification si une chaîne ne contient que des espaces, et cette seule fonction lodash ne résoudra pas à elle seule ce problème.
Erich

@Erich, maintenant j'ai compris, merci d'avoir mentionné.
Moshii

36

Essayer:

if (str && str.trim().length) {  
    //...
}

2
La propriété de longueur est-elle nécessaire?
frogcoder

str.trim().lengthfera plus vite que str.trim()d'environ 1% selon mes propres résultats de test.
devildelta

2
@devildelta - Votre 1% est une erreur dans votre test.
Stephen M Irving

OP cherche à tester la chaîne vide, non définie ou nulle. Ceci teste une chaîne qui ne correspond à aucune de ces conditions. Il n'a rien dit non plus sur les espaces blancs uniquement. Vous pouvez tester les conditions OP avec juste cela, tant que vous êtes sûr qu'aucun autre type de données n'est stocké dans la variable: if (!str) { ... }
Stephen M Irving

36

Une fonction:

function is_empty(x)
{
    return (
        (typeof x == 'undefined')
                    ||
        (x == null)
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x == "")
                    ||
        (x.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
    );
}

PS: En JavaScript, n'utilisez pas de saut de ligne après return;


1
Avez-vous une chance d'expliquer ce que fait chaque vérification? :)
DanV

2
-1 Ils testent différentes choses. Cela n'a aucun sens de les mettre tous dans une seule ifdéclaration.
Bennett McElwee

1
typeof MyVariable == 'undefined' ne fait pas de distinction entre une variable initialisée avec une valeur non définie et une variable non déclarée à moins que la variable ait été initialement déclarée et initialisée à null. La vérification de la propriété length entraîne le conditionnement de la primitive de chaîne dans un objet chaîne.
Scott Marcus

34
var s; // undefined
var s = ""; // ""
s.length // 0

Il n'y a rien qui représente une chaîne vide en JavaScript. Faites une vérification contre length(si vous savez que la var sera toujours une chaîne) ou contre""


29

Je ne m'inquiéterais pas trop de la méthode la plus efficace . Utilisez ce qui est le plus clair pour votre intention. Pour moi, c'est généralementstrVar == "" .

Selon le commentaire de Constantin , si strVar pouvait finir par contenir une valeur entière 0, ce serait en effet l'une de ces situations de clarification de l'intention.


11
Mauvaise idée. Vous obtiendrez vrai si strVar est accidentellement assigné 0.
Constantin

5
Je conviens qu'il est plus important de clarifier votre intention que toute micro-optimisation que d'autres méthodes pourraient produire, mais il serait préférable d' utiliser l' opérateur de comparaison strict === . Il ne renvoie vrai que si strVarest une chaîne vide.
Code inutile

La vérification échoue si elle n'est pas définie. Donc, si (str) fonctionne mieux
Valentin Heinitz

3
@ValentinHeinitz si str s'est vu attribuer une valeur de falsey de 0 ou "0", si (str) rapportait faussement vrai. La meilleure approche est if (str === ""). C'est simple et ça n'échouera jamais.
Scott Marcus


21

Performance

J'effectue des tests sur macOS v10.13.6 (High Sierra) pour 18 solutions choisies. Les solutions fonctionnent légèrement différemment (pour les données d'entrée de cas d'angle), ce qui a été présenté dans l'extrait ci-dessous.

Conclusions

  • les solutions simples basées sur !str, ==, ===etlength sont rapides pour tous les navigateurs (A, B, C, G, I, J)
  • les solutions basées sur l'expression régulière ( test, replace) etcharAt sont les plus lentes pour tous les navigateurs (H, L, M, P)
  • les solutions marquées comme les plus rapides n'étaient les plus rapides que pour un essai - mais dans de nombreux essais, elles changent dans le groupe de solutions «rapides»

Entrez la description de l'image ici

Détails

Dans l'extrait ci-dessous, je compare les résultats des 18 méthodes choisies en utilisant différents paramètres d'entrée

  • "" "a" " "- chaîne vide, chaîne avec lettre et chaîne avec espace
  • [] {} f- tableau, objet et fonction
  • 0 1 NaN Infinity - Nombres
  • true false - booléen
  • null undefined

Toutes les méthodes testées ne prennent pas en charge tous les cas d'entrée.

Et puis pour toutes les méthodes str = "", j'effectue un test de vitesse pour les navigateurs Chrome v78.0.0, Safari v13.0.4 et Firefox v71.0.0 - vous pouvez exécuter des tests sur votre machine ici

Entrez la description de l'image ici


C'est vraiment génial! J'adore voir tout cela présenté! Je vous remercie!
WebWanderer

c'est une étude approfondie - merci
Deian

20

Beaucoup de réponses et beaucoup de possibilités différentes!

Sans aucun doute pour une mise en œuvre simple et rapide, le gagnant est: if (!str.length) {...}

Cependant, comme de nombreux autres exemples sont disponibles. La meilleure méthode fonctionnelle pour y parvenir, je suggère:

function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

Un peu excessif, je sais.


2
La vérification de l'indéfini devrait être déplacée en premier dans les vérifications, ou les éléments non définis lèveront des exceptions sur les vérifications antérieures.
SvdSinner

Entièrement d'accord! BELLE PRISE. Je vais modifier ma réponse ci-dessus!
tfont

str.length === 0renvoie true pour toute fonction qui n'a pas de paramètres formels.
RobG

20

Vous pouvez également utiliser des expressions régulières:

if((/^\s*$/).test(str)) { }

Recherche les chaînes vides ou remplies d'espaces.


Cela fonctionne, mais c'est aussi horriblement cher en termes d'opérations. Bien si vous voulez simplement vérifier une ou deux choses, pas un grand ensemble.
Orphée

19
  1. regarde ça var a; existent
  2. rogner false spacesla valeur, puis tester pouremptiness

    if ((a)&&(a.trim()!=''))
    {
      // if variable a is not empty do this 
    }

17

De plus, si vous considérez une chaîne remplie d'espaces comme "vide".

Vous pouvez le tester avec cette expression régulière:

!/\S/.test(string); // Returns true if blank.

14

J'utilise habituellement quelque chose comme ça,

if (!str.length) {
    // Do something
}

3
Le plus rapide si vous savez que la variable est une chaîne. Lance une erreur si la variable n'est pas définie.
Adrian Hope-Bailie

@ AdrianHope-Bailie pourquoi voudriez-vous tester une variable non définie?
Abimael Martell

2
@AbimaelMartell Pourquoi pas? Vous avez une variable que vous avez déclarée ou qui vous a été transmise à partir d'une étendue sur laquelle vous n'avez aucun contrôle, comme dans une réponse d'un appel de méthode ou d'API. Vous pouvez supposer qu'il contient une valeur et utiliser la vérification ci-dessus, mais s'il n'est pas défini ou est nul, vous obtiendrez une erreur. var test = null; if (! test.length) {alert ("adrian a tort");}
Adrian Hope-Bailie

OP demandait "comment vérifier une chaîne vide", une variable non définie n'est pas une chaîne vide. Quoi qu'il en soit, vous pouvez vérifier typeof variable != "undefined"avant de vérifier s'il est vide.
Abimael Martell

10

Je n'ai pas remarqué de réponse prenant en compte la possibilité de caractères nuls dans une chaîne. Par exemple, si nous avons une chaîne de caractères nulle:

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

Pour tester sa nullité, on pourrait faire quelque chose comme ceci:

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

Il fonctionne sur une chaîne nulle et sur une chaîne vide et il est accessible à toutes les chaînes. En outre, il pourrait être développé pour contenir d'autres caractères JavaScript vides ou blancs (c'est-à-dire un espace insécable, une marque d'ordre des octets, un séparateur de ligne / paragraphe, etc.).


2
Analyse intéressante. Je ne pense pas que ce serait pertinent dans 99,9% des cas. MAIS j'ai récemment découvert que MySQL évalue une colonne à "null" si (et seulement si) cette colonne contient le caractère nul ("\ 0"). Oracle, d'autre part, n'évaluerait pas "\ 0" comme étant nul, préférant le traiter comme une chaîne de longueur 1 (où ce caractère est le caractère nul). Cela pourrait causer de la confusion s'il n'est pas traité correctement, car de nombreux développeurs Web travaillent avec une base de données principale, qui peut passer par différents types de valeurs "nulles". Cela devrait être à l'esprit de chaque développeur.
cartbeforehorse

10

Pendant ce temps, nous pouvons avoir une fonction qui vérifie tous les «vides» comme null, undefined, «», «», {}, [] . Je viens donc d'écrire ceci.

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

Cas d'utilisation et résultats.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

10

Pour l'instant, il n'y a pas de méthode directe comme string.empty pour vérifier si une chaîne est vide ou non. Mais dans votre code, vous pouvez utiliser une vérification de wrapper pour une chaîne vide comme:

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.

}

En utilisant cela, vous pouvez également vous assurer que la chaîne n'est pas non plus définie ou nulle également. Rappelez-vous que non défini, nul et vide sont trois choses différentes.


Cela lancerait une erreur sur null ou indéfini car nous ne devrions pas faire directement une opération sur une variable qui est nulle ou indéfinie - vérifiez que str existe avant de le faire comme indiqué dans d'autres réponses et notez également que cela fonctionnerait sur let abc = '' mais pas sur let abc = '', ces deux sont différents.
whoami

Considérez let rand = ()=>Math.random(), puis rand && rand.length > 0)retournez false, mais clairement fn n'est pas "vide". C'est-à-dire qu'il retourne faux pour toute fonction qui n'a pas de paramètres de format.
RobG

@RobG Math.random()renvoie un nombre et non une chaîne. Et cette réponse concerne les chaînes. ;-)
Harshit Agarwal

10

Toutes ces réponses sont agréables.

Mais je ne peux pas être sûr que la variable est une chaîne, ne contient pas que des espaces (c'est important pour moi) et peut contenir '0' (chaîne).

Ma version:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

Échantillon sur jsfiddle .


1
Hein? Si vous attendez une chaîne empty(0)et devez empty(7)renvoyer la même valeur.
Bennett McElwee

Dans mon cas particulier - empty("0")doit retourner false(car ce n'est pas une chaîne vide), mais empty(0)doit retourner trueparce qu'elle est vide :)
Andron

Mais 0 n'est pas vide! C'est un nombre, et les nombres ne peuvent pas être pleins ou vides. Bien sûr, c'est votre fonction et doit donc répondre à vos besoins, mais emptyc'est un nom trompeur dans ce cas.
Bennett McElwee

Je pense que ce nom emptyest bon. Dans les documents php pour la fonction vide : Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.La différence entre PHPet cette fonction - cette chaîne '0'ne sera pas identifiée comme vide.
Andron

Comme je l'ai dit, c'est votre fonction: appelez-la comme vous voulez. Mais emptyc'est un nom inexact et trompeur. Il est intéressant de noter que PHP a également une fonction mal nommée empty, mais les défaillances de PHP n'ont rien à voir avec JavaScript.
Bennett McElwee

10

Je n'ai pas vu de bonne réponse ici (du moins pas une réponse qui me convient)

J'ai donc décidé de me répondre:

value === undefined || value === null || value === "";

Vous devez commencer à vérifier s'il n'est pas défini. Sinon, votre méthode peut exploser, puis vous pouvez vérifier si elle est égale à null ou est égale à une chaîne vide.

Vous ne pouvez pas avoir !! ou seulement if(value)parce que si vous cochez, 0cela va vous donner une fausse réponse (0 est faux).

Cela dit, enveloppez-le dans une méthode comme:

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PS: Vous n'avez pas besoin de vérifier le typeof , car il exploserait et se lancerait même avant d'entrer dans la méthode


Il est probablement préférable d'utiliser la construction booléenne (valeur) qui traite les valeurs non définies et nulles (et également 0, -0, faux, NaN) comme fausses. Voir stackoverflow.com/questions/856324/…
Zhuravlev A.

9

Si l'on a besoin de détecter non seulement des chaînes vides mais aussi vides, j'ajouterai à la réponse de Goral:

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

8

Essaye ça

str.value.length == 0

3
"".value.lengthprovoquera une erreur. Cela devrait êtrestr.length === 0
AndFisher

Ce trow a TypeErrorIf strest égal à undefinedounull
RousseauAlexandre

8

Vous pouvez facilement l'ajouter à l' objet String natif en JavaScript et le réutiliser encore et encore ...
Quelque chose de simple comme le code ci-dessous peut faire le travail pour vous si vous souhaitez vérifier ''les chaînes vides:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
  return !(!!this.length);
}

Sinon, si vous souhaitez vérifier à la fois la ''chaîne vide et l' ' 'espace, vous pouvez le faire en ajoutant simplement trim()quelque chose comme le code ci-dessous:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
   return !(!!this.trim().length);
}

et vous pouvez l'appeler de cette façon:

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false

Quel avantage y a-t-il à faire !(!!this.length)plutôt que juste !this(ou !this.trim()pour la deuxième option)? Une chaîne de longueur nulle est déjà fausse, les parenthèses sont redondantes et la nier trois fois équivaut exactement à la nier une fois.
John Montgomery

8

Essaye ça:

export const isEmpty = string => (!string || !string.length);

8

J'ai fait des recherches sur ce qui se passe si vous passez une valeur non chaîne et non vide / nulle à une fonction de testeur. Comme beaucoup le savent, (0 == "") est vrai en JavaScript, mais comme 0 est une valeur et non vide ou nulle, vous voudrez peut-être la tester.

Les deux fonctions suivantes renvoient true uniquement pour les valeurs non définies, nulles, vides / blancs et false pour tout le reste, comme les nombres, les booléens, les objets, les expressions, etc.

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

Des exemples plus compliqués existent, mais ils sont simples et donnent des résultats cohérents. Il n'est pas nécessaire de tester undefined, car il est inclus dans la vérification (valeur == null). Vous pouvez également imiter le comportement C # en les ajoutant à String comme ceci:

String.IsNullOrEmpty = function (value) { ... }

Vous ne voulez pas le mettre dans le prototype Strings, car si l'instance de la classe String est nulle, cela produira une erreur:

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // Could be set
myvar.IsNullOrEmpty(); // Throws error

J'ai testé avec le tableau de valeurs suivant. Vous pouvez le parcourir pour tester vos fonctions en cas de doute.

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // Valid number in some locales, not in JavaScript
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];

Si vous arrêtez simplement d'utiliser == et utilisez ===, cela résout le problème si (s === "").
Scott Marcus

8

Pour vérifier s'il s'agit exactement d'une chaîne vide:

if(val==="")...

Pour vérifier s'il s'agit d'une chaîne vide OU d'un équivalent logique pour aucune valeur (null, undefined, 0, NaN, false, ...):

if(!val)...

7

Il n'y a pas de isEmpty()méthode, vous devez vérifier le type et la longueur:

if (typeof test === 'string' && test.length === 0){
  ...

La vérification de type est nécessaire afin d'éviter les erreurs d'exécution lorsque testest undefinedou null.


7

En ignorant les chaînes d'espaces blancs, vous pouvez utiliser ceci pour vérifier les valeurs nulles, vides et non définies:

var obj = {};
(!!obj.str) // Returns false

obj.str = "";
(!!obj.str) // Returns false

obj.str = null;
(!!obj.str) // Returns false

Il est concis et fonctionne pour les propriétés non définies, bien qu'il ne soit pas le plus lisible.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.