Cum pot verifica un șir de caractere gol/undefined/null în JavaScript? (Programare, Javascript, Null, Este Gol)

casademora a intrebat.

Am văzut această întrebare, dar nu am văzut un exemplu specific pentru JavaScript. Există un simplu string.Empty disponibil în JavaScript, sau este vorba doar de a verifica dacă există un ""?

Comentarii

  • Doar pentru informare, cred că cele mai utile API-uri pentru clasa String sunt la Mozilla și kitul javascript. [elated.com](elated.com/articles/working-with-strings ) are un tutorial cu privire la toate proprietățile, metodele,… Vă rugăm să rețineți: link-ul Mozilla a fost actualizat la developer.mozilla.org/en/JavaScript/Reference/Global_Objects/… –  > Por Gene T.
  • Verifică-l pe acesta : stackoverflow.com/a/36491147/7026966 –  > Por Himanshu Shekhar.
  • Ar fi de mare ajutor dacă cerința ar fi clar specificată. Pentru ce valori ar trebui să isEmpty să returneze true? Verificarea pentru „” presupune că ar trebui să returneze adevărat numai dacă valoarea este Șir de caractere de tip și lungime 0. Multe răspunsuri de aici presupun că ar trebui să returneze adevărat și pentru unele sau toate valorile falși. –  > Por RobG.
  • str.length > -1 –  > Por Omar bakhsh.
52 răspunsuri
bdukes

Dacă doriți doar să verificați dacă există o valoare, puteți face

if (strValue) {
    //do something
}

Dacă aveți nevoie să verificați în mod specific pentru un șir gol peste null, aș crede că verificarea față de "" este cea mai bună opțiune, folosind === operatorul (astfel încât să știți că, de fapt, este vorba de un șir de caractere cu care faceți comparația).

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

user5779136

Comentarii

    208

  • Testarea proprietății de lungime poate fi de fapt mai rapidă decât testarea șirului de caractere cu „”, deoarece interpretul nu va trebui să creeze un obiect String din literalul stringului. –  > Por Vincent Robert.
  • 43

  • @Vincent face niște profilări naive în Chrome developer tools, testând === '' vs .length nu a arătat nicio îmbunătățire vizibilă (și folosind .length funcționează doar dacă puteți presupune că aveți un șir de caractere) –  > Por bdukes.
  • 32

  • @bdukes când începi să te intereseze acest tip de micro-optimizări, nu cred că Chrome este browserul în care ai cele mai multe probleme de performanță… –  > Por Vincent Robert.
  • 25

  • Doar pentru a nota, dacă definiția dvs. de „șir gol” include spații albe, atunci această soluție nu este potrivită. Un șir de 1 sau mai multe spații returnează true mai sus. Dacă folosiți JQuery, puteți folosi pur și simplu acest lucru: if ($.trim(ref).length === 0) – conform acestui răspuns la o întrebare similară: stackoverflow.com/questions/2031085/… -.  > Por CodeClimber.
  • 124

  • Așa cum era de așteptat .length > 0 este de fapt mult mai rapid decât compararea cu un șir literal! Verificați acest lucru jsPerf –  > Por Chad.
Jano González

Pentru a verifica dacă un șir de caractere este gol, nul sau nedefinit, folosesc:

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

Pentru a verifica dacă un șir de caractere este gol, nul sau nedefinit, folosesc:

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

Pentru a verifica dacă un șir de caractere este gol sau conține doar spații albe:

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

Comentarii

    36

  • de ce 0 === str.length în loc de str.length === 0 ? –  > Por Vincent.
  • 97

  • @Vincent Condițiile sunt adesea scrise astfel if (variable == constant value) și dacă uitați un ‘=’, atunci atribuiți valoarea constantă variabilei în loc să testați. Codul va funcționa în continuare, deoarece puteți atribui o variabilă într-un if. Deci, un mod mai sigur de a scrie această condiție este să inversați valoarea constantă și variabila. În acest fel, atunci când testați codul, veți vedea o eroare (Invalid lef-hand side in assignment). De asemenea, puteți utiliza ceva de genul JSHint pentru a nu permite atribuirea în condiții și pentru a fi avertizat atunci când scrieți una. –  > Por florian.
  • păcat că /^s*$/.test(str) nu este chiar lizibil – poate că eliminarea spațiilor folosind un cod mai simplu sau regex ar fi mai bine? vezi stackoverflow.com/questions/6623231/… și, de asemenea, stackoverflow.com/questions/10800355/… –  > Por Adrien Be.
  • /^s*$/.test(str) poate fi înlocuit cu str.trim().length === 0 –  > Por Schadenfreude.
  • 34

  • @Vincent acest lucru se mai numește și „Condiții Yoda”, cum ar fi if blue is the sky. A se vedea dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html –  > Por AZ..
