Comment puis-je rechercher une chaîne vide / indéfinie / nulle dans Ja

Comment puis-je rechercher une chaîne vide / indéfinie / nulle dans JavaScript?

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

Montrez la meilleure réponse

juste pour info, je pense que les API les plus utiles pour la classe String se trouvent sur Mozilla et kit 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/Reference/Global_Objects‌ /…

Cela aiderait grandement si l'exigence était clairement spécifiée. Pour quelles valeurs isEmpty doit-il renvoyer true? La vérification de "" en déduit qu'elle ne doit renvoyer true que si la valeur est Type string et longueur 0. De nombreuses réponses ici supposent qu'il doit également renvoyer true pour certaines ou toutes les valeurs falsey.

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 la vérification par rapport à "" est votre meilleur pari, en utilisant l'opérateur === (pour que vous sachiez qu'il s'agit en fait d'une chaîne à laquelle vous comparez).

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

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 effectuant un profilage naïf dans les outils de développement Chrome, tester === '' vs .length n'a montré aucune amélioration perceptible (et utiliser .length ne fonctionne que si vous pouvez supposer que vous avez une chaîne)

@bdukes lorsque vous commencez à vous soucier de ce genre de micro-optimisations, je ne pense pas que Chrome soit le navigateur où vous rencontrez la plupart de vos problèmes de performances ...

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 d'un ou plusieurs espaces renvoie true 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 /…

@Chad, Votre jsPerf est assez imparfait, car l'un des tests compare pour une valeur spécifique, tandis que l'autre compare pour n'importe quelle valeur sauf vide. Donc, pour être juste, le premier test doit être s!=="" qui est «seulement» 24% plus lent que s.length > 0

Comme il varie d'une version à l'autre de Chrome, la bonne façon est de l'écrire afin qu'il identifie quelle version de chrome se trouve dans quelle liste et utilise la méthode la plus rapide: P Vous passerez plus de cycles à vérifier quelle version de chrome vous utilisez et qui est le plus rapide. Honnêtement, c'est si proche en comparaison ces derniers temps, choisissez simplement la saveur qui vous convient le mieux. Ne pas vérifier la longueur est bien pour certaines capacités de type canard. Bien que tout le monde connaisse les dangers des canards et devrait exécuter TypeScript; fact ™.

@ kir.gera, JavaScript ne donne pas d'erreurs de compilation, obtenez-vous cette erreur du compilateur TypeScript? Si votre compilateur veut une valeur bool stricte, vous pouvez Boolean(u.GroupRole) ou !!u.GroupRole

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 == "" .

Selon le commentaire de Constantin , si strVar pouvait finir par contenir une valeur entière 0, alors ce serait être en fait l'une de ces situations de clarification des intentions.

Mauvaise idée. Vous deviendrez vrai si strVar est accidentellement attribué à 0.

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

@ValentinHeinitz si str avait une valeur falsey de 0 ou "0", si (str) rapporterait faussement true. La meilleure approche est if (str === ""). C'est simple et cela n'échouera jamais.

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

Rien ne représente une chaîne vide en JavaScript. Faites une vérification soit contre length (si vous savez que la var sera toujours une chaîne) ou contre ""

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

if (!str.length) { ...
 

Cela ne lèverait-il pas une exception si str est nul?

@PicMickael Oui! Tout comme str.Empty .

Si vous avez besoin de vous assurer que la chaîne n'est pas simplement 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,"") == ""){
}
 

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

Qu'en est-il de la propriété de longueur?

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 de retour de nouvelle chaîne que vous vérifiez ensuite. if(str.match(/\S/g)){}

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

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

+1 J'ai essayé cette méthode et cela a fonctionné pour moi. L'utilisateur peut entrer des espaces vides qui sont encore vides.

if(str.replace(/^\s+|\s+$/g,"")){...}+ suffirait

Pourquoi n'utiliseriez-vous pas simplement if(str.trim()) {...} ?

Peut-être que /\S/.test(str) est meilleur que str.match(/\S/) car il ne se soucie pas de renvoyer un tableau de résultats correspondants (cela pourrait être un gain de micro-performances). De plus, lorsque vous testez une chaîne par rapport à une expression régulière, utilisez la méthode RegExp .test() pour mieux transmettre cette intention.

