We gebruiken vaak het volgende codepatroon in onze JavaScript-code
if (typeof(some_variable) != 'undefined' && some_variable != null)
{
// Do something with some_variable
}
Is er een minder uitgebreide manier van controleren die hetzelfde effect heeft?
Volgens sommige forums en literatuur zou het volgende hetzelfde effect moeten hebben.
if (some_variable)
{
// Do something with some_variable
}
Helaas evalueert Firebugeen dergelijke instructie als een fout tijdens runtime wanneer some_variableis niet gedefinieerd, terwijl de eerste er prima voor is. Is dit alleen een (ongewenst) gedrag van Firebug of is er echt een verschil tussen die twee manieren?
Antwoord 1, autoriteit 100%
Ik denk dat de meest efficiënte manier om te testen op “waarde is nullof undefined” is
if ( some_variable == null ){
// some_variable is either null or undefined
}
Dus deze twee regels zijn equivalent:
if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}
Opmerking 1
Zoals vermeld in de vraag, vereist de korte variant dat some_variableis gedeclareerd, anders wordt er een ReferenceError gegenereerd. In veel gevallen kunt u er echter vanuit gaan dat dit veilig is:
controleer op optionele argumenten:
function(foo){
if( foo == null ) {...}
controleer op eigenschappen van een bestaand object
if(my_obj.foo == null) {...}
Aan de andere kant kan typeofomgaan met niet-gedeclareerde globale variabelen (retourneert eenvoudig undefined). Toch moeten deze gevallen om goede redenen tot een minimum worden beperkt, zoals Alsciende uitlegde.
Opmerking 2
Deze – zelfs kortere – variant is nietequivalent:
if ( !some_variable ) {
// some_variable is either null, undefined, 0, NaN, false, or an empty string
}
dus
if ( some_variable ) {
// we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}
Opmerking 3
Over het algemeen wordt aanbevolen om ===te gebruiken in plaats van ==.
De voorgestelde oplossing vormt een uitzondering op deze regel. De JSHint syntax checkerbiedt om deze reden zelfs de optie eqnull.
Uit de jQuery-stijlgids:
Strenge gelijkheidscontroles (===) moeten worden gebruikt in het voordeel van ==. De enige
uitzondering is bij het controleren op undefined en null door middel van null.
// Check for both undefined and null values, for some important reason.
undefOrNull == null;
BEWERK 2021-03:
Tegenwoordig de meeste browsers
ondersteuning van de Nullish coalescing-operator (??)
en de Logische nullish-toewijzing (??=), wat een beknoptere manier mogelijk maakt om
wijs een standaardwaarde toe als een variabele null of ongedefinieerd is, bijvoorbeeld:
if (a.speed == null) {
// Set default if null or undefined
a.speed = 42;
}
kan als elk van deze vormen worden geschreven
a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;
Antwoord 2, autoriteit 69%
U moet onderscheid maken tussen gevallen:
- Variabelen kunnen
undefinedof ondeclaredzijn. U krijgt een foutmelding als u een niet-gedeclareerde variabele opent in een andere context dantypeof.
if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error
Een variabele die is gedeclareerd maar niet is geïnitialiseerd, is undefined.
let foo;
if (foo) //evaluates to false because foo === undefined
-
Ongedefinieerde eigenschappen, zoals
someExistingObj.someUndefProperty. Een niet-gedefinieerde eigenschap levert geen fout op en retourneert eenvoudigundefined, die, wanneer geconverteerd naar een boolean, evalueert totfalse. Dus, als je er niet om geeft
0enfalse, het gebruik vanif(obj.undefProp)is oké. Er is een gemeenschappelijk idioom gebaseerd op dit feit:value = obj.prop || defaultValuewat betekent “als
objde eigenschappropheeft, wijs deze dan toe aanvalue, anders wijs de standaardwaardedefautValue“.Sommige mensen vinden dit gedrag verwarrend, met het argument dat het leidt tot moeilijk te vinden fouten en raden aan om de
inoperator in plaats daarvanvalue = ('prop' in obj) ? obj.prop : defaultValue
Antwoord 3, autoriteit 15%
Het controleren van null met normale gelijkheid levert ook true op voor undefined.
if (window.variable == null) alert('variable is null or undefined');
Antwoord 4, autoriteit 6%
dit is het enige geval waarin ==en !=moeten worden gebruikt:
if (val == null) console.log('val is null or undefined')
if (val != null) console.log('val is neither null nor undefined')
Voor alle andere vergelijkingen moeten de strikte vergelijkers (===en !==) worden gebruikt.
https://developer.mozilla.org/en-US/ docs/Web/JavaScript/Equality_comparisons_and_samenness
Antwoord 5, autoriteit 6%
In nieuwere JavaScript-standaarden zoals ES5 en ES6 kun je gewoon zeggen
> Boolean(0) //false
> Boolean(null) //false
> Boolean(undefined) //false
alle retourneren false, wat vergelijkbaar is met Python’s controle van lege variabelen.
Dus als je voorwaardelijke logica rond een variabele wilt schrijven, zeg je gewoon
if (Boolean(myvar)){
// Do something
}
hier wordt “null” of “lege string” of “undefined” efficiënt behandeld.
Antwoord 6, autoriteit 4%
Als u probeert te verwijzen naar een niet-gedeclareerde variabele, wordt er een fout gegenereerd in alle JavaScript-implementaties.
Eigenschappen van objecten zijn niet onderhevig aan dezelfde voorwaarden. Als een objecteigenschap niet is gedefinieerd, wordt er geen fout gegenereerd als u deze probeert te openen. Dus in deze situatie zou je het volgende kunnen inkorten:
if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)
naar
if (myObj.some_property != null)
Met dit in gedachten, en het feit dat globale variabelen toegankelijk zijn als eigenschappen van het globale object (windowin het geval van een browser), kun je het volgende gebruiken voor globale variabelen:
p>
if (window.some_variable != null) {
// Do something with some_variable
}
In lokale scopes is het altijd handig om ervoor te zorgen dat variabelen bovenaan uw codeblok worden gedeclareerd, dit bespaart herhaald gebruik van typeof.
Antwoord 7, autoriteit 3%
Ten eerste moet je heel duidelijk zijn over wat je test. JavaScript heeft allerlei impliciete conversies om je te laten struikelen, en twee verschillende soorten gelijkheidsvergelijkers: ==en ===.
Een functie, test(val)die voor nullof undefinedtest, moet de volgende kenmerken hebben:
test(null) => true
test(undefined) => true
test(0) => false
test(1) => false
test(true) => false
test(false) => false
test('s') => false
test([]) => false
Laten we eens kijken welke van de ideeën hier onze test daadwerkelijk doorstaan.
Deze werken:
val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null
Deze werken niet:
typeof(val) === 'undefined'
!!val
Ik heb een jsperf-item gemaakt om de juistheid en prestatiesvan deze benaderingen te vergelijken. De resultaten zijn voorlopig niet overtuigend omdat er niet genoeg runs zijn geweest op verschillende browsers/platforms. Neem even de tijd om de test op uw computer uit te voeren!
Op dit moment lijkt het erop dat de eenvoudige val == null-test de beste prestaties geeft. Het is ook zo’n beetje de kortste. De test kan worden ontkend tot val != nullals je de aanvulling wilt.
Antwoord 8, autoriteit 2%
hier is een andere manier om de Array includes( )methode:
[undefined, null].includes(value)
Antwoord 9
Aangezien er niet één volledig en correct antwoord is, zal ik proberen het samen te vatten:
Over het algemeen is de uitdrukking:
if (typeof(variable) != "undefined" && variable != null)
kan niet worden vereenvoudigd, omdat de variablemogelijk niet gedeclareerd is, dus het weglaten van het typeof(variable) != "undefined"zou resulteren in ReferenceError. Maar u kunt de uitdrukking vereenvoudigen volgens de context:
Als de variablealgemeenis, kun je vereenvoudigen tot:
if (window.variable != null)
Als het lokaalis, kunt u waarschijnlijk situaties vermijden waarin deze variabele niet gedeclareerd is, en ook vereenvoudigen tot:
if (variable != null)
Als het objecteigenschapis, hoeft u zich geen zorgen te maken over ReferenceError:
if (obj.property != null)
Antwoord 10
Dit is een voorbeeld van een zeer zeldzame gelegenheid waarbij het wordt aanbevolen om ==te gebruiken in plaats van ===. Expressie somevar == nullretourneert true voor undefineden null, maar false voor al het andere (een fout als variabele niet gedeclareerd is).
Als u de !=gebruikt, wordt het resultaat omgedraaid, zoals verwacht.
Moderne editors zullen niet waarschuwen voor het gebruik van de operator ==of !=met null, aangezien dit bijna altijd het gewenste gedrag is.
Meest voorkomende vergelijkingen:
undeffinedVar == null // true
obj.undefinedProp == null // true
null == null // true
0 == null // false
'0' == null // false
'' == null // false
Probeer het zelf:
let undefinedVar;
console.table([
{ test : undefinedVar, result: undefinedVar == null },
{ test : {}.undefinedProp, result: {}.undefinedProp == null },
{ test : null, result: null == null },
{ test : false, result: false == null },
{ test : 0, result: 0 == null },
{ test : '', result: '' == null },
{ test : '0', result: '0' == null },
]);
Antwoord 11
Je kunt gewoon controleren of de variabele een waarde heeft of niet. Betekenis,
if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false
}
Als u niet weet of een variabele bestaat (dat wil zeggen, of deze is gedeclareerd), moet u dit controleren met de typeof-operator. bijv.
if( typeof myVariable !== 'undefined' ) {
// myVariable will get resolved and it is defined
}
Antwoord 12
wat yyyook ongedefinieerd of null is, het zal true retourneren
if (typeof yyy == 'undefined' || !yyy) {
console.log('yes');
} else {
console.log('no');
}
ja
if (!(typeof yyy == 'undefined' || !yyy)) {
console.log('yes');
} else {
console.log('no');
}
nee
Antwoord 13
Open de Ontwikkelaarstoolsin uw browser en probeer de code die in de onderstaande afbeelding wordt getoond.
Antwoord 14
Vergelijkbaar met wat je hebt, zou je zoiets kunnen doen
if (some_variable === undefined || some_variable === null) {
do stuff
}
Antwoord 15
Als het doel van de if-instructie is om te controleren op null– of undefined-waarden voordat u een waarde aan een variabele toewijst, kunt u gebruik maken van de Nullish Coalescing-operator. Volgens de gegevens van caniusezou het door ongeveer 85% van de browsers moeten worden ondersteund( vanaf januari 2021). Een voorbeeld van de operator wordt hieronder getoond:
const a = some_variable ?? '';
Dit zorgt ervoor dat de variabele wordt toegewezen aan een lege tekenreeks (of een andere standaardwaarde) als some_variablenullof undefinedis .
Deze operator is het meest geschikt voor uw gebruik, omdat het niet de standaardwaarde retourneert voor andere typen valse waarden, zoals 0en ''.
p>
Antwoord 16
Zoals vermeld in een van de antwoorden, kun je geluk hebben als je het hebt over een variabele met een globaal bereik. Zoals u wellicht weet, worden de variabelen die u globaal definieert, meestal toegevoegd aan het Windows-object. Je kunt profiteren van dit feit, dus laten we zeggen dat je toegang hebt tot een variabele genaamd bleh, gebruik gewoon de dubbele omgekeerde operator (!!)
!!window['bleh'];
Dit zou een false retourneren terwijl bleh niet is gedeclareerd EN een waarde heeft toegewezen.
Antwoord 17
Laten we, om dit te begrijpen, analyseren wat de waarde zal zijn die wordt geretourneerd door de Javascript-engine bij het converteren van undefined , null en ” (ook een lege tekenreeks). U kunt hetzelfde rechtstreeks controleren op uw ontwikkelaarsconsole.
Je kunt zien dat ze allemaal worden geconverteerd naar false , wat betekent dat deze drie allemaal ‘gebrek aan bestaan’ aannemen door javascript. U hoeft dus niet alle drie in uw code expliciet aan te vinken, zoals hieronder.
if (a === undefined || a === null || a==='') {
console.log("Nothing");
} else {
console.log("Something");
}
Ik wil ook nog op één ding wijzen.
Wat zal het resultaat zijn van Boolean(0)?
Natuurlijk niet waar. Dit zal een bug in uw code veroorzaken wanneer 0 een geldige waarde is in uw verwachte resultaat. Zorg er dus voor dat u dit controleert wanneer u de code schrijft.
Antwoord 18
Ik heb dit met deze methode gedaan
bewaar de id in een variabele
var someVariable = document.getElementById("someId");
gebruik dan als voorwaarde
if(someVariable === ""){
//logic
} else if(someVariable !== ""){
//logic
}
Antwoord 19
Dit is ook een leuke (maar uitgebreide) manier om het te doen:
if(someObject.someMember ?? null === null) {
// bladiebla
}
Het is heel duidelijk wat er gebeurt en moeilijk verkeerd te begrijpen. En dat kan HEEL belangrijk zijn! 🙂
Dit gebruikt de operator ??(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator). Als de waarde van someObject.someMembernullof undefinedis, treedt de operator ??in werking en maakt de waarde null.
TBH, ik hou van de explicietheid van dit ding, maar ik geef meestal de voorkeur aan someObject.someMember == null, het is beter leesbaar en ervaren JS-ontwikkelaars weten waarschijnlijk wat hier aan de hand is.
Antwoord 20
Het testen van nietigheid (if (value == null)) of niet-nulliteit (if (value != null)) is minder uitgebreid dan het testen van de definitiestatus van een variabele.
Bovendien mislukt het testen van if (value)(of if( obj.property)) om te verzekeren dat uw variabele (of objecteigenschap) bestaat als deze is gedefinieerd met een booleaanse falsewaarde. Waarschuwing emptor 🙂
21
Met RAMDA kunt u eenvoudig doen R.isNil(yourValue)
Lodash en andere helperbibliotheken hebben dezelfde functie.