Hoe kan ik controleren op een lege/niet-gedefinieerde/null-tekenreeks in JavaScript?

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

Antwoord 16

Ook als u een met witruimte gevulde tekenreeks als “leeg” beschouwt.

Je kunt het testen met deze reguliere expressie:

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

Antwoord 17

Ik gebruik meestal zoiets als dit,

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

Antwoord 18

Als men niet alleen lege maar ook lege strings moet detecteren, zal ik aan Goral’s antwoord toevoegen:

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

Antwoord 19

Vanaf:

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

Kijkend naar de laatste voorwaarde, als waarde == “”, moet de lengte moet 0 zijn. Laat het daarom vallen:

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

Maar wacht! In JavaScript is een lege tekenreeks onwaar. Laat daarom waarde vallen == “”:

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

En !undefined is waar, dus die controle is niet nodig. Dus we hebben:

return (!value);

En we hebben geen haakjes nodig:

return !value

Antwoord 20

Ik heb geen antwoord opgemerkt dat rekening houdt met de mogelijkheid van null-tekens in een string. Als we bijvoorbeeld een null-tekenreeks hebben:

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

Om de nietigheid te testen, zou je zoiets als dit kunnen doen:

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

Het werkt op een null-tekenreeks en op een lege tekenreeks en is toegankelijk voor alle tekenreeksen. Bovendien kan het worden uitgebreid om andere lege JavaScript-tekens of witruimtetekens te bevatten (d.w.z. vaste spatie, bytevolgordemarkering, lijn-/paragraafscheidingsteken, enz.).

Antwoord 21

Ondertussen kunnen we één functie hebben die controleert op alle ‘leegtes’ zoals null, undefined, ”, ‘ ‘, {}, [].
Dus ik heb dit zojuist geschreven.

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

Gebruik cases en resultaten.

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

Antwoord 22

Vanaf nu is er geen directe methode zoals string.empty om te controleren of een string leeg is of niet. Maar in je code kun je een wrapper check gebruiken voor een lege string zoals:

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

Hiermee kunt u er ook voor zorgen dat de tekenreeks niet ongedefinieerd of ook null is. Onthoud dat ongedefinieerd, null en leeg drie verschillende dingen zijn.

Antwoord 23

Ik heb hier geen goed antwoord gezien (althans geen antwoord dat bij mij past)

Dus besloot ik mezelf te antwoorden:

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

Je moet beginnen met controleren of het niet gedefinieerd is. Anders kan je methode exploderen, en dan kun je controleren of deze gelijk is aan null of gelijk is aan een lege string.

Je kunt niet hebben !! of alleen if(value) want als je 0 aanvinkt, krijg je een fout antwoord (0 is fout).

Dat gezegd hebbende, sluit het af in een methode zoals:

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

PS.: Je hoeft typeof niet aan te vinken, omdat het zou exploderen en weggooien nog voordat het de methode binnengaat

Antwoord 24

Ik gebruik een combinatie en de snelste controles zijn eerst.

function isBlank(pString) {
    if (!pString) {
        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);
}

Antwoord 25

Al deze antwoorden zijn leuk.

Maar ik weet niet zeker of die variabele een tekenreeks is, niet alleen spaties bevat (dit is belangrijk voor mij) en ‘0’ (tekenreeks) kan bevatten.

Mijn versie:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}
empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

Voorbeeld op jsfiddle.

Antwoord 26

Ik heb wat onderzoek gedaan naar wat er gebeurt als je een niet-string en niet-lege/null-waarde doorgeeft aan een testerfunctie. Zoals velen weten, is (0 == “”) waar in JavaScript, maar aangezien 0 een waarde is en niet leeg of null, wil je er misschien op testen.

De volgende twee functies retourneren alleen true voor ongedefinieerde, null-, lege/witruimtewaarden en false voor al het andere, zoals getallen, Boolean, objecten, expressies, enz.

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

Er zijn meer gecompliceerde voorbeelden, maar deze zijn eenvoudig en geven consistente resultaten. Het is niet nodig om te testen op undefined, omdat het is opgenomen in de (value == null) controle. Je kunt ook het gedrag van C# nabootsen door ze als volgt aan String toe te voegen:

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

Je wilt het niet in het Strings-prototype plaatsen, want als de instantie van de String-klasse null is, zal deze een foutmelding geven:

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

Ik heb getest met de volgende waardearray. Je kunt het doorlopen om je functies te testen als je twijfelt.

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

Antwoord 27

Om te controleren of het precies een lege string is:

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

Om te controleren of het een lege string is OF een logisch equivalent voor geen waarde (null, undefined, 0, NaN, false, …):

if(!val)...

Antwoord 28

Witruimte bijsnijden met de null-coalescerende operator:

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

Antwoord 29

in het geval van het eenvoudig controleren van de lege string

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

als u ook null & ongedefinieerd met uw cheque gewoon

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

Antwoord 30

Er is geen isEmpty() methode, je moet het type en de lengte controleren:

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

De typecontrole is nodig om runtime-fouten te voorkomen wanneer test undefined of null is.