J'utilise généralement quelque chose comme:

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

L'opérateur == n'est pas strict. Ainsi si str == "" , str peut être null , undefined , false , 0 , [] , etc.

Avatar Jet

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
  

Cette solution est plus indépendante de la langue. La seule fonctionnalité JavaScript sur laquelle il s'appuie est le typeof. C'est donc un bon exemple de solution que vous pouvez utiliser lorsque vous ne faites pas confiance aux implémentations de 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. Ce n'est pas le plus propre, mais vous pouvez être sûr que cela fonctionnera sans en savoir trop sur JavaScript.

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

Le typeof dans le switch ne fonctionnait pas pour moi. J'ai ajouté un test if (typeof e == "undefined") et cela fonctionne. Pourquoi?

@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)

Pouvons-nous utiliser case undefined: au lieu de case typeof(e) == "undefined": ?

Essayez ceci

str.value.length == 0
 

"".value.length provoquera une erreur. Ce devrait être str.length === 0

Ceci trow un TypeError Si str est égal à undefined ou null

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.

J'utilise une combinaison et les vérifications les plus rapides sont les premières.

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

Vous vous demandez simplement si vous pourriez expliquer quand le contrôle de longueur serait nécessaire? Est-ce que! PString n'attraperait rien qui était une chaîne nulle / vide? Cela semble fonctionner. var test = ''; if (! test) alert ('vide');

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
 

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

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 pour toutes les chaînes. De plus, il pourrait être développé pour contenir d'autres caractères JavaScript vides ou d'espaces blancs (c'est-à-dire espace insécable, marque d'ordre d'octet, séparateur de ligne / paragraphe, etc.).

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 être source de 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 dans l'esprit de chaque développeur.

C'est également une bonne idée de vérifier que vous n'essayez pas de transmettre un terme indéfini.

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

TestMe();

var str = 'hello';

TestMe();
 

Je rencontre généralement 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.

Essayez:

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

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

str.trim().length fera plus vite que str.trim() , d'environ 1% selon mon propre résultat de test.

OP cherche à tester une chaîne vide, indéfinie ou nulle. Ceci teste une chaîne qui ne correspond à aucune de ces conditions. Il n'a rien dit non plus sur les chaînes uniquement d'espaces blancs. Vous pouvez tester les conditions d'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) { ... }

Une autre manière, mais je crois que La réponse de bdukes est la meilleure.

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

Toutes ces réponses sont bien.

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 .

Hein? Si vous attendez une chaîne, empty(0) et empty(7) doivent renvoyer la même valeur.

Dans mon cas particulier - empty("0") doit renvoyer false (car ce n'est pas une chaîne vide), mais empty(0) doit renvoyer true car il est vide :)

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 exigences, mais empty est un nom trompeur dans ce cas.

Je pense que ce nom empty est bon. Dans la documentation 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 PHP et cette fonction - cette chaîne '0' ne sera pas identifiée comme vide.

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

Avatar JHM

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 null, vous voudrez peut-être le tester.

Les deux fonctions suivantes ne renvoient true que pour les valeurs non définies, nulles, vides / d'espaces et false pour tout le reste, comme les nombres, les valeurs booléennes, 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 ceux-ci sont simples et donnent des résultats cohérents. Il n'est pas nécessaire de tester undefined, car il est inclus dans (value == null) check. Vous pouvez également imiter le comportement de 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 provoquera 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 if (s === "").

Je préfère utiliser un test non vierge au lieu de blanc

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

Mettre la négation dans les noms de fonctions est une mauvaise idée. Votre code lui-même est très bien, mais la fonction devrait être appelée quelque chose comme hasValue (). Pourquoi? Que se passe-t-il lorsque vous voyez un code comme celui-ci: "if (! IsNotBlank (str))" ... Ce n'est pas immédiatement clair ce que l'intention est censée être. Cela peut ne pas vous sembler pertinent pour cet exemple simple, mais ajouter une négation à un nom de fonction est toujours une mauvaise idée.

IsNotBlank est une fonction standard et une fonction très populaire dans StringUtils commons.apache.org/proper/commons-lang/apidocs/org/apache/…

il fournit également l'IsBlank pour éviter les doubles négatifs. Je pense que les noms de fonction doivent refléter les fonctionnalités qu'ils exécutent et qu'il serait plus facile pour les développeurs de comprendre lorsqu'ils voient les fonctions isBlank et IsNotBlank dans la même classe.

Avatar Kev

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

Le fait est: réfléchissez bien à ce que votre application doit faire et peut accepter. Construisez 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».

À titre d'exemple de quelque chose qui explosera si vous ne suivez pas attentivement certains conseils ici.


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'
 

Alors, je m'en tiens à


if (myVar === '')
  ...
 

J'utilise généralement quelque chose comme ça,

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

Plus rapide si vous savez que la variable est une chaîne. Lève une erreur si la variable n'est pas définie.

@ AdrianHope-Bailie pourquoi testeriez-vous une variable non définie?

@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'une méthode ou d'un appel 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 s'il est nul, vous obtiendrez une erreur. var test = null; if (! test.length) {alert ("adrian est faux");}

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.

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 Ils testent différentes choses. Cela n'a aucun sens de les mettre tous dans une seule instruction if .

typeof MyVariable == 'undefined' ne discerne pas entre une variable initialisée avec une valeur non définie et une variable non déclarée à moins que la variable n'ait été initialement déclarée et initialisée à null. La vérification de la propriété length entraîne l'encapsulation de la primitive de chaîne dans un objet chaîne.

var x ="  ";
var patt = /^\s*$/g;
isBlank = patt.test(x);
alert(isBlank); // Is it blank or not??
x = x.replace(/\s*/g, ""); // Another way of replacing blanks with ""
if (x===""){
    alert("ya it is blank")
}
 

Vous devriez toujours vérifier le type également, car JavaScript est un langage typé canard, vous ne savez donc peut-être pas quand et comment les données ont changé au milieu du processus. Alors, voici la meilleure solution:

     let undefinedStr;
    if (!undefinedStr) {
      console.log("String is undefined");
    }
    
    let emptyStr = "";
    if (!emptyStr) {
      console.log("String is empty");
    }
    
    let nullStr = null;
    if (!nullStr) {
      console.log("String is null");
    }  

Pour vérifier s'il est vide:

var str = "Hello World!";
var n = str.length;
if(n === ''){alert("THE STRING str is EMPTY");}
 

Pour vérifier s'il n'est pas vide

var str = "Hello World!";
var n = str.length;
if(n != ''){alert("THE STRING str isn't EMPTY");}
 

Faux. length n'est pas null . str = ''; str.length == 0 et non str.length == null . Mais dans l'ensemble, votre approche est correcte.

La vérification de la propriété length entraînera l'enveloppement de la primitive de chaîne dans un objet string et la vérification de null n'est pas non plus correcte car elle ne recherche pas undefined (ce qui n'est pas la même chose). Pour tester une chaîne vide, vérifiez-la simplement par rapport à "" (c'est-à-dire if (myString === ""))

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

  1. vérifiez que var a; existe
  2. découpez le false spaces dans la valeur, puis testez emptiness

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

<html>
    <head>
        <script lang="javascript">

            function nullcheck()
            {
                var n = "fdgdfg";
                var e = n.length;
                if (e == 0)
                {
                    return true;
                }
                else
                {
                    alert("success");
                    return false;
                }
            }
        </script>
    </head>

    <body>
        <button type="submit" value="add" onclick="nullcheck()"></button>
    </body>
</html>
 

Une explication s'impose.

La bibliothèque JavaScript Underscore.js , http://underscorejs.org/ , fournit une fonction _.isEmpty() très utile pour vérifier les chaînes vides et autres objets vides.

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

est vide _.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é length est 0.

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

_.isEmpty({});
=> vrai

D'autres fonctions Underscore.js très utiles incluent:

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

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

Cependant, autant 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.

La recherche d'indéfini devra ê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 précédentes.

Complètement d'accord! BELLE PRISE. Je vais modifier ma réponse ci-dessus!

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

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 de type est nécessaire pour éviter les erreurs d'exécution lorsque test est undefined ou null .

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)...
 

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

Il couvre de nombreux cas tels que {} , '' , null , undefined , etc.

Mais il renvoie toujours true pour le type Number de Les types de données JavaScript primitifs comme _.isEmpty(10) ou _.isEmpty(Number.MAX_VALUE) tous les deux renvoient true .

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

@Erich Parce que " " n'est pas vide. _.isEmpty(""); renvoie vrai.

tout à fait vrai - j'ai mentionné cela parce que quelques-unes des autres réponses ici impliquent la validation du formulaire et la vérification si une chaîne se compose uniquement d'espaces blancs, et cette fonction lodash unique en elle-même ne résoudra pas ce problème.

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 les '' 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 simplement en ajoutant trim() , quelque chose comme le code ci-dessous:

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

et vous pouvez l'appeler ainsi:

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

Quel avantage y a-t-il à faire !(!!this.length) plutôt que simplement !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 l'annuler trois fois équivaut exactement à l'annuler une fois.

Vous pouvez valider les méthodes suivantes 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");  

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
 

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 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 indéfinie ou nulle. Rappelez-vous, indéfini, nul et vide sont trois choses différentes.

Cela générerait une erreur sur null ou undefined car nous ne devrions pas faire directement une opération sur une variable qui est nulle ou non définie - vérifiez si 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.

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

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

Essayez ceci:

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

L'expression régulière suivante est une autre solution, qui peut être utilisée pour une chaîne nulle, vide ou non définie.

(/(null|undefined|^$)/).test(null)
 

J'ai ajouté cette solution, car elle peut être étendue pour vérifier le vide ou une valeur comme suit. L'expression régulière suivante vérifie que l'une ou l'autre chaîne peut être vide null non définie ou qu'elle ne contient que des entiers.

(/(null|undefined|^$|^\d+$)/).test()
 

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 et vous pouvez ensuite vérifier si elle est égale à null ou est égale à une chaîne vide.

Vous ne pouvez pas avoir !! ou seulement if(value) puisque si vous cochez 0 cela vous donnera une fausse réponse (0 est faux).

Cela dit, résumez-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 typeof , car il exploserait et se lancerait avant même 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 (ainsi que 0, -0, false, NaN) comme false. Voir stackoverflow.com/questions/856324/...

Vérifiez tous les scénarios ci-dessous:

  1. null

  2. non défini

  3. 0

  4. "" (la chaîne vide)

  5. faux

  6. NaN

Performances

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.

  • les solutions simples basées sur !str ,== ,=== et length sont rapides pour tous les navigateurs (A, B, C , G, I, J)
  • les solutions basées sur l'expression régulière (test , replace ) et charAt 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 une seule exécution de test, mais dans de nombreuses exécutions, 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.

 function A(str) {
  let r=1;
  if (!str)
    r=0;
  return r;
}

function B(str) {
  let r=1;
  if (str == "")
    r=0;
  return r;
}

function C(str) {
  let r=1;
  if (str === "")
    r=0;
  return r;
}

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
    r=0;
  return r;
}

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
    r=0;
  return r;
}

function F(str) {
  let r=1;
  if(!Boolean(str))
    r=0;
  return r;
}

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
    r=0;
  return r;
}

function H(str) {
  let r=1;
  if(!/\S/.test(str))
    r=0;
  return r;
}

function I(str) {
  let r=1;
  if (!str.length)
    r=0;
  return r;
}

function J(str) {
  let r=1;
  if(str.length <= 0)
    r=0;
  return r;
}

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
    r=0;
  return r;
}

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
    r=0;
  return r;
}

function M(str) {
  let r=1;
  if((/^\s*$/).test(str))
    r=0;
  return r;
}


function N(str) {
  let r=1;
  if(!str || !str.trim().length)
    r=0;
  return r;
}

function O(str) {
  let r=1;
  if(!str || !str.trim())
    r=0;
  return r;
}

function P(str) {
  let r=1;
  if(!str.charAt(0))
    r=0;
  return r;
}

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
    r=0;
  return r;
}

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

    r=0;
  return r;
}




// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);  

Et puis, pour toutes les méthodes, j'effectue un scénario de test de vitesse str = "" 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é! Merci!