Wat is het verschil tussen null en undefined in JavaScript?

Ik wil weten wat het verschil is tussen nullen undefinedin JavaScript.

Antwoord 1, autoriteit 100%

In JavaScript betekent undefineddat een variabele is gedeclareerd maar nog geen waarde heeft gekregen, zoals:

var testVar;
alert(testVar); //shows undefined
alert(typeof testVar); //shows undefined

nullis een toewijzingswaarde. Het kan worden toegewezen aan een variabele als een representatie van geen waarde:

var testVar = null;
alert(testVar); //shows null
alert(typeof testVar); //shows object

Uit de voorgaande voorbeelden is het duidelijk dat undefineden nulltwee verschillende typen zijn: undefinedis zelf een type (undefined), terwijl nullis een object.

null === undefined // false
null == undefined // true
null === null // true

en

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Antwoord 2, autoriteit 23%

(tekens toegevoegd wegens gebrek aan tekens, dus ik mag dit plaatsen.)

Antwoord 3, autoriteit 7%

Ik heb dit hier

De ongedefinieerde waarde is een primitieve waarde die wordt gebruikt wanneer een variabele dat niet heeft
een waarde toegewezen gekregen.

De null-waarde is een primitieve waarde die de null, lege,
of niet-bestaande referentie.

Als je een variabele declareert via var en er geen waarde aan geeft, zal deze de waarde undefined hebben. Op zichzelf, als je probeert om WScript.Echo() of alert() deze waarde te geven, zul je niets zien. Als u er echter een lege string aan toevoegt, verschijnt deze plotseling:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

U kunt een variabele declareren, deze op null instellen en het gedrag is identiek, behalve dat u “null” afgedrukt ziet versus “undefined”. Dit is inderdaad een klein verschil.

Je kunt zelfs een variabele die ongedefinieerd is, vergelijken met null of vice versa, en de voorwaarde zal waar zijn:

undefined == null
null == undefined

Ze worden echter als twee verschillende typen beschouwd. Hoewel undefined een type op zichzelf is, wordt null beschouwd als een speciale objectwaarde. Je kunt dit zien door typeof() te gebruiken die een tekenreeks retourneert die het algemene type van een variabele vertegenwoordigt:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

Het uitvoeren van het bovenstaande script resulteert in de volgende uitvoer:

undefined
object

Ongeacht dat ze van verschillende typen zijn, zullen ze nog steeds hetzelfde doen als je probeert toegang te krijgen tot een lid van een van beide, bijv. dat wil zeggen dat ze een uitzondering zullen gooien. Met WSH zie je de gevreesde “‘varname’ is null or not an object” en dat is als je geluk hebt (maar dat is een onderwerp voor een ander artikel).

Je kunt expliciet instellen dat een variabele ongedefinieerd is, maar ik raad dit ten zeerste af. Ik raad aan om variabelen alleen op null in te stellen en de waarde ongedefinieerd te laten voor dingen die je bent vergeten in te stellen. Tegelijkertijd moedig ik je echt aan om altijd elke variabele in te stellen. JavaScript heeft een andere scope-keten dan die van talen in C-stijl, waardoor zelfs ervaren programmeurs gemakkelijk in verwarring kunnen worden gebracht, en variabelen instellen op null is de beste manier om bugs die erop zijn gebaseerd te voorkomen.

Een ander geval waarin u een ongedefinieerd pop-upvenster ziet, is wanneer u de delete-operator gebruikt. Degenen onder ons uit een C-wereld zouden dit ten onrechte kunnen interpreteren als het vernietigen van een object, maar dat is niet zo. Wat deze bewerking doet, is een subscript uit een array of een lid uit een object verwijderen. Voor arrays heeft het geen invloed op de lengte, maar eerder dat subscript nu als niet gedefinieerd wordt beschouwd.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Het resultaat van het bovenstaande script is:

0.) a
1.) undefined
2.) c

Je krijgt ook ongedefinieerd terug als je een subscript of lid leest dat nooit heeft bestaan.

Het verschil tussen null en undefined is: JavaScript zal nooit iets op null zetten, dat is meestal wat we doen. Hoewel we variabelen op ongedefinieerd kunnen instellen, geven we de voorkeur aan null omdat dit niet iets is dat ooit voor ons wordt gedaan. Wanneer u debugt, betekent dit dat alles dat op null is ingesteld, door u zelf is gedaan en niet door JavaScript. Verder zijn deze twee speciale waarden bijna gelijk.

