web-dev-qa-db-fra.com

Comment vérifier une chaîne vide / indéfinie / nulle en JavaScript?

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

javascriptnullis-empty
2549
casademora

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

if (strValue) {
    //do something
}

Si vous avez besoin de rechercher spécifiquement une chaîne vide sur null, je pense que vérifier avec "" est votre meilleur choix, en utilisant l'opérateur === (pour que vous sachiez qu'il est en fait une chaîne avec laquelle vous comparez).

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

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:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};
1035
Jano González

Tout ce qui précède est bon mais ce sera encore mieux. utilisez !! (( pas opérateur ).

if(!!str){
some code here;
}

ou utilisez le type casting:

if(Boolean(str)){
    codes here;
}

Les deux remplissent la même fonction, tapez la variable booléen, où str est une variable.
Renvoie false pour null,undefined,0,000,"",false.
Renvoie true pour la chaîne "0" et les espaces "".

266
karthick.sk

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

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

La chose la plus proche de str.Empty (avec comme condition préalable que str soit une chaîne) est:

if (!str.length) { ...
91
Ates Goral

J'utilise :

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

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

Essayer:

if (str && str.trim().length) {  
    //...
}
32
Yang Dong

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))
  );
}

p.s. En Javascript, n'utilisez pas Line-Break après return;

31
T.Todua
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 soit sur length (si vous savez que la variable var sera toujours une chaîne), soit sur "".

30
cllpse

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

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

Mais il retourne toujours true pour Number type de Types de données primitifs Javascript comme _.isEmpty(10) ou _.isEmpty(Number.MAX_VALUE) les deux retournent true.

29
Moshii

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éralement strVar == "".

EDIT: par commentaire de Constantin , si strVar pouvait contenir une valeur entière égale à 0, il s'agirait bien d'une de ces situations de clarification d'intention.

26
Chris Noe

vous pouvez aussi aller avec les expressions régulières:

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

Vérifie les chaînes vides ou remplies d'espaces.

19
oem
  1. vérifier que var a; existe

  2. découper le false spaces dans la valeur, puis tester emptiness

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

Beaucoup de réponses et de nombreuses possibilités!

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

Cependant, comme beaucoup d'autres exemples sont disponibles. La meilleure méthode fonctionnelle pour y parvenir, je suggérerais:

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.

16
tfont

De même, si vous considérez une chaîne remplie par un espace comme "vide". Vous pouvez le tester avec cette regex:

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

J'utilise habituellement quelque chose comme ça,

if (!str.length) {
//do some thing
}
12
user2086641

Je n'ai pas remarqué de réponse qui prenne 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

Cela fonctionne sur une chaîne nulle et sur une chaîne vide et il est accessible pour toutes les chaînes. De plus, il pourrait être étendu pour contenir d’autres caractères JavaScript vides ou espaces (par exemple, espace insécable, repère d’octet, séparateur de ligne/paragraphe, etc.).

9
Bikush

Toutes ces réponses sont gentilles.

Mais je ne peux pas être sûr que cette variable est une chaîne, ne contient pas seulement 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 .

9
Andron

S'il faut détecter non seulement les chaînes vides, mais également les chaînes vides, j'ajouterai à la réponse de Goral:

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

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

pour vérifier si est exactement une chaîne vide:

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

pour vérifier s'il s'agit d'une chaîne vide ORa un équivalent logique de no-value (null, indéfini, 0, NaN, false, ...):

if(!val)...
7
Luca C.

J'utilise habituellement quelque chose comme:

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}
7
jmc734

En attendant, nous pouvons avoir une fonction qui vérifie tous les "vides" comme null, undefined, '', '', {}, []. Alors je viens 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
7
Imran

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

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

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

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

Concis et cela fonctionne pour les propriétés non définies, bien que ce ne soit pas le plus lisible.

7
mricci

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

Les deux fonctions suivantes ne renvoient vrai que pour les valeurs non définies, nulles, vides/espaces, et faux 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 complexes existent, mais ils sont simples et donnent des résultats cohérents. Il n'est pas nécessaire de tester non défini, 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 de Strings, car si l'instance de la classe String est nulle, l'erreur sera la suivante:

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 js
    ['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; } }]
];
7
JHM

J'utilise une combinaison, les contrôles les plus rapides sont les premiers.

function isBlank(pString){
    if (!pString || pString.length == 0) {
        return true;
    }
    // checks for a non-white space character 
    // which I think [citation needed] is faster 
    // than removing all the whitespace and checking 
    // against an empty string
    return !/[^\s]+/.test(pString);
}
7
Will

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

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

