Come posso verificare la presenza di una stringa vuota / non definita / null in JavaScript?


2853

Ho visto questa domanda , ma non ho visto un esempio specifico di JavaScript. C'è un semplice string.Emptydisponibile in JavaScript o è solo un caso di verifica ""?


2
solo FYI, penso che le API più utili per la classe String siano su Mozilla e javascript kit . [elated.com] ( elated.com/articles/working-with-strings ) ha un tutorial su tutte le proprietà, i metodi di String, ... Nota: il link Mozilla è stato aggiornato a developer.mozilla.org/en/ JavaScript / Riferimenti / Global_Objects /…
Gene T


Sarebbe di grande aiuto se il requisito fosse chiaramente specificato. Per quali valori deve essere restituito true? Il controllo di "" indica che dovrebbe restituire vero solo se il valore è Tipo stringa e lunghezza 0. Molte risposte qui presuppongono che debba restituire vero anche per alcuni o tutti i valori di falso.
RobG

Risposte:


3572

Se vuoi solo verificare se c'è qualche valore, puoi farlo

if (strValue) {
    //do something
}

Se hai bisogno di controllare specificatamente una stringa vuota su null, penso che fare il check in ""sia la tua scommessa migliore, usando l' ===operatore (in modo da sapere che in realtà è una stringa con cui stai confrontando).

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

174
Il test della proprietà length potrebbe effettivamente essere più veloce del test della stringa rispetto a "", poiché l'interprete non dovrà creare un oggetto String dal valore letterale della stringa.
Vincent Robert,

26
@Vincent sta facendo un po 'di profilatura ingenua negli strumenti di sviluppo di Chrome, test === ''vs .lengthnon ha mostrato alcun miglioramento visibile (e l'utilizzo di .lengthopere funziona solo se puoi supporre di avere una stringa)
bdukes

26
@bdukes quando inizi a interessarti a quel tipo di micro-ottimizzazioni, non credo che Chrome sia il browser in cui stai riscontrando la maggior parte dei tuoi problemi di prestazioni ...
Vincent Robert,

15
Solo per notare, se la tua definizione di "stringa vuota" include spazi bianchi, questa soluzione non è appropriata. Una stringa di 1 o più spazi restituisce true sopra. Se si utilizza JQuery si può semplicemente utilizzare questo: if ($ .trim (ref) .length === 0) - come da questa risposta a una domanda simile: stackoverflow.com/questions/2031085/...
CodeClimber

115
Come previsto, in .length > 0realtà è molto più veloce rispetto a una stringa letterale! Dai
Chad,

1128

Per verificare se una stringa è vuota, nulla o non definita, utilizzo:

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

Per verificare se una stringa è vuota, nulla o non definita, utilizzo:

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

Per verificare se una stringa è vuota o contiene solo spazi bianchi:

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

21
perché 0 === str.length invece di str.length === 0?
Vincent,

