Is er een universele JavaScript-functie die controleert of een variabele een waarde heeft en ervoor zorgt dat deze niet undefined
of null
is? 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 truthy
waarde heeft of niet. Dat betekent
if( value ) {
}
wordt geëvalueerd tot true
als value
nietis:
- null
- niet gedefinieerd
- NaN
- lege tekenreeks (“”)
- 0
- vals
De bovenstaande lijst vertegenwoordigt alle mogelijke falsy
waarden in ECMA-/Javascript. Vind het in de specificatieop de ToBoolean
sectie.
Bovendien, als u niet weetof een variabele bestaat (dat betekent dat als deze is verklaard), u dit moet controleren met de typeof
exploitant. 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 length
is 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 null
of undefined
is, 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 !val
of !!val
gebruiken.
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 TypeScript
gebruikt en geen rekening wilt houden met “waarden die zijn false
“dan 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 === null
in 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 null
en 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:
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: hasOwnProperty
retourneert 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
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