Vad är skillnaden mellan null och undefined i JavaScript?

Vad är skillnaden mellan null och undefined i JavaScript?

Svar #1

undefined betyder att en variabel har deklarerats men ännu inte tilldelats ett värde :

var testVar;
console.log(testVar); //shows undefined
console.log(typeof testVar); //shows undefined

null är ett tilldelningsvärde. Det kan tilldelas en variabel som en representation av inget värde :

var testVar = null;
console.log(testVar); //shows null
console.log(typeof testVar); //shows object

Från de föregående exemplen är det tydligt att undefined och null är två olika typer: undefined är en typ i sig själv (undefined) medan null är ett objekt.

Bevis :

console.log(null === undefined) // false (not the same type)
console.log(null == undefined) // true (but the "same value")
console.log(null === null) // true (both type and value are the same)

och

null = 'value' // Uncaught SyntaxError: invalid assignment left-hand side
undefined = 'value' // 'value'

Svar #2

Skillnaden kan förklaras med toalettpappershållare:

Ett icke-nollvärde är som en hållare med en rulle toalettpapper och det finns fortfarande papper kvar på tuben.
Ett nollvärde är som en hållare med en tom toarulle.
Ett nollvärde är som en hållare som inte ens har ett torrisrör.
Ett odefinierat värde liknar att själva behållaren saknas.

Svar #3

Jag plockade det här härifrån

Det odefinierade värdet är ett primitivt värde som används när en variabel inte har tilldelats ett värde.
Nullvärdet är ett primitivt värde som representerar null, tom eller icke-existerande referens.

När du deklarerar en variabel med var och inte ger den ett värde, kommer den att ha värdet undefined. I sig självt, om du försöker använda WScript.Echo() eller alert() med detta värde, kommer du inte att se något. Men om du lägger till en tom sträng till det kommer det plötsligt att synas:

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

Du kan deklarera en variabel, sätta den till null, och beteendet är identiskt förutom att du kommer att se "null" utskrivet istället för "undefined". Detta är en liten skillnad verkligen.

Du kan till och med jämföra en variabel som är odefinierad med null eller tvärtom, och villkoret kommer att vara sant:

undefined == null
null == undefined

De anses dock vara två olika typer. Medan undefined är en typ i sig själv, anses null vara ett speciellt objektvärde. Du kan se detta genom att använda typeof() som returnerar en sträng som representerar den allmänna typen av en variabel:

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

Att köra ovanstående skript kommer att resultera i följande utdata:

undefined
object

Oavsett att de är olika typer, kommer de ändå att bete sig likadant om du försöker komma åt en medlem av någon av dem, t.ex. det vill säga att de kommer att kasta ett undantag. Med WSH kommer du att se det fruktade "'varname' är null eller inte ett objekt" och det är om du har tur (men det är ett ämne för en annan artikel).

Du kan uttryckligen sätta en variabel till att vara undefined, men jag avråder starkt från det. Jag rekommenderar att endast sätta variabler till null och lämna undefined som värde för saker du glömt att sätta. Samtidigt uppmuntrar jag verkligen att alltid sätta varje variabel. JavaScript har en scope-kedja som är annorlunda än den hos C-liknande språk, vilket lätt kan förvirra även erfarna programmerare, och att sätta variabler till null är det bästa sättet att förhindra buggar baserade på detta.

Ett annat exempel där du kommer att se undefined dyka upp är när du använder delete-operatorn. Vi som kommer från en C-värld kan felaktigt tolka detta som att vi förstör ett objekt, men så är det inte. Vad denna operation gör är att ta bort ett index från en Array eller en medlem från ett Object. För Arrays påverkar det inte längden, utan det indexet anses nu vara undefined.

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

Resultatet av skriptet ovan är:

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

Du kommer också att få undefined som returvärde när du läser ett subscript eller en medlem som aldrig har funnits.

Skillnaden mellan null och undefined är: JavaScript kommer aldrig att sätta något till null, det är vanligtvis vad vi gör. Medan vi kan sätta variabler till undefined, föredrar vi null eftersom det inte är något som någonsin görs åt oss. När du felsöker betyder det här att allt som sätts till null är av din egen handling och inte JavaScript. Bortsett från det är dessa två speciella värden nästan ekvivalenta.

Svar #4

Vänligen läs följande noggrant. Det bör ta bort alla dina tvivel angående skillnaden mellan null och undefined i JavaScript. Dessutom kan du använda hjälpfunktionen i slutet av detta svar för att få mer specifika typer av variabler.

I JavaScript kan vi ha följande typer av variabler:

Odeklarerade variabler
Deklarerade men oassignerade variabler
Variabler tilldelade med literal undefined
Variabler tilldelade med litteral null
Variabler tilldelade med något annat än undefined eller null

Följande förklarar var och en av dessa fall ett i taget:

Odeklarerade variabler
- Kan endast kontrolleras med typeof-operatorn som returnerar strängen 'undefined'
- Kan inte kontrolleras med den lösa likhetsoperatorn (== undefined), än mindre med den strikta likhetsoperatorn (=== undefined),
  samt if-satser och ternära operatorer (? :) — dessa ger Reference Errors