66
Le condizioni @Vincent sono spesso scritte in questo modo if (variable == constant value)e se si dimentica un '=', si assegna il valore costante alla variabile invece di testare. Il codice continuerà a funzionare poiché puoi assegnare una variabile in un if. Quindi un modo più sicuro per scrivere questa condizione è invertire il valore costante e la variabile. In questo modo quando testerai il tuo codice vedrai un errore (lato mancino nell'assegnazione). Puoi anche usare qualcosa come JSHint per impedire l'assegnazione in condizioni ed essere avvisato quando ne scrivi una.
Florian,

2
peccato che /^\s*$/.test(str)non sia davvero leggibile - forse sarebbe meglio rimuovere gli spazi usando un codice più semplice o regex? vedi stackoverflow.com/questions/6623231/… e anche stackoverflow.com/questions/10800355/…
Adrien Be

6
/^\s*$/.test(str) può essere sostituito con str.trim (). length === 0
Schadenfreude

21
@Vincent questo è anche chiamato "Condizioni Yoda", come if blue is the sky. Vedi dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html
AZ.

316

Tutte le risposte precedenti sono buone, ma sarà ancora meglio. Utilizzare l' operatore !!( non ).

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

Oppure usa il tipo casting:

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

Entrambi svolgono la stessa funzione. Digita la variabile in booleano, dove strè una variabile.
Ritorna falseper null,undefined,0,000,"",false.
Restituisce trueper la stringa "0" e lo spazio bianco "".


61
Perché questo "è ancora meglio"?
Mene,

33
C'è qualche differenza tra il comportamento di if(str)e if(!!str)?
Peter Olson,

6
@PeterOlson se stai cercando di salvare una variabile come booleana che controlla più stringhe per il contenuto, ti consigliamo di farlo .. aka var any = (!!str1 && !!str2 && !!str3)gestione se c'è anche un numero lì dentro
John Ruddell

23
Questa è la soluzione che uso sempre. !!str.trim()per assicurarsi che la stringa non sia composta solo da spazi bianchi.
Dario Oddenino,

5
Non sembra un hack, Boolean(str)è molto più leggibile e meno "wtfish".
shinzou,

105

La cosa più vicina a cui puoi arrivare str.Empty(con il presupposto che str sia una stringa) è:

if (!str.length) { ...

9
Non sarebbe un'eccezione che str sia nullo?
Pic Mickael,

3
@PicMickael Sì! Così sarebbe str.Empty.
Ates Goral,

99

Se devi assicurarti che la stringa non sia solo un mucchio di spazi vuoti (suppongo che questo sia per la convalida del modulo) devi fare una sostituzione sugli spazi.

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

8
Ma fa il lavoro se ciò che si desidera effettivamente testare è una stringa con contenuto non spaziale. C'è un modo meno costoso per testarlo?
lampeggia il

4
Che ne dici della proprietà length?
dall'11

27
Invece di rimuovere tutti gli spazi, perché non controllare se esiste un non spazio? Ha 2 vantaggi che può essere salvato in anticipo se c'è un carattere non spaziale e non ha una nuova stringa che poi verifichi. if(str.match(/\S/g)){}
aprono il

34
@Mark FYI, non è necessario il modificatore globale, poiché la corrispondenza della prima occorrenza di un carattere non spaziale significherebbe che la stringa non è vuota:str.match(/\S/)
Neezer,

1
perché è costoso? Se lo è davvero, perché jQuery utilizza questo metodo? Puoi trovarlo nella fonte di jQueryvar trimLeft = /^\s+/, trimRight = /\s+$/;
Marecky

66

Io uso:

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
Questa soluzione è più agnostica del linguaggio. L'unica funzione JavaScript su cui si basa è typeof. Quindi è un buon esempio di soluzione che puoi usare quando non ti fidi delle implementazioni in diversi browser e non hai tempo per trovare una soluzione migliore. (IE, nessun accesso a Internet). È qualcosa come una prova. Non il più pulito, ma puoi essere sicuro che funzionerà senza sapere troppo su JavaScript.
Jeff Davis,

2
Andrei ancora un po 'oltre e lo inchioderei con un operatore === per il caso indefinito. Altrimenti è semplicemente la risposta perfetta.
xarlymg89,

Il typeofnel switchnon ha funzionato per me. Ho aggiunto un if (typeof e == "undefined")test e funziona. Perché?
Lucas,

1
@Lucas Perché questo era un errore di battitura o una svista. La tua modifica è l'approccio corretto. (l'originale si riferisce al contesto della funzione vuota, non al parametro e, che è ciò che la funzione dovrebbe verificare)
beeThree

Potremmo usare al case undefined:posto di case typeof(e) == "undefined":?
Boris J.

43

Puoi usare lodash : _.isEmpty (valore).

Esso copre un sacco di casi come {}, '', null,undefined , etc.

Ma restituisce sempre trueper Numbertipi di dati di tipo primitivo JavaScript come _.isEmpty(10)o _.isEmpty(Number.MAX_VALUE)entrambi i ritorni true.


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

1
@Erich Perché " "non è vuoto. _.isEmpty("");ritorna vero.
Moshii

1
abbastanza vero - l'ho menzionato perché alcune delle altre risposte qui implicano la convalida del modulo e il controllo se una stringa è composta solo da spazi bianchi, e questa singola funzione lodash da sola non risolverà quel problema.
Erich,

@Erich, ora ho capito il tuo punto, grazie per averlo menzionato.
Moshii,

36

Funzione:

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: in JavaScript, non utilizzare l'interruzione di riga dopo return;


1
Qualche possibilità che potresti spiegare cosa sta facendo ogni controllo? :)
DanV,

2
-1 Stanno testando cose diverse. Non ha senso metterli tutti in una iffrase.
Bennett McElwee,

