Is er een standaardfunctie om te controleren op null-, niet-gedefinieerde of lege variabelen in JavaScript?

Is er een universele JavaScript-functie die controleert of een variabele een waarde heeft en ervoor zorgt dat deze niet undefinedof nullis? Ik heb deze code, maar ik weet niet zeker of deze in alle gevallen dekt:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

Antwoord 1, autoriteit 100%

Je kunt gewoon controleren of de variabeleeen truthywaarde heeft of niet. Dat betekent

if( value ) {
}

wordt geëvalueerd tot trueals valuenietis:

  • null
  • niet gedefinieerd
  • NaN
  • lege tekenreeks (“”)
  • 0
  • vals

De bovenstaande lijst vertegenwoordigt alle mogelijke falsywaarden in ECMA-/Javascript. Vind het in de specificatieop de ToBooleansectie.

Bovendien, als u niet weetof een variabele bestaat (dat betekent dat als deze is verklaard), u dit moet controleren met de typeofexploitant. Bijvoorbeeld

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

Als u er zeker van kunt zijn dat een variabeleop zijn minst is gedeclareerd, moet u direct controleren of deze een truthy-waarde heeft zoals hierboven weergegeven.


Antwoord 2, autoriteit 5%

De uitgebreide methode om te controleren of de waarde ongedefinieerd of null is, is:

return value === undefined || value === null;

U kunt ook de ==-operator gebruiken, maar dit verwacht een op Ken alle regels :

return value == null; // also returns true if value is undefined

3, Autoriteit 2%

function isEmpty(value){
  return (value == null || value.length === 0);
}

Hierdoor wordt geretourneerd voor

undefined  // Because undefined == null
null
[]
""

en nul argumentfuncties sinds een functie lengthis het aantal gedeclareerde parameters dat het nodig heeft.

Om de laatste categorie niet toe te staan, wilt u misschien gewoon controleren op lege strings

function isEmpty(value){
  return (value == null || value === '');
}

4

Dit is de veiligste cheque en ik heb het hier niet precies zoals dat gezien:

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

Het bedekt de gevallen waarin waarde nooit is gedefinieerd, en ook een van deze:

  • null
  • undefined (waarde van undefined is niet hetzelfde als een parameter die nooit is gedefinieerd)
  • 0
  • “” (lege string)
  • false
  • nan

bewerkt: veranderd in strikte gelijkheid (! ==) omdat het nu de norm is;)


5

Misschien vindt u de volgende functie nuttig:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

Of in ES7 (commentaar bij verdere verbeteringen)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);
  return type.toLowerCase();
}

Resultaten:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

“Merk op dat de bind-operator (::) geen deel uitmaakt van ES2016 (ES7) noch enige latere editie van de ECMAScript-standaard. Het is momenteel een voorstel van fase 0 (strawman) om in de taal geïntroduceerd te worden.” – Simon Kjellberg. de auteur wil zijn steun toevoegen aan dit prachtige voorstel om koninklijke hemelvaart te ontvangen.


Antwoord 6

Het eerste antwoord met de beste beoordeling is fout. Als de waarde niet is gedefinieerd, wordt er een uitzondering gegenereerd in moderne browsers. Je moet gebruiken:

if (typeof(value) !== "undefined" && value)

of

if (typeof value  !== "undefined" && value)

Antwoord 7

Een oplossing die ik erg leuk vind:

Laten we definiëren dat een lege variabele nullof undefinedis, of als deze een lengte heeft, nul is, of als het een object is, geen sleutels heeft :

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||
    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||
    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Retouren:

  • true:undefined, null, "", [], {}
  • false:true, false, 1, 0, -1, "foo", [1, 2, 3], { foo: 1 }

Antwoord 8

Deze conditiecontrole

if (!!foo) {
    //foo is defined
}

is alles wat je nodig hebt.


Antwoord 9

!controleer op lege strings (“”), null, undefined, false en het cijfer 0 en NaN.Zeg, als een string leeg is var name = ""en console.log(!name)retourneert true.