Antwoord 4, autoriteit 3%

nullis een speciaal zoekwoord dat aangeeft dat er geen waarde is.

beschouw het als een waarde, zoals:

• “foo” is een tekenreeks,
• waar is boolean ,
• 1234 is nummer,
• null is niet gedefinieerd.

undefinedeigenschap geeft aan dat aan een variabele geen waarde is toegewezen inclusief null.
Vind ik leuk

var foo;

gedefinieerde lege variabele is nullvan gegevenstype undefined

Beiden vertegenwoordigen een waarde van een variabele zonder waarde

EN
nullvertegenwoordigt geen tekenreeksdie geen waarde heeft – lege tekenreeks-

Vind ik leuk

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Nu als

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

MAAR

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

DUSelk heeft zijn eigen manier om te gebruiken

undefinedgebruik het om het variabele gegevenstype te vergelijken

nullgebruik het om een ​​waarde van een variabele leeg te maken

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

Antwoord 5, autoriteit 3%

Lees het volgende aandachtig door. Het zou al uw twijfels over het verschil tussen nullen undefinedin JavaScript moeten wegnemen. Je kunt ook de utility-functie aan het einde van dit antwoord gebruiken om meer specifieke soorten variabelen te krijgen.

In JavaScript kunnen we de volgende soorten variabelen hebben:

1. Niet-gedeclareerde variabelen
2. Verklaarde maar niet-toegewezen variabelen
3. Variabelen toegewezen met letterlijke undefined
4. Variabelen toegewezen met letterlijke null
5. Variabelen die zijn toegewezen met iets anders dan undefinedof null

Het volgende legt elk van deze gevallen één voor één uit:

1. Niet-gedeclareerde variabelen

   • Kan alleen worden gecontroleerd met de operator typeofdie de tekenreeks ‘undefined’

   retourneert

   • Kan niet worden gecontroleerd met de losse gelijkheidsoperator ( == undefined), laat staan ​​de strikte gelijkheidsoperator ( === undefined),
     evenals if-statementsen ternaire operatoren( ? :) deze veroorzaken referentiefouten

2. Verklaarde maar niet-toegewezen variabelen

   • typeofretourneert string ‘undefined’
   • ==controleren met nullretourneert true
   • ==controleren met undefinedretourneert true
   • ===controleren met nullretourneert false
   • ===controleren met undefinedretourneert true
   • Is falsyvoor if-statementsen ternaire operatoren( ? :)

3. Variabelen toegewezen met letterlijke undefined
   Deze variabelen worden precies hetzelfde behandeld als Verklaarde maar niet-toegewezen variabelen.

4. Variabelen toegewezen met letterlijke null

   • typeofretourneert string ‘object’
   • ==controleren met nullretourneert true
   • ==controleren met undefinedretourneert true
   • ===controleren met nullretourneert true
   • ===controleren met undefinedretourneert false
   • Is falsyvoor if-statementsen ternaire operatoren( ? :)

5. Variabelen die zijn toegewezen aan iets anders dan undefinedof null

   • typeof retourneert een van de volgende tekenreeksen: ‘bigint’, ‘boolean’, ‘function’, ‘number’ , ‘object’, ‘string’, ‘symbool’

Het volgende biedt het algoritme voor het correct controleren van het type van een variabele:

1. Verkrijg het typeofonze variabele en retourneer het als het niet ‘object’

is

2. Controleer op null, want typeof nullretourneert ook ‘object’
3. Evalueer Object.prototype.toString.call(o)met een switch-instructie om een ​​preciezere waarde te retourneren. De toString-methode van toStringretourneert tekenreeksen die eruitzien als ‘[object ConstructorName]’voor native/host-objecten. Voor alle andere objecten (door de gebruiker gedefinieerde objecten), retourneert het altijd ‘[object Object]’
4. Als dat laatste het geval is (de stringified versie van de variabele is ‘[object Object]’) en de parameter returnConstructorBooleanis true, zal het proberen de naam van de constructor te krijgen door het toString-ing te geven en de naam daaruit te extraheren. Als de constructor niet kan worden bereikt, wordt zoals gewoonlijk ‘object’geretourneerd. Als de tekenreeks zijn naam niet bevat, wordt ‘anonymous’geretourneerd

