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
}
They closed my question on SO because it's not reproducible, but that's exactly why I posted, because code isn't behaving as it should.
Anyway, I 'm receiving a JSON result from a web service. It looks something like this:
{ "data": [{ "id": "123ABC", "name" : "Test 1" }, { "id": "", "name" : "Test 2" }] }I 'm looping through the data array and need to determine if an id exists or not:
for( const item of data ) {
if( item.id !== null && item.id.trim().length > 0 ) {
doSomething();
} else {
doSomethingElse();
}
}My problem is that doSomething() fires for the first item ("123ABC") but also fires for the second where the id is empty.
I've tried spitting out the values for the second item:
console.log("NULL ", item.id === null);
console.log("EMPTY ", item.id.trim().length === 0);and results are
NULL false EMPTY false
so I'm wondering if there's something strange about the id value.
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.
Videos
Perhaps this is trivial, but I got to wondering what is considered the "best" way to check for a blank string. I was specifically thinking of Javascript, although this could be applied to a number of languages. (Any C-style language) I thought up a couple solutions...
if (foo == "") ...
if (foo.length() == 0) ...
Not included in Javascript, but in languages that have it:
if (foo.isEmpty()) ...
Which of these is generally considered the most elegant/readable? Is it the single-purpose function, or a general-purpose function with a comparison? Or does it just not matter?
we had an argue about this on our team, I wonder what approach should we consider? what is the better?
We have a user interface like this:
interface User {
name:string;
family?:string;
age:number;family name is optional, so our backend developer sends us this json data for those users that didnt filled the family:
{name: "john",
family:"",
age:18
}and in another object's case they sends null for the optional props...
We have been confused with this not having a solid convention from the backend team! what approach is the better? I think the right way is just removing optional property from the json data instead of setting it to null or "" empty string, I mean just dont add that!
When declaring variables what's the best practice?
My manager asked me to change a declaration from null to an empty string and I don't really see why?
Edit: This is for JavaScript
Hello and sorry for my noob question but i am stuck here and cant move forward
i have this object
const obj = { first: "", second: "", third: "", fourth: "" };
and using useState to update it const [urls, setUrls] = useState(obj);
and trying in switch to check if properties are empty or not like this:
switch(urls){case urls.first === '':setUrls({ ...urls, ["first"]: state.favoritesUrl});setText({ ...text, ["first"]: state.favoritesUrl});console.log("ispis urls.first: ",text.first);break;case urls.second.length === 0:setUrls({ ...urls, ["second"]: state.favoritesUrl});setText({ ...text, ["second"]: state.favoritesUrl});console.log("ispis urls.second: ",text.second);break;case urls.third.length === 0:setUrls({ ...urls, ["third"]: state.favoritesUrl});setText({ ...text, ["third"]: state.favoritesUrl});console.log("ispis urls.third: ",text.third);break;case urls.fourth.length === 0:setUrls({ ...urls, ["fourth"]: state.favoritesUrl});setText({ ...text, ["fourth"]: state.favoritesUrl});console.log("ispis urls.fourth: ",text.fourth);break;
i tried with .length === 0
and with Object.key(urls.first).length === 0
but my switch/case wont trigger.
I check length.
if (str.length == 0) {
}
If you want to know if it's an empty string use === instead of ==.
if(variable === "") {
}
This is because === will only return true if the values on both sides are of the same type, in this case a string.
for example: (false == "") will return true, and (false === "") will return false.
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.
I've seen so many methods; but I am looking for a simple style I can adopt in my code to keep it consistent:
if (PostCodeInformation !== null PostCodeInformation !== undefined){
}
So I have this regular expression:
/([\s+\-*\/%=&^|<>~"`!;:,.?()[\]{}\\])/gwhich should match all whitespace, and +-*/%=&|<>~"`!;:,.?()[]{}]\
(and the up caret, but reddit is being annoying)
On regex websites like this one, you can see that the Regular Expression works how I'd like it to, however if you run the JavaScript String.split, it returns all the matches I want, and the text in between matches which I also want. The issue is it also returns some empty strings, which I don't want.
Run this in your browser and you'll see what I mean:
`document.write("<h2>Table of Factorials</h2>");
for(i = 1, fact = 1; i < 10; i++, fact *= i) {
document.write(i + "! = " + fact);
document.write("<br>");
}`.split(/([\s+\-*\/%=&^|<>~"`!;:,.?()[{\]}\\])/g);The expected result is something like:
["document", ".", "write", "(", """, "<", "h2", ">", "Table", " ", "of", " ", "Factorials", "<", "/", "h2", ">", """, ")"...]however, the actual result is:
["document", ".", "write", "(", "", """, "", "<", "h2", ">", "Table", " ", "of", " ", "Factorials", "<", "", "/", "h2", ">", "", """, "", ")"...]Why am I getting some empty strings back? How can I fix it? Thank you for your time.