function isEmpty(val){
  return !val;
}

deze functie retourneert true als valempty, null, undefined, false, het getal 0 of NaNis.

OF

Volgens uw probleemdomein kunt u gewoon !valof !!valgebruiken.


Antwoord 10

U bent een beetje overdreven. Om te controleren of een variabele geen waarde krijgt, hoeft u alleen maar te controleren op undefined en null.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Hieronder gaat over 0, "", EN OBJECT (Even Lege Object en Array) zijn geldige “waarden”.


11

Hier is de mijne – retourneert true als de waarde null, undefined, etc of blanco (dwz alleen lege spaties bevat):

function stringIsEmpty(value) {
    return value ? value.trim().length == 0 : true;
}

12

Als u de voorkeur geeft aan duidelijke javascript, probeer dit dan:

 /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */
function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

Als je al underscore of lodash gebruikt, probeer dan:

_.isEmpty(value)

Antwoord 13

return val || 'Handle empty variable'

is een heel mooie en schone manier om het op veel plaatsen te behandelen, kan ook worden gebruikt om variabelen toe te wijzen

const res = val || 'default value'

Antwoord 14

Als de variabele niet is gedeclareerd, kunt u niet testen op ongedefinieerd met behulp van een functie, omdat u een foutmelding krijgt.

if (foo) {}
function (bar) {}(foo)

Beide zullen een fout genereren als foo niet is gedeclareerd.

Als u wilt testen of een variabele is gedeclareerd, kunt u gebruik maken van

typeof foo != "undefined"

als je wilt testen of foo is gedeclareerd en het heeft een waarde die je kunt gebruiken

if (typeof foo != "undefined" && foo) {
    //code here
}

Antwoord 15

Leegte

Ik raad niet aan om te proberen een functie te definiëren of te gebruiken die berekent of een waarde in de hele wereld leeg is. Wat betekent het eigenlijk om “leeg” te zijn? Als ik `let human = { name: ‘bob’, maag: ’empty’ }` heb, moet `isEmpty(human)` dan `true` retourneren? Als ik `let reg = new RegExp(”);` heb, moet `isEmpty(reg)` dan `true` retourneren? Hoe zit het met `isEmpty([ null, null, null, null ])` – deze lijst bevat alleen leegte, dus is de lijst zelf leeg? Ik wil hier enkele opmerkingen maken over “leegte” (een opzettelijk obscuur woord, om reeds bestaande associaties te vermijden) in javascript – en ik wil argumenteren dat “leegte” in javascript-waarden nooit generiek moet worden behandeld.


Waarheid/Onwaarheid

Om te beslissen hoe we de “leegte” van waarden kunnen bepalen, moeten we rekening houden met het ingebouwde, inherente gevoel van javascript of waarden “waar” of “vals” zijn. Natuurlijk zijn `null` en `undefined` beide “falsy”. Minder natuurlijk is het getal ‘0’ (en geen ander getal behalve ‘NaN’) ook “vals”. Tenminste natuurlijk: ”” is onwaar, maar `[]` en `{}` (en `new Set()`, en `new Map()`) zijn waarheidsgetrouw – hoewel ze allemaal even leeg lijken!


Null versus ongedefinieerd

Er is ook enige discussie over `null` versus `undefined` – hebben we echt beide nodig om leegte in onze programma’s tot uitdrukking te brengen? Persoonlijk vermijd ik dat de letters u, n, d, e, f, i, n, e, d in die volgorde in mijn code verschijnen. Ik gebruik altijd `null` om “leegte” aan te duiden. Nogmaals, we moeten echter rekening houden met het inherente gevoel van javascript van hoe `null` en `undefined` verschillen:

  • Proberen toegang te krijgen tot een niet-bestaande eigenschap geeft undefined
  • Een parameter weglaten bij het bellen van een functie resulteert in die parameter die undefined:
  • wordt ontvangen

let f = a => a;
console.log(f('hi'));
console.log(f());

16

Om de standaardwaarde

te controleren

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

controleer Resultaat:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