(ondersteunt alle typen tot ECMAScript 2020)

function TypeOf(o, returnConstructorBoolean) {
  const type = typeof o
  if (type !== 'object') return type
  if (o === null)        return 'null'
  const toString = Object.prototype.toString.call(o)
  switch (toString) {
    // Value types: 6
    case '[object BigInt]':            return 'bigint'
    case '[object Boolean]':           return 'boolean'
    case '[object Date]':              return 'date'
    case '[object Number]':            return 'number'
    case '[object String]':            return 'string'
    case '[object Symbol]':            return 'symbol'
    // Error types: 7
    case '[object Error]':             return 'error'
    case '[object EvalError]':         return 'evalerror'
    case '[object RangeError]':        return 'rangeerror'
    case '[object ReferenceError]':    return 'referenceerror'
    case '[object SyntaxError]':       return 'syntaxerror'
    case '[object TypeError]':         return 'typeerror'
    case '[object URIError]':          return 'urierror'
    // Indexed Collection and Helper types: 13
    case '[object Array]':             return 'array'
    case '[object Int8Array]':         return 'int8array'
    case '[object Uint8Array]':        return 'uint8array'
    case '[object Uint8ClampedArray]': return 'uint8clampedarray'
    case '[object Int16Array]':        return 'int16array'
    case '[object Uint16Array]':       return 'uint16array'
    case '[object Int32Array]':        return 'int32array'
    case '[object Uint32Array]':       return 'uint32array'
    case '[object Float32Array]':      return 'float32array'
    case '[object Float64Array]':      return 'float64array'
    case '[object ArrayBuffer]':       return 'arraybuffer'
    case '[object SharedArrayBuffer]': return 'sharedarraybuffer'
    case '[object DataView]':          return 'dataview'
    // Keyed Collection types: 2
    case '[object Map]':               return 'map'
    case '[object WeakMap]':           return 'weakmap'
    // Set types: 2
    case '[object Set]':               return 'set'
    case '[object WeakSet]':           return 'weakset'
    // Operation types: 3
    case '[object RegExp]':            return 'regexp'
    case '[object Proxy]':             return 'proxy'
    case '[object Promise]':           return 'promise'
    // Plain objects
    case '[object Object]':
      if (!returnConstructorBoolean)
        return type
      const _prototype = Object.getPrototypeOf(o)
      if (!_prototype)              
        return type
      const _constructor = _prototype.constructor
      if (!_constructor)            
        return type
      const matches = Function.prototype.toString.call(_constructor).match(/^function\s*([^\s(]+)/)
        return matches ? matches[1] : 'anonymous'
    default: return toString.split(' ')[1].slice(0, -1)
  }
}

Antwoord 6, autoriteit 2%

null: afwezigheid van waarde voor een variabele; undefined: afwezigheid van variabele zelf;

..waarbij variabele een symbolische naam is die aan een waarde is gekoppeld.

JS zou zo vriendelijk kunnen zijn om nieuw gedeclareerde variabelen impliciet te initiëren met null, maar doet dat niet.

Antwoord 7

U kunt undefined beschouwen als een onverwachte of foutachtige afwezigheid van waarde op systeemniveau en null als een normale of verwachte afwezigheid van waarde op programmaniveau.

via JavaScript: de definitieve gids

Antwoord 8

Ik zal undefined, nullen Uncaught ReferenceErroruitleggen:

1 – Uncaught ReferenceError: variabele is niet gedeclareerdin uw script, er is geen verwijzing naar deze variabele
2 – undefined: variabele gedeclareerd maar niet geïnitialiseerd
3 – null: Variabele gedeclareerd en is een lege waarde

Antwoord 9

nullen undefinedzijn twee verschillende objecttypen die het volgende gemeen hebben:

• beide kunnen slechts één waarde bevatten, respectievelijk nullen undefined;
• beide hebben geen eigenschappen of methoden en een poging om eigenschappen van een van beide te lezen zal resulteren in een runtime-fout (voor alle andere objecten krijgt u de waarde undefinedals u een niet -bestaande eigenschap);
• waarden nullen undefinedworden door ==en !=operators.

De overeenkomsten eindigen hier echter. Voor een keer is er een fundamenteel verschil in de manier waarop de zoekwoorden nullen undefinedworden geïmplementeerd. Dit is niet voor de hand liggend, maar beschouw het volgende voorbeeld:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

undefined, NaNen Infinityzijn slechts namen van vooraf geïnitialiseerde “superglobale” variabelen – ze worden tijdens runtime geïnitialiseerd en kunnen worden overschreven door normale globale of lokale variabele met dezelfde namen.

Laten we nu hetzelfde proberen met null:

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Oeps! null, trueen falsezijn gereserveerde zoekwoorden – de compiler laat je ze niet gebruiken als variabele of eigenschapsnamen

Een ander verschil is dat undefinedeen primitief type is, terwijl nulleen objecttype is (wat aangeeft dat er geen objectreferentie is). Overweeg het volgende:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Er is ook een belangrijk verschil in de manier waarop nullen undefinedworden behandeld in een numerieke context:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1
var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1
WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)
WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)
WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)
WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

