You can simply use typeof. It will check undefined, null, 0 and "" also.
if(typeof RetailPrice!='undefined' && RetailPrice){
return this.RetailPrice;
}
Videos
Empty string, undefined, null, ...
To check for a truthy value:
if (strValue) {
// strValue was non-empty string, true, 42, Infinity, [], ...
}
To check for a falsy value:
if (!strValue) {
// strValue was empty string, false, 0, null, undefined, ...
}
Empty string (only!)
To check for exactly an empty string, compare for strict equality against "" using the === operator:
if (strValue === "") {
// strValue was empty string
}
To check for not an empty string strictly, use the !== operator:
if (strValue !== "") {
// strValue was not an empty string
}
For checking if a variable is falsey or if it has length attribute equal to zero (which for a string, means it is empty), I use:
function isEmpty(str) {
return (!str || str.length === 0 );
}
(Note that strings aren't the only variables with a length attribute, arrays have them as well, for example.)
Alternativaly, you can use the (not so) newly optional chaining and arrow functions to simplify:
const isEmpty = (str) => (!str?.length);
It will check the length, returning undefined in case of a nullish value, without throwing an error. In the case of an empty value, zero is falsy and the result is still valid.
For checking if a variable is falsey or if the string only contains whitespace or is empty, I use:
function isBlank(str) {
return (!str || /^\s*$/.test(str));
}
If you want, you can monkey-patch the String prototype like this:
String.prototype.isEmpty = function() {
// This doesn't work the same way as the isEmpty function used
// in the first example, it will return true for strings containing only whitespace
return (this.length === 0 || !this.trim());
};
console.log("example".isEmpty());
Note that monkey-patching built-in types are controversial, as it can break code that depends on the existing structure of built-in types, for whatever reason.
Using a juggling-check, you can test both null and undefined in one hit:
if (x == 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 (x === null) {
You can try this with various values using this example:
var a: number;
var b: number = null;
function check(x, name) {
if (x == null) {
console.log(name + ' == null');
}
if (x === null) {
console.log(name + ' === null');
}
if (typeof x === 'undefined') {
console.log(name + ' is undefined');
}
}
check(a, 'a');
check(b, 'b');
Output
"a == null"
"a is undefined"
"b == null"
"b === null"
if( value ) {
}
will evaluate to true if value is not:
nullundefinedNaN- empty string
'' 0false
typescript includes javascript rules.
I believe this is as close as you're going to get only using the typing system (rather than having a 'nonEmptyString' class)
type nonEmptyString = never; // Cannot be implicitly cast to
function isNonEmptyString(str: string): str is nonEmptyString {
return str && str.length > 0; // Or any other logic, removing whitespace, etc.
}
Testing it:
let fn = function(a: nonEmptyString) {
}
let someStr = '';
if (isNonEmptyString(someStr)) {
fn(someStr); // Valid
} else {
fn(someStr); // Compile error
}
Unfortunately, you end up with warts since nonEmptyString is never. Which means you need to explicitly cast nonEmptyString back to string.
let fn = function(a: nonEmptyString) {
let len = a.length; // Invalid
let len2 = (<string>a).length; // Valid
let str = a + 'something else'; // Valid (str is now typed as string)
}
One possible resolution is:
type nonEmptyString = string & { __nonEmptyStr: never };
Which alleviates the problem of having to explicitly cast back to a string (all three tests above are valid), but does pollute the type with __nonEmptyStr (which will be undefined if referenced).
You can use this trick in your specific case:
function fn<T extends string>(a: T extends '' ? never : T) {
// But TypeScript won't know here that !!a === true
}
fn(''); // Error
fn('foo'); // No error
Note that this does NOT work when passing a variable that has type string:
const myEmptyString: string = '';
fn(myEmptyString); // Should error, but does not
Starting with:
return (!value || value == undefined || value == "" || value.length == 0);
Looking at the last condition, if value == "", it's length MUST be 0. Therefore drop it:
return (!value || value == undefined || value == "");
But wait! In JS, an empty string is false. Therefore, drop value == "":
return (!value || value == undefined);
And !undefined is true, so that check isn't needed. So we have:
return (!value);
And we don't need parentheses:
return !value
Q.E.D.
There are just a few revisions I would make.
First, always use === instead of == in Javascript. You can read more about that on Stack Overflow.
Second, since undefined is mutable, I would reccomend using
typeof value === "undefined"
instead of
value === undefined
Third, I would remove the !value and value === "" conditions. They are redundant.
My Revision
I would use a slightly different approach than you:
String.isNullOrEmpty = function(value) {
return !(typeof value === "string" && value.length > 0);
}
This checks if the type of the value is "string" (and thus non-null and not undefined), and if it is not empty. If so, it is not null or empty.
Note that this returns true for non-string inputs, which might not be what you want if you wanted to throw an error for an unexpected input type.