I am using this code to check undefined variable but it's not working.
var uemail = localStorage.getItem("useremail");_x000D_
_x000D_
if (typeof uemail === "undefined")_x000D_
{_x000D_
alert('undefined');_x000D_
}_x000D_
else_x000D_
{_x000D_
alert('defined');_x000D_
}
_x000D_
This question is related to
typescript
Adding this late answer to check for object.propertie that can help in some cases:
Using a juggling-check, you can test both null and undefined in one hit:
if (object.property == null) {
If you use a strict-check, it will only be true for values set to null and won't evaluate as true for undefined variables:
if (object.property === null) {
Typescript does NOT have a function to check if a variable is defined.
Update October 2020
You can now also use the nullish coallesing operator introduced in Typescript.
let neverNullOrUndefined = someValue ?? anotherValue;
Here, anotherValue
will only be returned if someValue
is null or undefined.
Late to the story but I think some details are overlooked?
if you use
if (uemail !== undefined) {
//some function
}
You are, technically, comparing variable uemail
with variable undefined
and, as the latter is not instantiated, it will give both type and value of 'undefined' purely by default, hence the comparison returns true.
But it overlooks the potential that a variable by the name of undefined
may actually exist -however unlikely- and would therefore then not be of type undefined.
In that case, the comparison will return false.
To be correct one would have to declare a constant of type undefined for example:
const _undefined: undefined
and then test by:
if (uemail === _undefined) {
//some function
}
This test will return true
as uemail
now equals both value & type of _undefined
as _undefined
is now properly declared to be of type undefined.
Another way would be
if (typeof(uemail) === 'undefined') {
//some function
}
In which case the boolean return is based on comparing the two strings on either end of the comparison. This is, from a technical point of view, NOT testing for undefined, although it achieves the same result.
Use 'this' keyword to access variable. This worked for me
var uemail = localStorage.getItem("useremail");
if (typeof this.uemail === "undefined")
{
alert('undefined');
}
else
{
alert('defined');
}
You can just check for truthy on this:
if(uemail) {
console.log("I have something");
} else {
console.log("Nothing here...");
}
Go and check out the answer from here: Is there a standard function to check for null, undefined, or blank variables in JavaScript?
Hope this helps!
In Typescript 2 you can use Undefined type to check for undefined values. So if you declare a variable as:
let uemail : string | undefined;
Then you can check if the variable z is undefined as:
if(uemail === undefined)
{
}
It actually is working, but there is difference between null
and undefined
. You are actually assigning to uemail, which would return a value or null in case it does not exists. As per documentation.
For more information about the difference between the both of them, see this answer.
For a solution to this Garfty's answer may work, depending on what your requirement is. You may also want to have a look here.
It's because it's already null or undefined. Null or undefined does not have any type. You can check if it's is undefined first. In typescript (null == undefined)
is true.
if (uemail == undefined) {
alert('undefined');
} else {
alert('defined');
}
or
if (uemail == null) {
alert('undefined');
} else {
alert('defined');
}
NOT STRICTLY RELATED TO TYPESCRIPT
Just to add to all the above answers, we can also use the shorthand syntax
var result = uemail || '';
This will give you the email if uemail
variable has some value and it will simply return an empty string if uemail
variable is undefined.
This gives a nice syntax for handling undefined variables and also provide a way to use a default value in case the variable is undefined.
From Typescript 3.7 on, you can also use nullish coalescing:
let x = foo ?? bar();
Which is the equivalent for checking for null or undefined:
let x = (foo !== null && foo !== undefined) ?
foo :
bar();
https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#nullish-coalescing
While not exactly the same, you could write your code as:
var uemail = localStorage.getItem("useremail") ?? alert('Undefined');
Source: Stackoverflow.com