nullwordt 0wanneer gebruikt in rekenkundige uitdrukkingen of numerieke vergelijkingen – vergelijkbaar met false, het is eigenlijk gewoon een speciaal soort “nul “. undefineddaarentegen is een echt “niets” en wordt NaN(“geen getal”) wanneer je het in een numerieke context probeert te gebruiken.

Houd er rekening mee dat nullen undefinedeen speciale behandeling krijgen van de operators ==en !=, maar u kan echte numerieke gelijkheid van aen btesten met de uitdrukking (a >= b && a <= b).

Antwoord 10

nullis een speciale waarde die ‘geen waarde’ betekent. nullis een speciaal object omdat typeof null‘object’ retourneert.

Aan de andere kant betekent undefineddat de variabele niet is gedeclareerd of dat er geen waarde aan is gegeven.

Antwoord 11

De beste manier om het verschil te begrijpen, is door eerst je geest te ontdoen van de innerlijke werking van JavaScript en de verschillen in betekenis te begrijpen tussen:

let supervisor = "None"
    // I have a supervisor named "None"
let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.
let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Er is een verschil in betekenis tussen deze drie gevallen en JavaScript onderscheidt de laatste twee gevallen met twee verschillende waarden, nullen undefined. Het staat je vrij om die waarden expliciet te gebruiken om die betekenissen over te brengen.

Dus wat zijn enkele van de JavaScript-specifieke problemen die zich voordoen als gevolg van deze filosofische basis?

1. Een gedeclareerde variabele zonder initializer krijgt de waarde undefinedomdat je nooit iets hebt gezegd over wat de bedoelde waarde was.

   let supervisor;
   assert(supervisor === undefined);
   

2. Een eigenschap van een object die nooit is ingesteld, evalueert tot undefinedomdat niemand ooit iets over die eigenschap heeft gezegd.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);
   

3. nullen undefinedzijn “vergelijkbaar” met elkaar omdat Brendan Eich dat zei. Maar ze zijn nadrukkelijk niet gelijk aan elkaar.

   assert(null == undefined);
   assert(null !== undefined);
   

4. nullen undefinedhebben gelukkig verschillende typen. nullhoort bij het type nullen undefinedbij het type undefined. Dit staat in de specificatie, maar je zou dit nooit weten vanwege de rare typeofdie ik hier niet zal herhalen.

5. Een functie die het einde van zijn hoofdtekst bereikt zonder een expliciete return-instructie, retourneert undefinedomdat u niets weet over wat hij heeft geretourneerd.

Trouwens, er zijn andere vormen van “niets” in JavaScript (het is goed om filosofie te hebben gestudeerd….)

• NaN
• Een variabele gebruiken die nog nooit is gedeclareerd en een ReferenceError

ontvangen

• Een letof constgedefinieerde lokale variabele gebruiken in de tijdelijke dode zone en een ReferenceError

ontvangen

• Lege cellen in schaarse arrays. Ja, deze zijn niet eens undefinedhoewel ze ===vergelijken met undefined.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]
  

Antwoord 12

Ongedefinieerd betekent dat een variabele is gedeclareerd maar geen waarde heeft:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null is een opdracht:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

Antwoord 13

tl;dr

Gebruik nullom een ​​variabele in te stellen waarvan u weet dat het een Object is.

Gebruik undefinedom een ​​variabele in te stellen waarvan het type gemengd is.

Dit is mijn gebruik van zowel de 5 primitieven als het objecttype, en dat verklaart het verschil tussen use case van undefinedof null.

String