1
typeof MyVariable == 'undefined' non discerne tra una variabile inizializzata con un valore indefinito e una variabile non dichiarata a meno che la variabile non sia stata inizialmente dichiarata e inizializzata su null. Il controllo della proprietà length comporta il wrapping della primitiva di stringa in un oggetto stringa.
Scott Marcus,

35

Provare:

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

2
È necessaria la proprietà length?
frogcoder

str.trim().lengthfarà più velocemente di str.trim()circa l'1% secondo il mio risultato del test.
Devildelta,

2
@devildelta - Il tuo 1% è un errore nel tuo test.
Stephen M Irving,

OP sta cercando di verificare la stringa vuota, indefinita o nulla. Questo sta testando una stringa che non è una di queste condizioni. Non ha detto nulla sulle stringhe degli spazi bianchi. È possibile verificare le condizioni di OP con questo, purché si sia sicuri che nella variabile non siano memorizzati altri tipi di dati: if (!str) { ... }
Stephen M Irving

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

Non c'è nulla che rappresenti una stringa vuota in JavaScript. Fai un controllo contro length(se sai che var sarà sempre una stringa) o contro""


29

Non mi preoccuperei troppo del metodo più efficiente . Usa ciò che è più chiaro alla tua intenzione. Per me questo è di solitostrVar == "" .

Secondo il commento di Constantin , se strVar potesse in qualche modo finire con contenere un valore intero 0, questa sarebbe davvero una di quelle situazioni che chiariscono l'intenzione.


11
Cattiva idea. Otterrai la verità se strVar viene assegnato accidentalmente 0.
Constantin

5
Concordo sul fatto che rendere chiara la tua intenzione è più importante di qualsiasi altra microottimizzazione che altri metodi potrebbero produrre, ma usare l' operatore di confronto rigoroso === sarebbe meglio. Restituisce vero solo se strVarè una stringa vuota.
Codice inutile

Il controllo ha esito negativo se non definito. Quindi se (str) funziona meglio
Valentin Heinitz il

3
@ValentinHeinitz se a str fosse assegnato un valore di falso pari a 0 o "0", se (str) riporterebbe falsamente vero. L'approccio migliore è if (str === ""). È semplice e non fallirà mai.
Scott Marcus,


20

Molte risposte e molte possibilità diverse!

Senza dubbio per un'implementazione rapida e semplice il vincitore è: if (!str.length) {...}

Tuttavia, come molti altri esempi sono disponibili. Il miglior metodo funzionale per procedere, suggerirei:

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 po 'eccessivo, lo so.


2
Il controllo per non definito dovrebbe essere spostato per primo nei controlli, altrimenti gli articoli non definiti genereranno eccezioni nei controlli precedenti.
SvdSinner,

Sono completamente d'accordo! BELLA PRESA. Modificherò la mia risposta sopra!
fino al

str.length === 0restituisce vero per qualsiasi funzione che non ha parametri formali.
RobG

20

Potresti anche scegliere espressioni regolari:

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

Controlla le stringhe vuote o piene di spazi bianchi.


Funziona, ma è anche terribilmente costoso dal punto di vista operativo. Buono se vuoi solo controllare una o due cose, non un set di grandi dimensioni.
Orfeo,

20

Prestazione

Eseguo test su macOS v10.13.6 (High Sierra) per 18 soluzioni scelte. Le soluzioni funzionano in modo leggermente diverso (per i dati di input in caso di angolo) che è stato presentato nel frammento di seguito.

conclusioni

  • le soluzioni semplici sulla base di !str, ==, ===e lengthsono veloci per tutti i browser (A, B, C, G, I, J)
  • le soluzioni basate sull'espressione regolare ( test, replace) e charAtsono più lente per tutti i browser (H, L, M, P)
  • le soluzioni contrassegnate come più veloci erano le più veloci solo per una prova - ma in molte corse cambia all'interno del gruppo di soluzioni "veloci"

Inserisci qui la descrizione dell'immagine

Dettagli

Nel frammento di seguito comparo i risultati dei 18 metodi scelti usando diversi parametri di input

  • "" "a" " "- stringa vuota, stringa con lettera e stringa con spazio
  • [] {} f- array, oggetto e funzione
  • 0 1 NaN Infinity - numeri
  • true false - Booleano
  • null undefined

Non tutti i metodi testati supportano tutti i casi di input.

