J'ai vu cette question , 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 ""
?
J'ai vu cette question , 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 ""
?
Réponses:
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 === "") {
//...
}
=== ''
vs .length
n'ont montré aucune amélioration perceptible (et n'utilisent .length
que des travaux si vous pouvez supposer que vous avez une chaîne)
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());
};
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.
/^\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/…
if blue is the sky
. Voir dodgycoder.net/2011/11/11/yoda-conditions-pokemon-exception.html
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ù str
est une variable.
Il revient false
pour null,undefined,0,000,"",false
.
Il renvoie la true
chaîne "0" et les espaces "".
if(str)
et if(!!str)
?
var any = (!!str1 && !!str2 && !!str3)
manipulation s'il y a un certain nombre là aussi
!!str.trim()
pour vous assurer que la chaîne n'est pas faite uniquement d'espaces.
Boolean(str)
est beaucoup plus lisible et moins "wtfish".
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) { ...
str.Empty
.
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,"") == ""){
}
if(str.match(/\S/g)){}
str.match(/\S/)
var trimLeft = /^\s+/, trimRight = /\s+$/;
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
typeof
dans le switch
ne fonctionnait pas pour moi. J'ai ajouté un if (typeof e == "undefined")
test et ça marche. Pourquoi?
case undefined:
place de case typeof(e) == "undefined":
?
Vous pouvez utiliser lodash : _.isEmpty (valeur).
Il couvre beaucoup de cas comme {}
, ''
, null
,undefined
, etc.
Mais elle retourne toujours true
pour le Number
type de JavaScript types de données primitives comme _.isEmpty(10)
ou les _.isEmpty(Number.MAX_VALUE)
deux déclarations true
.
_.isEmpty(" "); // => false
" "
n'est pas vide. _.isEmpty("");
renvoie vrai.
Essayer:
if (str && str.trim().length) {
//...
}
str.trim().length
fera plus vite que str.trim()
d'environ 1% selon mes propres résultats de test.
if (!str) { ... }
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
;
if
déclaration.
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.
===
. Il ne renvoie vrai que si strVar
est une chaîne vide.
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
!str
, ==
, ===
etlength
sont rapides pour tous les navigateurs (A, B, C, G, I, J)test
, replace
) etcharAt
sont les plus lentes pour tous les navigateurs (H, L, M, P)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 fonction0
1
NaN
Infinity
- Nombrestrue
false
- booléennull
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
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.
str.length === 0
renvoie true pour toute fonction qui n'a pas de paramètres formels.
Vous pouvez également utiliser des expressions régulières:
if((/^\s*$/).test(str)) { }
Recherche les chaînes vides ou remplies d'espaces.
var a;
existentrogner false spaces
la valeur, puis tester pouremptiness
if ((a)&&(a.trim()!=''))
{
// if variable a is not empty do this
}
J'utilise habituellement quelque chose comme ça,
if (!str.length) {
// Do something
}
typeof variable != "undefined"
avant de vérifier s'il est vide.
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.).
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
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.
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.
Math.random()
renvoie un nombre et non une chaîne. Et cette réponse concerne les chaînes. ;-)
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 .
empty(0)
et devez empty(7)
renvoyer la même valeur.
empty("0")
doit retourner false
(car ce n'est pas une chaîne vide), mais empty(0)
doit retourner true
parce qu'elle est vide :)
empty
c'est un nom trompeur dans ce cas.
empty
c'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.
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, 0
cela 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
Essaye ça
str.value.length == 0
"".value.length
provoquera une erreur. Cela devrait êtrestr.length === 0
TypeError
If str
est égal à undefined
ounull
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
!(!!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.
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; } }]
];
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 test
est undefined
ou null
.
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.