Als u weet dat een variabele slechts een tekenreeks is, terwijl de hele levenscyclus, volgens afspraak, zou kunnen worden geïnitialiseerd in "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Nummer

Als u weet dat een variabele slechts een getal is terwijl de hele levenscyclus, volgens afspraak, zou kunnen worden geïnitialiseerd tot 0(of NaNals 0is een belangrijke waarde in uw gebruik):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

of

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Booleaans

Als u weet dat een variabele slechts een boolean is, terwijl de hele levenscyclus, volgens afspraak, zou kunnen worden geïnitialiseerd in false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Object

Als u weet dat een variabele slechts een object is terwijl de hele levenscyclus, volgens afspraak, u deze zou kunnen initialiseren tot null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Opmerking: het slimme gebruik van null moet de vals-versie van een object zijn, omdat een object altijd trueis, en omdat typeof nullretourneer toString. Dat betekent dat typeof myVarObjecteen consistente waarde retourneert voor zowel Object als null-type.

Alle

Als u weet dat een variabele een gemengd type heeft (elk type tijdens de gehele levenscyclus), kunt u deze volgens afspraak initialiseren tot undefined.

Antwoord 14

In JavasSript zijn er 5 primitieve datatypes String , Number , Boolean , null en undefined.
Ik zal proberen het uit te leggen met een eenvoudig voorbeeld

laten we zeggen dat we een eenvoudige functie hebben

function test(a) {
     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

ook in bovenstaande functie if(a == null) is hetzelfde als if(!a)

nu als we deze functie aanroepen zonder de parameter a door te geven

  test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

ook

var a;
alert(typeof a); 

dit geeft undefined; we hebben een variabele gedeclareerd maar we hebben geen waarde aan deze variabele toegekend;
maar als we schrijven

var a = null;
alert(typeof a); will give alert as object

dus null is een object. op een bepaalde manier hebben we een waarde null toegekend aan ‘a’

Antwoord 15

Wanneer u een variabele in javascript declareert, krijgt deze de waarde undefined. Dit betekent dat de variabele onaangeroerd blijft en in de toekomst elke waarde kan krijgen. Het houdt ook in dat je niet weet welke waarde deze variabele zal hebben op het moment van declaratie.

Je kunt nu expliciet een variabele nulltoewijzen. Het betekent dat de variabele geen waarde heeft. Bijvoorbeeld – Sommige mensen hebben geen tweede naam. Dus in zo’n geval is het beter om de waarde null toe te wijzen aan de middelste naamvariabele van een persoonsobject.

Veronderstel nu dat iemand toegang heeft tot de middelste naamvariabele van uw persoonsobject en dat deze de waarde undefinedheeft. Hij zou niet weten of de ontwikkelaar vergeten was deze variabele te initialiseren of dat deze geen waarde had. Als het de waarde nullheeft, kan de gebruiker gemakkelijk afleiden dat middlename geen waarde heeft en dat het geen onaangeroerde variabele is.

Antwoord 16

OK, we kunnen in de war raken als we horen over nullen undefined, maar laten we het simpel beginnen, ze zijn allebei falsyen vergelijkbaar in veel opzichten, maar raar onderdeel van JavaScript, maak ze een paar significante verschillen, bijvoorbeeld, typeofnullis 'object'terwijl typeofundefinedis 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Maar als je ze controleert met ==zoals hieronder, zie je dat ze allebei valszijn:

null==undefined; //true

U kunt ook nulltoewijzen aan een objecteigenschap of aan een primitief, terwijl undefinedeenvoudig kan worden bereikt door niets toe te wijzen.

Ik maak snel een afbeelding om de verschillen in één oogopslag voor je te laten zien.

Antwoord 17

Voor het type undefinedis er één en slechts één waarde: undefined.

Voor het type nullis er één en slechts één waarde: null.

Dus voor beiden is het label zowel het type als de waarde.

Het verschil tussen hen. Bijvoorbeeld:

• nullis een lege waarde
• undefinedis een ontbrekende waarde

Of:

• undefinedheeft nog geen waarde gehad
• nullhad een waarde en niet meer

Eigenlijk is nulleen speciaal zoekwoord, geen identifier, en daarom kun je het niet behandelen als een variabele om aan toe te wijzen.

undefinedis echter een identificatie. In zowel de non-strictmodus als de strictmodus kunt u echter een lokale variabele met de naam undefined maken. Maar dit is een verschrikkelijk idee!

function foo() {
    undefined = 2; // bad idea!
}
foo();
function foo() {
    "use strict";
    undefined = 2; // TypeError!
}
foo();

Antwoord 18

Naast een andere betekenis zijn er nog andere verschillen:

1. Object destructuringwerkt anders voor deze twee waarden:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null
   

2. JSON.stringify()behoudt nullmaar laat undefinedweg

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}
   