karthick.sk

Toate răspunsurile anterioare sunt bune, dar acesta va fi și mai bun. Folosiți operatorii duali NOT (!!):

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

Sau folosiți turnarea tipurilor:

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

Ambele fac aceeași funcție. Tippecast variabila în Boolean, unde str este o variabilă.
Se returnează false pentru null, undefined, 0, 000, "", false.
Se returnează true pentru șirul de caractere "0" și spații albe " ".

Comentarii

    77

  • De ce este acest lucru „chiar mai bun”? –  > Por Mene.
  • 41

  • Există vreo diferență între comportamentul if(str) și if(!!str)? –  > Por Peter Olson.
  • @PeterOlson dacă încercați să salvați o variabilă ca boolean care verifică mai multe șiruri de caractere pentru conținut, atunci ar trebui să faceți acest lucru… aka var any = (!!str1 && !!str2 && !!str3) manipulare în cazul în care există și un număr acolo –  > Por John Ruddell.
  • 29

  • Aceasta este soluția pe care o folosesc întotdeauna. !!str.trim() pentru a vă asigura că șirul nu este alcătuit numai din spații albe. –  > Por Dario Oddenino.
  • Nu nu nu arată ca un hack, Boolean(str) este mult mai ușor de citit și mai puțin „wtfish”. –  > Por shinzou.
Ates Goral

Cel mai apropiat lucru pe care îl puteți obține de str.Empty (cu condiția prealabilă ca str să fie un String) este:

if (!str.length) { ...

Comentarii

    18

  • Asta nu ar arunca o excepție dacă str este nul? –  > Por Pic Mickael.
  • @PicMickael Da! Așa ar fi str.Empty. –  > Por Ates Goral.
Sugendran

Dacă trebuie să vă asigurați că șirul nu este doar o grămadă de spații goale (presupun că este vorba de validarea formularului), trebuie să faceți o înlocuire a spațiilor.

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

Comentarii

  • Dar își face treaba dacă ceea ce doriți de fapt să testați este un șir cu un conținut fără spații. Există o modalitate mai puțin costisitoare de a testa acest lucru? –  > Por flash.
  • Ce ziceți de proprietatea de lungime? –  > Por driAn.
  • 27

  • În loc să eliminați toate spațiile, de ce să nu verificați doar dacă există un non-spațiu? Are două avantaje: poate ieși mai devreme dacă există un caracter care nu este un spațiu și nu trebuie să returneze un nou șir de caractere pe care apoi să îl verificați. if(str.match(/S/g)){} –  > Por mpen.
  • 34

  • @Mark Pentru informarea dvs., nu ați avea nevoie de modificatorul global, deoarece potrivirea primei apariții a unui caracter non-spațiu ar însemna că șirul nu este gol: str.match(/S/) –  > Por neezer.
  • De ce nu ai folosi doar if(str.trim()) {...} ? –  > Por Darryl.
Jet

Eu folosesc:

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

Comentarii

  • Această soluție este mai mult agnostică față de limbă. Singura caracteristică JavaScript pe care se bazează este typeof. Așadar, este un bun exemplu de soluție pe care o puteți utiliza atunci când nu aveți încredere în implementările din diferite browsere și nu aveți timp să găsiți o soluție mai bună. (IE, fără acces la internet). Este ceva de genul unei dovezi. Nu este cea mai curată, dar poți fi sigur că va funcționa fără să știi prea multe despre JavaScript. –  > Por Jeff Davis.
  • Aș merge chiar mai departe și aș bate-o în cuie cu un operator === pentru cazul nedefinit. Altfel, este pur și simplu răspunsul perfect. –  > Por xarlymg89.
  • The typeof din switch nu a funcționat pentru mine. Am adăugat un if (typeof e == "undefined") test și acesta funcționează. De ce?  > Por Lucas.
  • @Lucas Pentru că a fost o greșeală de scriere sau o omisiune. Modificarea ta este abordarea corectă. (originalul se referă la contextul funcției goale, nu la parametrul e, care este ceea ce ar trebui să verifice funcția) – -.  > Por beeThree.
  • Am putea folosi case undefined: în loc de case typeof(e) == "undefined":? –  > Por Boris J..
Moshii

Puteți utiliza lodash:_.isEmpty(value).

Aceasta acoperă o mulțime de cazuri precum {}, '', null, undefined, etc.

Dar întotdeauna returnează true pentru Number tipul de Tipuri de date primitive JavaScript cum ar fi _.isEmpty(10) sau _.isEmpty(Number.MAX_VALUE) ambele returnează true.

Comentarii

  • _.isEmpty(" "); // => false –  > Por Erich.
  • @Erich Pentru că " " nu este gol. _.isEmpty(""); se întoarce adevărat. –  > Por Moshii.
  • destul de adevărat – am menționat acest lucru deoarece câteva dintre celelalte răspunsuri de aici implică validarea formularului și verificarea dacă un șir de caractere este format doar din spații albe, iar această singură funcție lodash nu va rezolva singură această problemă. –  > Por Erich.
Kamil Kiełczewski

Performanță

Efectuez teste pe macOS v10.13.6 (High Sierra) pentru 18 soluții alese. Soluțiile funcționează ușor diferit (pentru datele de intrare din cazul de colț), care a fost prezentat în fragmentul de mai jos.

Concluzii

  • soluțiile simple bazate pe !str,==,=== și length sunt rapide pentru toate browserele (A,B,C,G,I,J)
  • soluțiile bazate pe expresia regulată (test,replace) și charAt sunt cele mai lente pentru toate browserele (H,L,M,P)
  • soluțiile marcate ca fiind cele mai rapide au fost cele mai rapide doar pentru o singură rulare de testare – dar în mai multe rulări se schimbă în interiorul grupului de soluții „rapide

Detalii

În fragmentul de mai jos am comparat rezultatele celor 18 metode alese prin utilizarea unor parametri de intrare diferiți

  • "" "a" " "– șir gol, șir cu litere și șir cu spațiu
  • [] {} f– matrice, obiect și funcție
  • 0 1 NaN Infinity – numere
  • true false – Boolean
  • null undefined

Nu toate metodele testate acceptă toate cazurile de intrare.

Și apoi, pentru toate metodele, am efectuat un test de viteză str = "" pentru browserele Chrome v78.0.0, Safari v13.0.4 și Firefox v71.0.0.0 – puteți efectua testele pe mașina dvs. aici

Comentarii

  • Acest lucru este cu adevărat minunat! Îmi place să văd toate acestea prezentate! Vă mulțumim! –  > Por WebWanderer.
  • Cam înșelător, deoarece combină soluțiile de ajustare cu soluțiile fără ajustare. –  > Por Sean.
T.Todua

Funcție foarte generică „All-In-One” (nu se recomandă totuși):

function is_empty(x)
{
    return (                                                           //don't put newline after return
        (typeof x == 'undefined')
              ||
        (x == null)
              ||
        (x == false)        //same as: !x
              ||
        (x.length == 0)
              ||
        (x == 0)            // note this line, you might not need this. 
              ||
        (x == "")
              ||
        (x.replace(/s/g,"") == "")
              ||
        (!/[^s]/.test(x))
              ||
        (/^s*$/.test(x))
    );
}

Cu toate acestea, nu vă recomand să o folosiți, deoarece variabila țintă ar trebui să fie de un tip specific (de exemplu, șir de caractere, sau numeric, sau obiect?), astfel încât să se aplice verificările care sunt relative la acea variabilă.

Comentarii

  • Ai vreo șansă să explici ce face fiecare verificare? 🙂 –  > Por DanV.
  • -1 Acestea testează lucruri diferite. Nu are sens să le punem pe toate într-unul singur if declarație. –  > Por Bennett McElwee.
  • typeof MyVariable == ‘undefined’ nu face diferența între o variabilă inițializată cu o valoare nedefinită și o variabilă nedeclarată, cu excepția cazului în care variabila a fost inițial declarată și inițializată la null. Verificarea proprietății length face ca primitiva string să fie înfășurată într-un obiect string. –  > Por Scott Marcus.
cllpse
var s; // undefined
var s = ""; // ""
s.length // 0

Nu există nimic care să reprezinte un șir gol în JavaScript. Efectuați o verificare în funcție de length (dacă știți că var-ul va fi întotdeauna un șir de caractere) sau față de ""

Yang Dong

Încercați:

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

Comentarii

  • Este necesară proprietatea length? –  > Por frogcoder.
  • str.trim().length va face mai repede decât str.trim()cu aproximativ 1%, conform rezultatelor testelor mele. –  > Por devildelta.
  • OP caută să testeze pentru șirul gol, nedefinit sau null. Acesta testează un șir care nu corespunde nici uneia dintre aceste condiții. Nu a spus nimic nici despre șiruri de caractere cu spațiu alb. Puteți testa condițiile lui OP doar cu această metodă, atâta timp cât sunteți sigur că în variabilă nu sunt stocate alte tipuri de date: if (!str) { ... } –  > Por Stephen M Irving.
Chris Noe

Nu mi-aș face prea multe griji în legătură cu cele mai eficientă metodă. Folosiți ceea ce este cel mai clar pentru intenția dumneavoastră. Pentru mine, aceasta este de obicei strVar == "".

În ceea ce privește comentariul lui Constantin, dacă strVar ar putea ajunge cumva să conțină o valoare întreagă 0, atunci aceasta ar fi într-adevăr una dintre acele situații care clarifică intenția.

Comentarii

  • O idee proastă. Vei obține true dacă lui strVar i se atribuie din greșeală valoarea 0. -.  > Por Constantin.
  • Sunt de acord că clarificarea intenției este mai importantă decât orice micro-optimizări pe care le-ar putea produce alte metode, dar utilizarea metodei operatorul de comparație strictă === ar fi mai bine. Acesta returnează adevărat doar dacă strVar este un șir gol. –  > Por Cod inutil.
  • Verificarea eșuează dacă este nedefinită. Așadar, if(str) funcționează mai bine –  > Por Valentin Heinitz.
  • @ValentinHeinitz dacă lui str i s-ar atribui o valoare falsă de 0 sau „0”, if(str) ar raporta în mod fals true. Cea mai bună abordare este if(str === „”). Este simplă și nu va da niciodată greș. –  > Por Scott Marcus.
  • Ce operator de egalitate (== vs ===) trebuie utilizat în comparațiile din JavaScript? –  > Por Brent Bradburn.
oem

Ați putea, de asemenea, să folosiți expresii regulate:

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

Verifică șirurile de caractere care sunt fie goale, fie pline de spații albe.

Comentarii

  • Funcționează, dar este, de asemenea, extrem de costisitor din punct de vedere operațional. Este bun dacă doriți să verificați doar unul sau două lucruri, nu un set mare. –  > Por Orpheus.
Timothy Nwanwene
  1. verificați că var a; există
  2. tăiați false spaces din valoare, apoi testați dacă există emptiness

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

tfont

O mulțime de răspunsuri și o mulțime de posibilități diferite!

Fără îndoială, pentru o implementare rapidă și simplă, câștigătorul este: if (!str.length) {...}

Cu toate acestea, sunt disponibile multe alte exemple. Cea mai bună metodă funcțională de a proceda în acest sens, aș sugera:

Un pic excesiv, știu.

Comentarii

  • Verificarea elementelor nedefinite ar trebui să fie mutată la prima în verificări, altfel elementele nedefinite vor arunca excepții la verificările anterioare. –  > Por SvdSinner.
  • Complet de acord! FRUMOASĂ CAPTURĂ. Voi edita răspunsul meu de mai sus! –  > Por tfont.
  • str.length === 0 returnează true pentru orice funcție care nu are parametri formali. –  > Por RobG.
  • str.length === 0 || str === „” ambele ar îndeplini aceeași sarcină. –  > Por Praveen M P.
Wab_Z

De asemenea, în cazul în care considerați un șir plin de spații albe ca fiind „gol”.

Puteți testa acest lucru cu această expresie regulată:

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

user2086641

De obicei, eu folosesc ceva de genul acesta,

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

Comentarii

  • Cel mai rapid dacă știi că variabila este un șir de caractere. Aruncă o eroare dacă variabila este nedefinită. –  > Por Adrian Hope-Bailie.
  • @AdrianHope-Bailie de ce ai testa o variabilă nedefinită? –  > Por Abimael Martell.
  • @AbimaelMartell De ce nu? Aveți o variabilă pe care fie ați declarat-o, fie v-a fost transmisă dintr-un domeniu asupra căruia nu aveți control, cum ar fi un răspuns la o metodă sau un apel API. Poți presupune că aceasta conține o valoare și să folosești verificarea de mai sus, dar dacă nu este definită sau este nulă, vei primi o eroare. var test = null; if(!test.length){alert(„adrian is wrong”);} -.  > Por Adrian Hope-Bailie.
  • OP a întrebat „cum se verifică dacă există un șir de caractere gol”, o variabilă nedefinită nu este un șir de caractere gol. În orice caz, ați putea verifica typeof variable != "undefined" înainte de a verifica dacă este gol. –  > Por Abimael Martell.
Josef.B

Dacă este nevoie să se detecteze nu numai șirurile goale, ci și cele goale, voi adăuga la răspunsul lui Goral:

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

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

Abhishek Luthra

Începând cu:

return (!value || value == undefined || value == "" || value.length == 0);

Dacă ne uităm la ultima condiție, dacă valoarea == „”, lungimea sa trebuie să fie să fie 0. Prin urmare, renunțați la ea:

return (!value || value == undefined || value == "");

Dar așteptați! În JavaScript, un șir gol este fals. Prin urmare, renunțați la valoarea == „”:

return (!value || value == undefined);

Iar !undefined este adevărat, deci această verificare nu este necesară. Deci, avem:

return (!value);

Și nu avem nevoie de paranteze:

return !value

Comentarii

  • Ce se întâmplă dacă value = false sau value = 0. va returna răspunsul corect în funcție de întrebare? –  > Por nerez.
Bikush

Nu am observat un răspuns care să țină cont de posibilitatea existenței caracterelor nule într-un șir de caractere. De exemplu, dacă avem un șir de caractere nule:

var y = ""; // 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

Pentru a testa caracterul său nul, s-ar putea face ceva de genul următor:

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

Funcționează și pe un șir nul, și pe un șir gol și este accesibil pentru toate șirurile. În plus, ar putea fi extins pentru a conține alte caractere JavaScript goale sau de spațiu alb (de exemplu, spațiu fără întrerupere, marca de ordine a octeților, separator de linie/paragraf etc.).

Comentarii

  • O analiză interesantă. Nu cred că acest lucru ar fi relevant în 99,9% din cazuri. DAR am descoperit recent că MySQL evaluează o coloană la „null” dacă (și numai dacă) acea coloană conține caracterul nul („”). Oracle, pe de altă parte, nu ar evalua „” ca fiind nul, preferând să îl trateze ca pe un șir de lungime 1 (unde acel caracter este caracterul nul). Acest lucru ar putea cauza confuzie dacă nu este tratat în mod corespunzător, deoarece mulți dezvoltatori web lucrează cu o bază de date de tip back-end, care ar putea trece prin diferite tipuri de valori „null”. Acest lucru ar trebui să fie în atenția fiecărui dezvoltator. –  > Por cartbeforehorse.
Imran Ahmad

Între timp, putem avea o funcție care să verifice toate „golurile”, cum ar fi null, undefined, ”, ‘ ‘ ‘, {}, [].așa că am scris asta.

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

Cazuri de utilizare și rezultate.

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

Harshit Agarwal

Deocamdată nu există o metodă directă precum string.empty pentru a verifica dacă un șir este gol sau nu. Dar în codul dvs. puteți utiliza o verificare a unui șir gol ca:

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

}