Ik heb de functie @Vix() gebruikt om het object van welk type te controleren.

instansof «

. gebruiken

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';
            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        

Antwoord 17

function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

In ES6 met trim om witruimtetekenreeksen te verwerken:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

Antwoord 18

Het kan handig zijn.

Alle waarden in de array vertegenwoordigen wat je wilt zijn (null, undefined of andere dingen) en je zoekt wat je erin wilt hebben.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

Antwoord 19

Het waarschijnlijk kortste antwoord is

val==null || val==''

als je de rechterzijde verandert in val==='', dan geeft een lege array false. Bewijs


Antwoord 20

Als u TypeScriptgebruikt en geen rekening wilt houden met “waarden die zijn falsedan is dit de oplossing voor jou:

Eerst: import { isNullOrUndefined } from 'util';

Dan: isNullOrUndefined(this.yourVariableName)

Let op: zoals vermeld hieronderdit is nu verouderd, gebruik value === undefined || value === nullin plaats daarvan. ref.


Antwoord 21

Probeer met andere logica. U kunt de onderstaande code gebruiken om alle vier (4) voorwaarden voor validatie te controleren, zoals niet null, niet leeg, niet ongedefinieerd en niet nul. Gebruik alleen deze code (!(!(variabele))) in javascript en jquery.

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test
    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}

Antwoord 22

U kunt de nullish-coalescentie-operator ??gebruiken om te controleren op nullen undefined-waarden. Zie de MDN-documenten

null ?? 'default string'; // returns "default string"
0 ?? 42;  // returns 0
(null || undefined) ?? "foo"; // returns "foo"

Antwoord 23

function isEmpty(val){
    return !val;
}

maar deze oplossing is overontwikkeld, als u de functie later niet wilt wijzigen voor behoeften aan een bedrijfsmodel, is het schoner om deze rechtstreeks in code te gebruiken:

if(!val)...

Antwoord 24

var myNewValue = myObject && myObject.child && myObject.child.myValue;

Dit zal nooit een foutmelding geven. Als myObject, childof myValuenull is, dan is myNewValuenull. Er worden geen fouten gegenereerd


Antwoord 25

Voor iedereen die hier komt met een soortgelijke vraag, het volgende werkt prima en ik heb het de laatste jaren in mijn bibliotheek:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

Antwoord 26

Als je wilt voorkomen dat je waar wordt als de waarde een van de volgende is, volgens jAndy’s antwoord:

  • null
  • niet gedefinieerd
  • NaN
  • lege tekenreeks (“”)
  • 0
  • vals

Een mogelijke oplossing die het verkrijgen van waarheidswaarden zou kunnen vermijden, is de volgende:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

Het zou als volgt worden gebruikt:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

Naast deze scenario’s wilt u misschien ook false retourneren als het objectof arrayleeg is:

  • Object: {} (met behulp van ECMA 7+)
  • Array: [] (met behulp van ECMA 5+)

Je zou het als volgt aanpakken:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}
function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

Als u alle witruimtetekenreeksen (” “) wilt controleren, kunt u het volgende doen:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

Opmerking: hasOwnPropertyretourneert true voor lege strings, 0, false, NaN, null en undefined, als de variabele als een van deze is gedeclareerd, dus het is misschien niet het beste om te gebruiken. De functie kan worden aangepast om het te gebruiken om te laten zien dat het is gedeclareerd, maar is niet bruikbaar.


Antwoord 27

Code op GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)
  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);
// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

Tests van arme mannen 😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };
  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];
  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

testresultaten:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

28

De optionele chain-operator biedt een manier om de toegang tot waarden via verbonden objecten te vereenvoudigen wanneer het mogelijk is dat een referentie of functie niet gedefinieerd of null kan zijn.

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

De nullish coalescing-operator kan worden gebruikt na een optionele keten om een ​​standaardwaarde te bouwen wanneer er geen is gevonden:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

29

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

Het controleert ook witte spaties (”) samen met het volgende:

  • null, undefined, nan, leeg, string (“”), 0, false

Other episodes