E poi per tutti i metodi che str = ""eseguo test di velocità per i browser Chrome v78.0.0, Safari v13.0.4 e Firefox v71.0.0 - puoi eseguire test sul tuo computer qui

Inserisci qui la descrizione dell'immagine


Questo è davvero fantastico! Adoro vedere tutto questo esposto! Grazie!
WebWanderer,

è uno studio approfondito - grazie
Deian il

19
  1. controlla che var a;esistano
  2. tagliare false spacesil valore in, quindi provareemptiness

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

17

Inoltre, nel caso in cui consideri una stringa riempita di spazi bianchi come "vuota".

Puoi testarlo con questa espressione regolare:

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

14

Di solito uso qualcosa del genere,

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

3
Il più veloce se sai che la variabile è una stringa. Genera un errore se la variabile non è definita.
Adrian Hope-Bailie,

@ AdrianHope-Bailie perché dovresti testare una variabile indefinita?
Abimael Martell

2
@AbimaelMartell Perché no? Hai una variabile che hai dichiarato o che ti è stata passata da un ambito in cui non hai alcun controllo, ad esempio in una risposta da un metodo o una chiamata API. Si può presumere che contenga un valore e utilizzare il controllo sopra riportato, ma se non è definito o è nullo si otterrà un errore. var test = null; if (! test.length) {alert ("adrian is wrong");}
Adrian Hope-Bailie

OP stava chiedendo "come verificare una stringa vuota", una variabile non definita non è una stringa vuota. Ad ogni modo è possibile verificare typeof variable != "undefined"prima di verificare se è vuoto.
Abimael Martell

10

Non ho notato una risposta che tenga conto della possibilità di caratteri null in una stringa. Ad esempio, se abbiamo una stringa di caratteri null:

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

Per testarne la nullità si potrebbe fare qualcosa del genere:

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

Funziona su una stringa nulla e su una stringa vuota ed è accessibile per tutte le stringhe. Inoltre, potrebbe essere espanso per contenere altri caratteri vuoti o bianchi di JavaScript (ad es. Spazio non di rottura, segno di ordine byte, separatore di riga / paragrafo, ecc.).


2
Analisi interessante. Non credo che ciò sarebbe rilevante nel 99,9% dei casi. MA recentemente ho scoperto che MySQL valuta una colonna su "null" se (e solo se) quella colonna contiene il carattere null ("\ 0"). Oracle d'altra parte non valuterebbe "\ 0" come nullo, preferendo trattarlo come una stringa di lunghezza 1 (dove quel carattere è il carattere nullo). Ciò potrebbe causare confusione se non gestito correttamente, poiché molti sviluppatori web funzionano con un database back-end, che potrebbe passare attraverso diversi tipi di valori "null". Dovrebbe essere nella parte posteriore della mente di ogni sviluppatore.
cartbeforehorse,

10

Nel frattempo possiamo avere una funzione che controlla tutti gli "vuoti" come null, undefined, '', '', {}, [] . Quindi ho appena scritto questo.

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

Usa casi e risultati.

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

A partire da ora non esiste un metodo diretto come string.empty per verificare se una stringa è vuota o meno. Ma nel tuo codice puoi usare un controllo wrapper per una stringa vuota come:

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

}

Usando questo puoi anche assicurarti che la stringa non sia indefinita o anche nulla. Ricorda, indefinito, nullo e vuoto sono tre cose diverse.


Avrebbe generato un errore su null o indefinito perché non dovremmo fare direttamente un'operazione su una variabile che è null o indefinita - verifica l'esistenza di str prima di farlo come indicato in altre risposte e nota anche che funzionerebbe su let abc = '' ma non su let abc = '', questi due sono diversi.
whoami,

Considera let rand = ()=>Math.random(), quindi rand && rand.length > 0)restituisce false, ma chiaramente fn non è "vuoto". Vale a dire restituisce false per qualsiasi funzione che non ha parametri di formato.
RobG

@RobG Math.random()restituisce un numero e non una stringa. E questa risposta riguarda le stringhe. ;-)
Harshit Agarwal,

10

Tutte queste risposte sono carine.

Ma non posso essere sicuro che la variabile sia una stringa, non contenga solo spazi (questo è importante per me) e può contenere '0' (stringa).

La mia versione:

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

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

Esempio su jsfiddle .


1
Eh? Se ti aspetti una stringa empty(0)e empty(7)dovresti restituire lo stesso valore.
Bennett McElwee,