Utilizând această metodă, vă puteți asigura, de asemenea, că șirul nu este nedefinit sau nul. Nu uitați, undefined, null și empty sunt trei lucruri diferite.

Comentarii

  • Se va arunca o eroare la null sau undefined, deoarece nu ar trebui să efectuăm direct o operație pe o variabilă care este null sau undefined – verificați dacă str există înainte de a face acest lucru, așa cum se menționează în alte răspunsuri & rețineți, de asemenea, că acest lucru ar funcționa la let abc = ”, dar nu la let abc = ‘ ‘ ‘, acestea două sunt diferite. –  > Por whoami – fakeFaceTrueSoul.
  • Luați în considerare let rand = ()=>Math.random(), atunci rand && rand.length > 0) returnează fals, dar în mod clar fn nu este „gol”. Adică returnează false pentru orice funcție care nu are parametri de format. –  > Por RobG.
  • @RobG Math.random() returnează un număr și nu un șir de caractere. Iar acest răspuns se referă la șiruri de caractere. 😉 –  > Por Harshit Agarwal.
Davi Daniel Siepmann

Nu am văzut un răspuns bun aici (cel puțin nu un răspuns care să se potrivească pentru mine)

Așa că am decis să răspund eu însumi:

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

Trebuie să începi să verifici dacă este nedefinit. Altfel metoda ta poate exploda, iar apoi poți verifica dacă este egal cu null sau este egal cu un șir gol.