Deklarerade men oassignerade variabler
- typeof returnerar sträng 'undefined'
- == jämförelse med null returnerar true
- == jämförelse med undefined returnerar true
- === kontroll med null returnerar false
- === jämförelse med undefined returnerar true
- Är falsk för if-satser och ternära operatorer ( ? : )
Variabler tilldelade med literal undefined
Dessa variabler behandlas exakt på samma sätt som deklarerade men oåtkomna variabler.
Variabler tilldelade med bokstavlig null
- typeof returnerar sträng 'object'
- == kontroll med null returnerar true
- == jämförelse med undefined returnerar true
- === kontroll med null returnerar true
- === jämfört med undefined returnerar false
- Är falsk för if-satser och ternära operatorer ( ? : )
Variabler som tilldelats något annat än undefined eller null
- typeof returnerar en av följande strängar: 'bigint', 'boolean', 'function', 'number', 'object', 'string', 'symbol'

Följande ger algoritmen för korrekt typkontroll av en variabel:

Hämta typeof för vår variabel och returnera den om den inte är 'object'
Kontrollera för null, eftersom typeof null också returnerar 'object'
Utvärdera Object.prototype.toString.call(o) med ett switch-uttryck för att returnera ett mer precist värde. Object's toString-metod returnerar strängar som ser ut som '[object ConstructorName]' för inbyggda/värdobjekt. För alla andra objekt (användardefinierade objekt) returnerar den alltid '[object Object]'
Om det sista fallet är fallet (den strängifierade versionen av variabeln är '[object Object]') och parametern returnConstructorBoolean är true, kommer det att försöka få namnet på konstruktören genom att toString-a den och extrahera namnet därifrån. Om konstruktören inte kan nås, returneras som vanligt 'object'. Om strängen inte innehåller dess namn, returneras 'anonymous'.

(stöder alla typer upp till 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)
  }
}

Svar #5

null är ett speciellt nyckelord som indikerar frånvaro av värde.

tänk på det som ett värde, som:

"foo" är en sträng,
true är boolean,
1234 är ett nummer,
null är undefined.

undefined egenskap indikerar att en variabel inte har tilldelats ett värde, inklusive null. Som

var foo;

definierad tom variabel är null av datatyp undefined

Båda representerar ett värde av en variabel utan värde

OCH null representerar inte en sträng som inte har något värde - tom sträng -

Gilla

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

Nu om

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

MEN

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

ALLTSÅ var och en har sitt eget sätt att använda

undefined använd det för att jämföra variabelns datatyp

null använd det för att tömma ett värde på en variabel

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

Svar #6

null: frånvaro av värde för en variabel; undefined: frånvaro av själva variabeln;

..där variabeln är ett symboliskt namn kopplat till ett värde.

JS skulle kunna vara vänlig nog att implicit initiera nydeklarerade variabler med null, men det gör det inte.

Svar #7

Du kan överväga undefined att representera en systemnivå, oväntad eller fel-liknande frånvaro av värde och null att representera en programnivå, normal eller förväntad frånvaro av värde.

via JavaScript: Den definitiva guiden

Svar #8

Många "tekniska" svar har getts, alla mestadels korrekta från den begränsade synvinkeln av JS som ett rent programmeringsspråk.

Jag skulle dock vilja lägga till följande tankar, särskilt när du skriver TypeScript-kod som en del av ett större projekt/(företags)applikation:

När du pratar med en slags backend kommer du troligen att få JSON
Medan vissa backends korrekt undviker användningen av "null" i deras JSON (genom att ta bort dessa egenskaper), gör andra det inte
Nu, medan "null" kan betyda att värdet saknas medvetet, uttrycker det oftare inte denna betydelse. De flesta databaser använder "null" bara för att de inte har en "undefined"-typ. Men betydelsen är egentligen bara "undefined".
På grund av det kan du aldrig veta om ett "null"-värde verkligen betyder medveten frånvaro. Därför kan "null" egentligen inte betyda det medvetna valet av "saknat värde". Det är i allmänhet omöjligt att avgöra.
Som en följd är semantiskt "null" och "undefined" exakt samma sak i praktiken.

Därför, i ett försök att harmonisera saker är jag strikt emot att använda "null" och vill uppmuntra dig att sluta använda "null" i din kod. Det är mycket lättare än du kan tro. Missförstå mig inte. Jag pratar inte om att inte hantera "null"-värden, bara att undvika att uttryckligen använda dem i din kod. Med andra ord: din kod ska fortfarande kunna fungera med av misstag passerade "null"-värden som kommer från utanför din applikation, t.ex. via ett tredjepartsbibliotek som Angular, eller ett tredjepart-backend.

Här är riktlinjerna som gör det möjligt:

undvik direkta odefinierade typkontroller (t.ex. if (value === undefined) { ... }.
Använd istället indirekta typkontroller (även kallade sanningsvärdeskontroller) t.ex. if (value) { ... }
- När 0 eller tomma strängar är meningsfulla, använd antingen
  - en explicit hjälpfunktion som Lodashs isNil
  - När 0 eller tomma strängar är betydelsefulla, använd antingen
  - en explicit hjälpfunktion som Lodashs isNil
  - eller inkludera det meningsfulla värdet i jämförelsen (t.ex. if (!value && value !== 0) { ... })
Överväg att använda en lint-regel som förbjuder användning av null

Svar #9

Det bästa sättet att förstå skillnaden är att först rensa ditt sinne från hur JavaScript fungerar internt och bara förstå skillnaderna i betydelse mellan:

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.

Det finns en skillnad i betydelse mellan dessa tre fall, och JavaScript skiljer de två senare fallen med två olika värden, null och undefined. Du är fri att använda dessa värden uttryckligen för att förmedla dessa betydelser.

Så vilka är några av de JavaScript-specifika problem som uppstår på grund av denna filosofiska grund?

En deklarerad variabel utan en initialiserare får värdet undefined eftersom du aldrig sa något om vad det avsedda värdet var.
```
let supervisor;
assert(supervisor === undefined);
```
En egenskap hos ett objekt som aldrig har satts utvärderas till undefined eftersom ingen någonsin har sagt något om den egenskapen.
```
const dog = { name: 'Sparky', age: 2 };
assert(dog.breed === undefined);
```
null och undefined är "lika" varandra eftersom Brendan Eich sa det. Men de är definitivt inte lika med varandra.
```
assert(null == undefined);
assert(null !== undefined);
```
null och undefined har tack och lov olika typer. null tillhör typen Null och undefined typen Undefined. Detta står i specifikationen, men man skulle aldrig veta det på grund av typeof-konstigheten som jag inte kommer att upprepa här.
En funktion som når slutet av sin kropp utan ett uttryckligt returneringsuttalande returnerar undefined eftersom du inte vet något om vad den returnerade.

Förresten, det finns andra former av "intet" i JavaScript (det är bra att ha studerat filosofi....)

```
NaN
```
Att använda en variabel som aldrig har deklarerats och få ett ReferenceError
Att använda en lokal variabel definierad med let eller const i dess temporära dödszon och få ett ReferenceError

Tomma celler i glesa arrayer. Ja, dessa är inte ens undefined även om de jämför === med undefined.

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

Svar #10

null är ett speciellt värde som betyder "inget värde". null är ett speciellt objekt eftersom typeof null returnerar 'object'.

Å andra sidan betyder undefined att variabeln inte har deklarerats, eller inte har tilldelats något värde.

Svar #11

null och undefined är två distinkta objekttyper som har följande gemensamt:

båda kan bara hålla ett enda värde, null respektive undefined;
båda har inga egenskaper eller metoder och ett försök att läsa några egenskaper hos någon av dem kommer att resultera i ett körtidsfel (för alla andra objekt får du värdet undefined om du försöker läsa en icke-existerande egenskap);
värdena null och undefined betraktas som lika med varandra och med inget annat av == och != operatorer.

Likheterna slutar dock här. För en gångs skull finns det en grundläggande skillnad i hur nyckelorden null och undefined implementeras. Detta är inte uppenbart, men överväg följande exempel:

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

undefined, NaN och Infinity är bara namn på förinitialiserade "superglobal"-variabler - de initialiseras vid körning och kan skrivas över av normala globala eller lokala variabler med samma namn.

Nu, låt oss prova samma sak med null:

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

Hoppsan! null, true och false är reserverade nyckelord - kompilatorn tillåter dig inte att använda dem som variabel- eller egenskapsnamn

En annan skillnad är att undefined är en primitiv typ, medan null är en objekttyp (vilket indikerar frånvaron av en objektreferens). Tänk på följande:

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

Det finns också en viktig skillnad i hur null och undefined behandlas i numeriskt sammanhang:

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 (!!!)

null blir 0 när det används i aritmetiska uttryck eller numeriska jämförelser - på samma sätt som false, är det i princip bara en speciell typ av "noll". undefined, å andra sidan, är ett verkligt "ingenting" och blir NaN ("inte ett nummer") när du försöker använda det i numeriskt sammanhang.

Observera att null och undefined får en speciell behandling från == och !=-operatorerna, men du kan testa verklig numerisk likhet mellan a och b med uttrycket (a >= b && a <= b).

Svar #12

Jag kommer att förklara undefined, null och Uncaught ReferenceError:

1 - Uncaught ReferenceError : variabel har inte deklarerats i ditt skript, det finns ingen referens till denna variabel
2 - undefined: Variabel deklarerad men inte initialiserad
3 - null : Variabel deklarerad och har ett tomt värde

Svar #13

Undefined betyder att en variabel har deklarerats men inte har något värde:

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

Null är en tilldelning:

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

Svar #14

Förutom en annan betydelse finns det andra skillnader:

Objektdestrukturering fungerar olika för dessa två värden:

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

JSON.stringify() behåller null men utelämnar undefined

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

typeof-operator

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