La vérification du type est nécessaire pour éviter les erreurs d’exécution lorsque test est undefined ou null.

6
Agustí Sánchez

Vous pouvez facilement l'ajouter à l'objet String natif dans 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 voulez vérifier '' chaînes vides:

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

Sinon, si vous souhaitez vérifier à la fois '' chaîne vide et ' ' avec un espace, vous pouvez le faire en ajoutant simplement trim(), un peu 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
5
Alireza

Ne supposez pas que la variable que vous vérifiez est une chaîne. Ne supposez pas que si cette variable a une longueur, c'est une chaîne.

Le problème est le suivant: réfléchissez bien à ce que votre application doit faire et peut accepter. Construire quelque chose de robuste.

Si votre méthode/fonction ne doit traiter qu'une chaîne non vide, testez si l'argument est une chaîne non vide et ne faites pas de "truc".

Comme exemple de quelque chose qui va exploser si vous suivez quelques conseils ici pas soigneusement.


var getLastChar = function (str) {
 if (str.length > 0)
   return str.charAt(str.length - 1)
}

getLastChar('hello')
=> "o"

getLastChar([0,1,2,3])
=> TypeError: Object [object Array] has no method 'charAt'

Donc, je resterais avec


if (myVar === '')
  ...
5
Kev

Essaye ça

str.value.length == 0
5
Doug

Vous pouvez être capable de valider les moyens suivants et comprendre la différence.

var j = undefined;
console.log((typeof j == 'undefined') ? "true":"false");
var j = null; 
console.log((j == null) ? "true":"false");
var j = "";
console.log((!j) ? "true":"false");
var j = "Hi";
console.log((!j) ? "true":"false");
4
KARTHIKEYAN.A

La bibliothèque javascript underscore http://underscorejs.org/ fournit une fonction très utile _.isEmpty() pour la recherche de chaînes vides et d'autres objets vides.

Référence: http://underscorejs.org/#isEmpty

isEmpty _.isEmpty(object)
Renvoie true si un objet énumérable ne contient aucune valeur (pas de propriétés propres énumérables). Pour les chaînes et les objets de type tableau, _.isEmpty vérifie si la propriété de longueur est 0.

_.isEmpty([1, 2, 3]);
=> false

_.isEmpty({});
=> true

D'autres fonctions de soulignement très utiles incluent:
http://underscorejs.org/#isNull_.isNull(object)
http://underscorejs.org/#isUndefined_.isUndefined(value)
http://underscorejs.org/#has_.has(object, key)

4
Thaddeus Albers
function tell()
{
var pass = document.getElementById('pasword').value;
var plen = pass.length;

now you can check if your string is empty as like 
if(plen==0)
{
         alert('empty');
}
else
{
   alert('you entered something');
}
}


<input type='text' id='pasword' />

c'est aussi un moyen générique de vérifier si le champ est vide.

4
Muhammad Salman

Vous devez également toujours vérifier le type, car JavaScript est un langage typé "canard". Vous risquez donc de ne pas savoir quand et comment les données ont été modifiées au cours du processus. Alors, voici la meilleure solution:

var str = "";
if (str === "") {
    //...
}
3
Sazid

Je préfère utiliser le test pas vide au lieu de blanc

function isNotBlank(str) {
   return (str && /^\s*$/.test(str));
}
3
Mubashar

C'est aussi une bonne idée de vérifier que vous n'essayez pas de passer un terme non défini.

function TestMe() {
  if((typeof str != 'undefined') && str) {
    alert(str);
  }
 };

TestMe();

var str = 'hello';

TestMe();

Je rencontre habituellement le cas où je veux faire quelque chose lorsqu'un attribut de chaîne pour une instance d'objet n'est pas vide. Ce qui est bien, sauf que cet attribut n'est pas toujours présent.

2
dkinzer

Essaye ça:

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

Une autre solution, mais je pense que la réponse de bdukes est la meilleure.

   var myString = 'hello'; 
    if(myString.charAt(0)){
    alert('no empty');
    }
    alert('empty');
2
GibboK

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 du wrapper pour une chaîne vide comme:

// considering the variable in which your string is saved is named str.
if(str !== null || str!== undefined){
  if (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 cette chaîne n'est pas indéfinie ni nulle. Rappelez-vous, indéfini, nul et vide sont trois choses différentes.

0
Harshit Agarwal