Nu puteți avea !!! sau numai if(value) deoarece dacă verificați 0 îți va da un răspuns fals (0 este fals).

Acestea fiind spuse, înfășurați-o într-o metodă de genul:

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

PS..: Nu este nevoie să verificați typeof, deoarece ar exploda și ar arunca chiar înainte de a intra în metodă

Comentarii

  • Probabil că este mai bine să folosiți construcția Boolean(value) care tratează valorile nedefinite și nule (și, de asemenea, 0, -0, false, NaN) ca fiind false. A se vedea stackoverflow.com/questions/856324/… –  > Por Zhuravlev A..
Andron

Toate aceste răspunsuri sunt frumoase.

Dar nu pot fi sigur că variabila este un șir de caractere, nu conține doar spații (acest lucru este important pentru mine) și poate conține „0” (șir de caractere).

Versiunea mea:

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

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

Exemplu pe jsfiddle.

Comentarii

  • Huh? Dacă vă așteptați la un șir de caractere, empty(0) și empty(7) ar trebui să returneze aceeași valoare. –  > Por Bennett McElwee.
  • În cazul meu particular – empty("0") trebuie să returneze false (pentru că este un șir de caractere care nu este gol), dar empty(0) trebuie să returneze true pentru că este gol 🙂 –  > Por Andron.
  • Dar 0 nu este gol! Este un număr, iar numerele nu pot fi pline sau goale. Bineînțeles, este funcția ta și deci trebuie să îndeplinească cerințele tale, dar empty este un nume înșelător în acest caz. –  > Por Bennett McElwee.
  • Cred că acest nume empty este bun. În documentația php pentru empty funcție: Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE. Diferența dintre PHP și această funcție – acel șir de caractere '0' nu va fi identificat ca fiind gol. –  > Por Andron.
  • După cum am spus, este funcția ta: numește-o cum vrei. Dar empty este o denumire inexactă și înșelătoare. Este interesant faptul că PHP are, de asemenea, o funcție cu un nume prost numit empty dar deficiențele PHP nu au nimic de-a face cu JavaScript. –  > Por Bennett McElwee.