3. type operator

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"
   

Antwoord 19

null en undefined worden beide gebruikt om de afwezigheid van een waarde aan te geven.

var a = null;

a is geïnitialiseerd en gedefinieerd.

typeof(a)
//object

null is een object in JavaScript

Object.prototype.toString.call(a) // [object Object]
var b;

b is niet gedefinieerd en niet geïnitialiseerd

ongedefinieerde objecteigenschappen zijn ook ongedefinieerd. “x” is bijvoorbeeld niet gedefinieerd op object c en als u probeert toegang te krijgen tot c.x, wordt het undefined geretourneerd.

Over het algemeen kennen we null toe aan variabelen die niet ongedefinieerd zijn.

Antwoord 20

Per Ryan Morr’s grondige artikel over dit onderwerp…

“Over het algemeen is null bijna altijd de beste optie als u een niet-waarde aan een variabele of eigenschap moet toewijzen, doorgeven aan een functie of retourneren vanuit een functie. Simpel gezegd, JavaScript gebruikt undefined en programmeurs zouden null moeten gebruiken.”

Zie De eeuwige afgrond van null en ongedefinieerd verkennen

Antwoord 21

In javascript worden alle variabelen opgeslagen als sleutelwaardeparen. Elke variabele wordt opgeslagen als variable_name : variable_value/reference.

undefinedbetekent dat een variabele een spatie in het geheugen heeft gekregen, maar dat er geen waarde aan is toegekend. Als best practice zou je dit type niet als opdracht moeten gebruiken.

Hoe geef je dan aan wanneer je wilt dat een variabele later in de code geen waarde heeft? U kunt het type gebruiken:
null, wat ook een type is dat wordt gebruikt om hetzelfde te definiëren, afwezigheid van een waarde, maar het is niet hetzelfde als undefined, omdat je in dit geval de waarde in het geheugen hebt. Die waarde is null

Beide zijn vergelijkbaar, maar gebruik en betekenis zijn verschillend.

Antwoord 22

Ik wil een heel subtiel verschil toevoegen tussen nullen undefined, wat goed is om te weten wanneer je Vanilla JavaScript (JS) van de grond af probeert te leren:

• nullis een gereserveerd zoekwoord in JS terwijl undefinedeen variabele is
  op het globale object van de runtime-omgeving waarin u zich bevindt.

Tijdens het schrijven van code is dit verschil niet herkenbaar, aangezien zowel nullals undefinedaltijd worden gebruikt in de RHS van een JavaScript-instructie. Maar als je ze in LHS van een uitdrukking gebruikt, kun je dit verschil gemakkelijk waarnemen. Dus JS interpreter interpreteert de onderstaande code als fout:

var null = 'foo'

Het geeft onderstaande foutmelding:

Uncaught SyntaxError: Onverwachte token null

Terwijl onderstaande code met succes wordt uitgevoerd, hoewel ik dit in het echte leven niet zal aanbevelen:

var undefined = 'bar'

Dit werkt omdat undefinedeen variabele is op het globale object (browservensterobject in het geval van client-side JS)

Antwoord 23

Aangezien typeof undefined retourneert, is undefined een type waarbij als null een initializer is, de variabele wijst naar geen object (vrijwel alles in Javascript is een object).

Antwoord 24

null– Het is een toewijzingswaarde, die met variabele wordt gebruikt om geen waarde aan te geven (het is een object).

undefined– Het is een variabele waaraan geen waarde is toegewezen, dus JavaScript zal er een undefined aan toewijzen (het is een gegevenstype).

onverklaard– Als een variabele helemaal niet is gemaakt, staat deze bekend als onverklaard.

Antwoord 25

Bekijk dit eens. De output is duizend woorden waard.

var b1 = document.getElementById("b1");
checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);
function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}
function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

       var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

       x=5;
        y=null;
        z=x+y;

let number;
number; // => undefined

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false