What reason is there to use null instead of undefined in JavaScript?
JavascriptNullUndefinedJavascript Problem Overview
I've been writing JavaScript for quite a long time now, and I have never had a reason to use null
. It seems that undefined
is always preferable and serves the same purpose programmatically. What are some practical reasons to use null
instead of undefined
?
Javascript Solutions
Solution 1 - Javascript
I don't really have an answer, but according to Nicholas C. Zakas, page 30 of his book "Professional JavaScript for Web Developers":
> When defining a variable that is meant
> to later hold an object, it is
> advisable to initialize the variable
> to null
as opposed to anything else.
> That way, you can explicitly check for the value null
to determine if
> the variable has been filled with an object reference at a later time
Solution 2 - Javascript
null
and undefined
are essentially two different values that mean the same thing. The only difference is in the conventions of how you use them in your system. As some have mentioned, some people use null
for meaning "no object" where you might sometimes get an object while undefined means that no object was expected (or that there was an error). My problem with that is its completely arbitrary, and totally unnecessary.
That said, there is one major difference - variables that aren't initialized (including function parameters where no argument was passed, among other things) are always undefined.
Which is why in my code I never use null unless something I don't control returns null (regex matching for example). The beauty of this is it simplifies things a lot. I never have to check if x === undefined
or x === null
. And if you're in the habit of using ==
or simply stuff like if(x) ...
, stop it.
!x
will evaluate to true for an empty string, 0
, null
, NaN
- i.e. things you probably don't want. If you want to write javascript that isn't awful, always use triple equals ===
and never use null
(use undefined
instead). It'll make your life way easier.
Solution 3 - Javascript
At the end of the day, because both null
and undefined
coerce to the same value (Boolean(undefined) === false && Boolean(null) === false
), you can technically use either to get the job done. However, there is right way, IMO.
-
Leave the usage of
undefined
to the JavaScript compiler.undefined
is used to describe variables that do not point to a reference. It is something that the JS compiler will take care for you. At compile time the JS engine will set the value of all hoisted variables toundefined
. As the engine steps through the code and values becomes available the engine will assign respective values to respective variables. For those variables for whom it did not find values, the variables would continue to maintain a reference to the primitiveundefined
. -
Only use null if you explicitly want to denote the value of a variable as having "no value".
As @com2gz states:
null
is used to define something programmatically empty.undefined
is meant to say that the reference is not existing. Anull
value has a defined reference to "nothing". If you are calling a non-existing property of an object, then you will getundefined
. If I would make that property intentionally empty, then it must benull
so you know that it's on purpose.
TLDR; Don't use the undefined
primitive. It's a value that the JS compiler will automatically set for you when you declare variables without assignment or if you try to access properties of objects for which there is no reference. On the other hand, use null
if and only if you intentionally want a variable to have "no value".
I never explicitly set anything to undefined (and I haven't come across this in the many codebases I've interacted with). Also, I rarely use null
. The only times I use null
is when I want to denote the value of an argument to a function as having no value, i.e.,:
function printArguments(a,b) {
console.log(a,b);
}
printArguments(null, " hello") // logs: null hello
Solution 4 - Javascript
undefined is where no notion of the thing exists; it has no type, and it's never been referenced before in that scope; null is where the thing is known to exist, but it has no value.
Solution 5 - Javascript
Everyone has their own way of coding and their own internal semantics, but over the years I have found this to be the most intuitive advice that I give people who ask this question: when in doubt, do what JavaScript does.
Let's say you are working with object properties like options for a jQuery plugin...ask yourself what value JavaScript gives a property that has yet to be defined -- the answer is undefined
. So in this context, I would initialize these types of things with 'undefined' to be consistent with JavaScript (for variables, you can do var myVar;
instead of var myVar = undefined;
).
Now let's say you are doing DOM manipulation...what value does JavaScript assign to non-existent elements? The answer is null
. This is the value I would initialize with if you are creating a placeholder variable that will later hold a reference to an element, document fragment, or similar that relates to the DOM.
If you're working with JSON, then a special case needs to be made: for undefined property values, you should either set them to ""
or null
because a value of undefined
is not considered proper JSON format.
With this said, as a previous poster has expressed, if you find that you're initializing stuff with null
or undefined
more than once in a blue moon, then maybe you should reconsider how you go about coding your app.
Solution 6 - Javascript
You might adopt the convention suggested here, but there really is no good reason to. It is not used consistently enough to be meaningful.
In order to make the convention useful, you first must know that the called function follows the convention. Then you have to explicitly test the returned value and decide what to do. If you get undefined, you can assume that some kind of error occurred that the called function knew about. But if an error happened, and the function knew about it, and it is useful to send that out into the wider environment, why not use an error object? i.e. throw an error?
So at the end of the day, the convention is practically useless in anything other than very small programs in simple environments.
Solution 7 - Javascript
A few have said that it is ok to initialise objects to null
. I just wanted to point out that destructuring argument defaults don't work with null
. For example:
const test = ({ name } = {}) => {
console.log(name)
}
test() // logs undefined
test(null) // throws error
This requires performing null
checks prior to calling the function which may happen often.
Solution 8 - Javascript
A useful property in null that undefined does not qualifies:
> null + 3
3
> undefined + 3
NaN
I use null
when I want to 'turn off' a numeric value,
or to initialize some. My last use was manipulating css transform:
const transforms = { perspective : null, rotateX : null };
// if already set, increase, if not, set to x
runTimeFunction((x) => { trasforms.perspective += x; });
// still useful, as setting perspective to 0 is different than turning it off
runTimeFunction2((x) => { transforms.perspective = null; });
// toCss will check for 'null' values and not set then at all
runTimeFunction3(() => { el.style.transform = toCss(transforms); });
Not sure if I should use this property thought...
Solution 9 - Javascript
DOM nodes and elements are not undefined, but may be null.
-
The nextSibling of the last child of an element is null.
-
The previousSibling of the first child is null.
-
A document.getElementById reference is null if the element does not exist in the document.
But in none of these cases is the value undefined; there just is no node there.
Solution 10 - Javascript
In JavaScript, the value null
represents the intentional absence of any object value. null
expresses a lack of identification, indicating that a variable points to no object.
The global undefined
property represents the primitive value undefined
.
undefined
is a primitive value automatically assigned to variables.
undefined
is meant to say that the reference is not existing.
Solution 11 - Javascript
I completely disagree that usage null or undefined is unnecessary. undefined is thing which keeping alive whole prototype chaining process. So compiler only with null can't check if this property just equal to null, or its not defined in endpoint prototype. In other dynamic typed languages(f.e. Python) it throws exception if you want access to not defined property, but for prototype-based languages compiler should also check parent prototypes and here are the place when undefined need most.
Whole meaning of using null is just bind variable or property with object which is singleton and have meaning of emptiness,and also null usage have performance purposes. This 2 code have difference execution time.
var p1 = function(){this.value = 1};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
p = new p1();
if(index > 50000000){
p.x = "some_string";
}
return p;
});
big_array.reduce((sum, p)=> sum + p.value, 0)
var p2 = function(){this.value = 1, p.x = null};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
p = new p2();
if(index > 50000000){
p.x = "some_string";
}
return p;
});
big_array.reduce((sum, p)=> sum + p.value, 0)
Solution 12 - Javascript
I'm working through this exact question right now, and looking at the following philosophy:
- Any function that is intended to return a result should return null if it fails to find a result
- Any function that is NOT intended to return a result implicitly returns undefined.
For me, this question is significant because anyone calling a function that returns a result should have no question as to whether to test for undefined vs null.
This answer does not attempt to address:
- Property values of null vs undefined
- Variables within your functions being null vs undefined
In my opinion, variables are your own business and not a part of your API, and properties in any OO system are defined and therefore should be defined with value different from what they would be if not defined (null for defined, undefined is what you get when accessing something that is not in your object).
Solution 13 - Javascript
Here's a reason: var undefined = 1
is legal javascript, but var null = 1
is a syntax error. The difference is that null
is a language keyword, while undefined
is, for some reason, not.
If your code relies on comparisons to undefined
as if it's a keyword (if (foo == undefined)
-- a very easy mistake to make) that only works because nobody has defined a variable with that name. All that code is vulnerable to someone accidentally or maliciously defining a global variable with that name. Of course, we all know that accidentally defining a global variable is totally impossible in javascript...
Solution 14 - Javascript
Just wanna add that with usage of certain javascript libraries, null and undefined can have unintended consequences.
For example, lodash's get
function, which accepts a default value as a 3rd argument:
const user = {
address: {
block: null,
unit: undefined,
}
}
console.log(_.get(user, 'address.block', 'Default Value')) // prints null
console.log(_.get(user, 'address.unit', 'Default Value')) // prints 'Default Value'
console.log(_.get(user, 'address.postalCode', 'Default Value')) // prints 'Default Value'
Another example: If you use defaultProps in React, if a property is passed null
, default props are not used because null is interpreted as a defined value.
e.g.
class MyComponent extends React.Component {
static defaultProps = {
callback: () => {console.log('COMPONENT MOUNTED')},
}
componentDidMount() {
this.props.callback();
}
}
//in some other component
<MyComponent /> // Console WILL print "COMPONENT MOUNTED"
<MyComponent callback={null}/> // Console will NOT print "COMPONENT MOUNTED"
<MyComponent callback={undefined}/> // Console WILL print "COMPONENT MOUNTED"
Solution 15 - Javascript
Unknown variable: undefined
.
Known variable yet no value: null
.
- You receive an object from a server,
server_object
. - You reference
server_object.errj
. It tells you it’sundefined
. That means it doesn’t know what that is. - Now you reference
server_object.err
. It tells you it’snull
. That means you’re referencing a correct variable but it’s empty; therefore no error.
The problem is when you declare a variable name without a value (var hello
) js declares that as undefined
: this variable doesn’t exist; whereas programmers mostly mean: “I’ve not given it a value yet”, the definition of null
.
So the default behavior of a programmer—declaring a variable without a value as nothing—is at odds with js—declaring it as not existing. And besides, !undefined
and !null
are both true
so most programmers treat them as equivalent.
You could of course ensure you always do var hello = null
but most won’t litter their code as such to ensure type sanity in a deliberately loosely-typed language, when they and the !
operator treat both undefined
and null
as equivalent.
Solution 16 - Javascript
Based on a recent breakage we ran into, the example below shows why I prefer to use undefined
over null
, unless there is a specific reason to do otherwise:
function myfunc (myArg) {
if (typeof myArg === 'string') {
console.log('a', myArg);
} else if (typeof abc === 'object') {
console.log('b', myArg);
if (myArg.id) {
console.log('myArg has an id');
} else {
console.log('myArg has an id');
}
} else {
console.log('no value');
}
}
The following values will play nicely:
'abc'
{}
undefined
{ id: 'xyz' }
On the other hand the assumption of null
and undefined
being equivalent here breaks the code. The reason being is that null
is of type of object
, where as undefined
is of type undefined
. So here the code breaks because you can't test for a member on null
.
I have seen a large number of cases with code of similar appearance, where null
is just asking for problems:
if (typeof myvar === 'string') {
console.log(myvar);
} else if (typeof myvar === 'object') {
console.log(myvar.id);
}
The fix here would be to explicitly test for null:
if (typeof myvar === 'string') {
console.log(myvar);
} else if (myvar !== null && typeof myvar === 'object') {
console.log(myvar.id);
}
My attitude is to code for the weaknesses of a language and the typical behaviours of programmers of that language, hence the philosophy here of going with 'undefined' bey default.
Solution 17 - Javascript
There are already some good answers here but not the one that I was looking for. null
and undefined
both "technically" do the same thing in terms of both being falsy, but when I read through code and I see a "null" then I'm expecting that it's a user defined null, something was explicitly set to contain no value, if I read through code and see "undefined" then I assume that it's code that was never initialized or assigned by anything. In this way code can communicate to you whether something was caused by uninitialized stuff or null values. Because of that you really shouldn't assign "undefined" manually to something otherwise it messes with the way you (or another developer) can read code. If another developer sees "undefined" they're not going to intuitively assume it's you who made it undefined, they're going to assume it's not been initialized when in fact it was. For me this is the biggest deal, when I read code I want to see what it's telling me, I don't want to guess and figure out if stuff has "actually" been initialized.
Not even to mention that using them in typescript means two different things. Using:
interface Example {
name?: string
}
Means that name can be undefined or a string, but it can't be null. If you want it null you have to explicitly use:
interface Example {
name: string | null
}
And even then you'll be forced to initialize it at least with "null".
That's of course only true if you're using "strictNullChecks": true
in tsconfig.json
.
Solution 18 - Javascript
To write simple code you need to keep complexity and variation down. When a variable or a property on an object does not have a value it is undefined , and for a value to be null you need to assign it a null value.