Luca C.

Pentru a verifica dacă este exact un șir gol:

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

Pentru a verifica dacă este un șir de caractere gol SAU un echivalent logic pentru nicio valoare (null, undefined, 0, NaN, false, …):

if(!val)...

V1NNY

Încercați acest lucru:

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

JHM

Am făcut câteva cercetări cu privire la ceea ce se întâmplă dacă treceți o valoare care nu este un șir de caractere și care nu este goală/nulă la o funcție de testare. După cum mulți știu, (0 == „”) este adevărat în JavaScript, dar, deoarece 0 este o valoare și nu este gol sau nul, este posibil să doriți să testați pentru aceasta.

Următoarele două funcții returnează true numai pentru valorile nedefinite, nule, goale/cu spațiu alb și false pentru orice altceva, cum ar fi numere, booleeni, obiecte, expresii etc.

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

Există exemple mai complicate, dar acestea sunt simple și dau rezultate consistente. Nu este necesar să se testeze pentru undefined, deoarece este inclus în verificarea (value == null). Puteți, de asemenea, să imitați C# comportamentul prin adăugarea lor la String astfel:

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

Nu doriți să le puneți în prototipul Strings, deoarece, dacă instanța clasei String este nulă, va da eroare:

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

Am testat cu următoarea matrice de valori. Dacă aveți îndoieli, puteți să-l parcurgeți în buclă pentru a vă testa funcțiile.