Nel mio caso particolare - empty("0")deve restituire false(perché questa è una stringa non vuota), ma empty(0)deve restituire trueperché è vuota :)
Andron

0 non è vuoto! È un numero e i numeri non possono essere pieni o vuoti. Certo, è la tua funzione e quindi deve soddisfare le tue esigenze, ma emptyin questo caso è un nome fuorviante.
Bennett McElwee,

Penso che quel nome emptysia buono. Nei documenti php per la funzione vuota : Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.la differenza tra PHPe questa funzione - quella stringa '0'non verrà identificata come vuota.
Andron,

Come ho già detto, è la tua funzione: chiamala come vuoi. Ma emptyè un nome impreciso e fuorviante. È interessante notare che PHP ha anche una funzione mal denominata empty, ma i suoi errori non hanno nulla a che fare con JavaScript.
Bennett McElwee,

10

Non ho visto una buona risposta qui (almeno non una risposta adatta a me)

Così ho deciso di rispondermi:

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

Devi iniziare a verificare se non è definito. Altrimenti il ​​tuo metodo può esplodere e quindi puoi verificare se è uguale a null o è uguale a una stringa vuota.

Non puoi avere !! o solo if(value)dal momento che se controlli 0ti darà una risposta falsa (0 è falso).

Detto questo, avvolgilo in un metodo come:

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

PS .: Non è necessario controllare typeof , poiché esplode e si lancia anche prima che entri nel metodo


Probabilmente è meglio usare il costrutto booleano (valore) che considera i valori indefiniti e nulli (e anche 0, -0, false, NaN) come falsi. Vedi stackoverflow.com/questions/856324/…
Zhuravlev A.

9

Se uno ha bisogno di rilevare non solo stringhe vuote ma anche vuote, aggiungerò alla risposta di Goral:

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

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


8

Puoi facilmente aggiungerlo all'oggetto String nativo in JavaScript e riutilizzarlo più e più volte ...
Qualcosa di semplice come il codice sottostante può fare il lavoro per te se vuoi controllare ''stringhe vuote:

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

Altrimenti, se desideri controllare sia la ''stringa vuota che lo ' 'spazio, puoi farlo semplicemente aggiungendo trim()qualcosa come il codice seguente:

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

e puoi chiamarlo in questo modo:

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

Quali sono i vantaggi del fare !(!!this.length)piuttosto che solo !this(o !this.trim()per la seconda opzione)? Una stringa di lunghezza zero è già falsa, le parentesi sono ridondanti e negarla tre volte è esattamente la stessa cosa che negarla una volta.
John Montgomery,

8

Prova questo:

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

8

Ho fatto delle ricerche su cosa succede se si passa un valore non stringa e non vuoto / null a una funzione tester. Come molti sanno, (0 == "") è vero in JavaScript, ma poiché 0 è un valore e non è vuoto o nullo, potresti voler testarlo.

Le seguenti due funzioni restituiscono true solo per valori indefiniti, null, vuoti / bianchi e false per tutto il resto, come numeri, valori booleani, oggetti, espressioni, ecc.

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

Esistono esempi più complicati, ma questi sono semplici e danno risultati coerenti. Non è necessario verificare se non definito, poiché è incluso nel controllo (valore == null). Puoi anche imitare il comportamento di C # aggiungendoli a String in questo modo:

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

Non si desidera inserirlo nel prototipo di Stringhe, poiché se l'istanza della classe String è nulla, si verificherà un errore:

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

Ho provato con il seguente array di valori. Puoi metterlo in loop per testare le tue funzioni in caso di dubbio.

// 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; } }]
];

Se semplicemente smetti di usare == e usi ===, allora questo risolve il problema se (s === "").
Scott Marcus,

8

Per verificare se si tratta esattamente di una stringa vuota:

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

Per verificare se si tratta di una stringa vuota O di un equivalente logico per nessun valore (null, non definito, 0, NaN, false, ...):

if(!val)...

7

Non esiste un isEmpty()metodo, devi verificare il tipo e la lunghezza:

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

Il controllo del tipo è necessario per evitare errori di runtime quando testè undefinedo null.


7

Ignorando le stringhe di spazi bianchi, è possibile utilizzarlo per verificare la presenza di null, vuoti e indefiniti:

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

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

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

È conciso e funziona con proprietà indefinite, sebbene non sia il più leggibile.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.