// 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', '
'],
    ['carriage return', 'r'],
    ['"\r
"', 'r
'],
    ['"
\r"', '
r'],
    ['" \t 
 "', ' t 
 '],
    ['" txt \t test 
"', ' txt t test 
'],
    ['"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; } }]
];

Comentarii

  • Dacă pur și simplu nu mai folosiți == și folosiți ===, atunci acest lucru rezolvă problema if(s === „”). –  > Por Scott Marcus.
Ibrahim shamma

în cazul verificării șirului gol, pur și simplu

if (str.length){
  //do something
}

dacă doriți, de asemenea, să includeți null & undefined cu verificarea dvs. pur și simplu

if (Boolean(str)){
  //this will be true when the str is not empty nor null nor undefined
}

Agustí Sánchez

Nu există isEmpty() trebuie să verificați tipul și lungimea:

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

Verificarea tipului este necesară pentru a evita erorile de execuție atunci când test este undefined sau null.

Doug

Încercați acest lucru

str.value.length == 0

Comentarii

  • "".value.length va cauza o eroare. Ar trebui să fie str.length === 0 –  > Por AndFisher.
  • Acest lucru a fost TypeError Dacă str este egal cu undefined sau null –  > Por RousseauAlexandre.
Alireza

Puteți să-l adăugați cu ușurință la nativ String în JavaScript și să îl reutilizați la nesfârșit…
Ceva simplu, cum ar fi codul de mai jos, poate face treaba pentru dvs. dacă doriți să verificați '' șirurile goale:

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

În caz contrar, dacă doriți să verificați ambele '' șirul gol și ' ' cu spațiu, puteți face acest lucru adăugând doar trim(), ceva asemănător codului de mai jos:

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

și îl puteți apela în acest fel:

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

Comentarii

  • Care este avantajul de a face !(!!this.length) în loc de doar !this (sau !this.trim() pentru a doua opțiune)? Un șir de lungime zero este deja fals, parantezele sunt redundante, iar negarea de trei ori este exact la fel ca negarea o dată. –  > Por John Montgomery.
  • Vă rugăm să nu poluați prototipurile. –  > Por Sean.
mricci

Ignorând șirurile de spații albe, ați putea folosi acest lucru pentru a verifica dacă există null, empty și undefined:

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

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

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

Este concis și funcționează pentru proprietățile nedefinite, deși nu este cel mai ușor de citit.

Ibraheem
if ((str?.trim()?.length || 0) > 0) {
   // str must not be any of:
   // undefined
   // null
   // ""
   // " " or just whitespace
}

Actualizare:Din moment ce acest răspuns devine popular, m-am gândit să scriu și eu o formă de funcție:

const isNotNilOrWhitespace = input => (input?.trim()?.length || 0) > 0;

const isNilOrWhitespace = input => (input?.trim()?.length || 0) === 0;

Sean

Tăierea spațiilor albe cu operatorul null-coalescing:

if (!str?.trim()) {
  // do something...
}

Comentarii

  • Arată bine, dar str.trim() este suficient. Nu ar trebui niciodată să complicăm prea mult lucrurile, IMO. –  > Por Hexodus.
  • Doar aruncând-o pentru cei care ar putea avea nevoie de ea. ?. nu ar putea fi mai puțin complicat. .trim() ar arunca o eroare dacă str este nulă. –  > Por Sean.
jmc734

De obicei, folosesc ceva de genul:

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

Comentarii

  • == operatorul nu este strict. Deci, dacă str == "", str poate fi null, undefined, false, 0, [], etc. –  > Por RousseauAlexandre.
Will

Eu folosesc o combinație, iar cele mai rapide verificări sunt primele.

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

Comentarii

  • Mă întrebam doar dacă puteți explica când ar fi necesară verificarea lungimii? Nu ar putea !pString să prindă orice ar fi un șir nul/vid? Acest lucru pare să funcționeze. var test=”; if (!test) alert(‘empty’); –  > Por Nicholi.
Kev

Nu presupuneți că variabila pe care o verificați este un șir de caractere. Nu presupuneți că dacă această var are o lungime, atunci este un șir de caractere.

Ideea este: gândiți-vă cu atenție la ceea ce trebuie să facă și ce poate accepta aplicația dumneavoastră. Construiți ceva robust.

Dacă metoda/funcția dvs. trebuie să proceseze doar un șir de caractere care nu este gol, atunci testați dacă argumentul este un șir de caractere care nu este gol și nu faceți vreun „truc”.

Ca exemplu de ceva care va exploda dacă nu urmați cu atenție unele sfaturi de aici.


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'

Așadar, eu aș rămâne cu


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

KARTHIKEYAN.A

Poți să poți valida următoarele moduri și să înțelegi diferența.

japesh singhal

Următoarea expresie regulată este o altă soluție, care poate fi utilizată pentru șirul nul, gol sau nedefinit.

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

Am adăugat această soluție, deoarece poate fi extinsă în continuare pentru a verifica dacă este goală sau o anumită valoare, după cum urmează. Următoarea expresie regulată verifică fie că șirul poate fi gol, nul, nedefinit, fie că are doar numere întregi.

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

Comentarii

  • Un defect major: această expresie regizorală se potrivește cu șirul literal „null”. (/(null|undefined|^$)/).test("null") –  > Por Sean.
Sazid

Ar trebui să verificați întotdeauna și tipul, deoarece JavaScript este un limbaj cu tipare de rață, astfel încât este posibil să nu știți când și cum s-au schimbat datele în mijlocul procesului. Așadar, iată o soluție mai bună:

Thaddeus Albers

The Underscore.js Biblioteca JavaScript, http://underscorejs.org/, oferă o foarte utilă _.isEmpty() foarte utilă pentru verificarea șirurilor de caractere goale și a altor obiecte goale.

Referință: http://underscorejs.org/#isEmpty

isEmpty _.isEmpty(object)
Returnează true dacă un obiect enumerabil nu conține valori (nu există proprietăți proprii enumerabile). Pentru șiruri de caractere și obiecte de tip array _.isEmpty verifică dacă proprietatea length este 0.

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

_.isEmpty({});
=> true

Mubashar

Prefer să folosesc testul not blank în loc de blank

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

Comentarii

  • Introducerea negației în numele funcțiilor este o idee proastă. Codul în sine este în regulă, dar funcția ar trebui să se numească ceva de genul hasValue(). De ce? Ce se întâmplă când vezi un cod ca acesta: „if (!isNotBlank(str))”… Nu este imediat clar care ar trebui să fie intenția. S-ar putea să nu vi se pară relevant pentru acest exemplu simplu, dar adăugarea negației la numele unei funcții este întotdeauna o idee proastă. –  > Por Mike Viens.
  • IsNotBlank este o funcție standard și o funcție foarte populară în StringUtils commons.apache.org/proper/commons-lang/apidocs/org/apache/… –  > Por Mubashar.
  • oferă, de asemenea, funcția IsBlank pentru a evita negațiile duble. Cred că numele funcțiilor ar trebui să reflecte funcționalitatea pe care o realizează și ar fi mai ușor pentru dezvoltatori să înțeleagă atunci când văd funcțiile isBlank și IsNotBlank în aceeași clasă. –  > Por Mubashar.
Muhammad Salman
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' />

Aceasta este, de asemenea, o modalitate generică de a verifica dacă un câmp este gol.

trn450

O mulțime de informații utile aici, dar, în opinia mea, unul dintre cele mai importante elemente nu a fost abordat.

null, undefined, și "" sunt toate falsy.

Atunci când se evaluează un șir de caractere gol, se întâmplă adesea pentru că trebuie să îl înlocuiți cu altceva.

În acest caz, vă puteți aștepta la următorul comportament.

var a = ""
var b = null
var c = undefined

console.log(a || "falsy string provided") // prints ->"falsy string provided"
console.log(b || "falsy string provided") // prints ->"falsy string provided"
console.log(c || "falsy string provided") // prints ->"falsy string provided"

Având în vedere acest lucru, o metodă sau o funcție care poate returna dacă un șir de caractere este sau nu este "", null, sau undefined (un șir invalid) față de un șir valid este la fel de simplă ca aceasta:

const validStr = (str) => str ? true : false

validStr(undefined) // returns false
validStr(null) // returns false
validStr("") // returns false
validStr("My String") // returns true

Sper că vă este de ajutor.

dkinzer

Este o idee bună și să verificați că nu încercați să treceți un termen nedefinit.

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

TestMe();

var str = 'hello';

TestMe();

De obicei, mă întâlnesc cu cazul în care vreau să fac ceva atunci când un atribut de șir de caractere pentru o instanță de obiect nu este gol. Ceea ce este în regulă, doar că acel atribut nu este întotdeauna prezent.

GibboK

O modalitate alternativă, dar cred că răspunsul lui bdukes este cel mai bun.

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

Nagnath Mungade

Verificați toate scenariile de mai jos:

  1. null

  2. nedefinit

  3. 0

  4. „” (șirul gol)

  5. fals

  6. NaN

Anastasios Tsournos

Puteți verifica acest lucru folosind operatorul typeof împreună cu metoda length.

const isEmptyString = (value) => typeof(value) == 'string' && value.length > 0

Mike Hanson

Această funcție a funcționat bine pentru mine, asigurându-se că este atât un șir de caractere, cât și că nu este gol:

isNonBlankString = function(s) { return ((typeof s === 'string' || s instanceof String) && s !== ''); }

Gaurav
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")
}

KanimozhiPalanisamy
<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>

Comentarii

  • Ar fi necesară o explicație. –  > Por Peter Mortensen.
Alban Kaperi

Pentru a verifica dacă este gol:

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

Pentru a verifica dacă nu este gol.

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

Comentarii

  • Greșit. length nu este null. str = ''; str.length == 0 not str.length == null. Dar, în general, abordarea dvs. este în regulă. –  > Por Verde.
  • Verificarea proprietății length va face ca primitiva string să fie înfășurată într-un obiect string, iar verificarea pentru null nu este nici ea corectă, deoarece nu caută undefined (care nu este același lucru). Pentru a verifica dacă există un șir de caractere gol, verificați pur și simplu dacă este vorba de „” (de exemplu, if(myString === „”)).  > Por Scott Marcus.