How can I check for an empty/undefined/null string in JavaScript?

The Question :

3054 people think this question is useful

I saw this question, but I didn’t see a JavaScript specific example. Is there a simple string.Empty available in JavaScript, or is it just a case of checking for ""?

The Question Comments :

The Answer 1

3822 people think this answer is useful

If you just want to check whether there’s any value, you can do

if (strValue) {
    //do something

If you need to check specifically for an empty string over null, I would think checking against "" is your best bet, using the === operator (so that you know that it is, in fact, a string you’re comparing against).

if (strValue === "") {

The Answer 2

1175 people think this answer is useful

For checking if a string is empty, null or undefined I use:

function isEmpty(str) {
    return (!str || 0 === str.length);

For checking if a string is blank, null or undefined I use:

function isBlank(str) {
    return (!str || /^\s*$/.test(str));

For checking if a string is blank or contains only white-space:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());

The Answer 3

353 people think this answer is useful

All the previous answers are good, but this will be even better. Use dual NOT operators (!!):

if (!!str) {
    // Some code here

Or use type casting:

if (Boolean(str)) {
    // Code here

Both do the same function. Typecast the variable to Boolean, where str is a variable.
It returns false for null, undefined, 0, 000, "", false.
It returns true for string "0" and whitespace " ".

The Answer 4

110 people think this answer is useful

The closest thing you can get to str.Empty (with the precondition that str is a String) is:

if (!str.length) { ...

The Answer 5

105 people think this answer is useful

If you need to make sure that the string is not just a bunch of empty spaces (I’m assuming this is for form validation) you need to do a replace on the spaces.

if(str.replace(/\s/g,"") == ""){

The Answer 6

69 people think this answer is useful

I use:

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof(e) == "undefined":
      return true;
      return false;

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

The Answer 7

47 people think this answer is useful

You can use lodash: _.isEmpty(value).

It covers a lot of cases like {}, '', null, undefined, etc.

But it always returns true for Number type of JavaScript primitive data types like _.isEmpty(10) or _.isEmpty(Number.MAX_VALUE) both returns true.

The Answer 8

42 people think this answer is useful

Very generic “All-In-One” Function (not recommended though):

function is_empty(x)
    return (                                                           //don't put newline after return
        (typeof x == 'undefined')
        (x == null)
        (x == false)        //same as: !x
        (x.length == 0)
        (x == 0)            // note this line, you might not need this. 
        (x == "")
        (x.replace(/\s/g,"") == "")

However, I don’t recommend to use that, because your target variable should be of specific type (i.e. string, or numeric, or object?), so apply the checks that are relative to that variable.

The Answer 9

38 people think this answer is useful
var s; // undefined
var s = ""; // ""
s.length // 0

There’s nothing representing an empty string in JavaScript. Do a check against either length (if you know that the var will always be a string) or against ""

The Answer 10

38 people think this answer is useful


if (str && str.trim().length) {  

The Answer 11

36 people think this answer is useful


I perform tests on macOS v10.13.6 (High Sierra) for 18 chosen solutions. Solutions works slightly different (for corner-case input data) which was presented in the snippet below.


  • the simple solutions based on !str,==,=== and length are fast for all browsers (A,B,C,G,I,J)
  • the solutions based on the regular expression (test,replace) and charAt are slowest for all browsers (H,L,M,P)
  • the solutions marked as fastest was fastest only for one test run – but in many runs it changes inside ‘fast’ solutions group

Enter image description here


In the below snippet I compare results of chosen 18 methods by use different input parameters

  • "" "a" " "– empty string, string with letter and string with space
  • [] {} f– array, object and function
  • 0 1 NaN Infinity – numbers
  • true false – Boolean
  • null undefined

Not all tested methods support all input cases.

function A(str) {
  let r=1;
  if (!str)
  return r;

function B(str) {
  let r=1;
  if (str == "")
  return r;

function C(str) {
  let r=1;
  if (str === "")
  return r;

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
  return r;

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
  return r;

function F(str) {
  let r=1;
  return r;

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
  return r;

function H(str) {
  let r=1;
  return r;

function I(str) {
  let r=1;
  if (!str.length)
  return r;

function J(str) {
  let r=1;
  if(str.length <= 0)
  return r;

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
  return r;

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
  return r;

function M(str) {
  let r=1;
  return r;

function N(str) {
  let r=1;
  if(!str || !str.trim().length)
  return r;

function O(str) {
  let r=1;
  if(!str || !str.trim())
  return r;

function P(str) {
  let r=1;
  return r;

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
  return r;

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

  return r;

// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=&gt; console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=&gt; console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=&gt; console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);

And then for all methods I perform speed test case str = "" for browsers Chrome v78.0.0, Safari v13.0.4, and Firefox v71.0.0 – you can run tests on your machine here

Enter image description here

The Answer 12

31 people think this answer is useful

I would not worry too much about the most efficient method. Use what is most clear to your intention. For me that’s usually strVar == "".

As per the comment from Constantin, if strVar could some how end up containing an integer 0 value, then that would indeed be one of those intention-clarifying situations.

The Answer 13

21 people think this answer is useful
  1. check that var a; exist
  2. trim out the false spaces in the value, then test for emptiness

    if ((a)&&(a.trim()!=''))
      // if variable a is not empty do this 

The Answer 14

21 people think this answer is useful

You could also go with regular expressions:

if((/^\s*$/).test(str)) { }

Checks for strings that are either empty or filled with whitespace.

The Answer 15

21 people think this answer is useful

A lot of answers, and a lot of different possibilities!

Without a doubt for quick and simple implementation the winner is: if (!str.length) {...}

However, as many other examples are available. The best functional method to go about this, I would suggest:

function empty(str)
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
        return true;
        return false;

A bit excessive, I know.

The Answer 16

17 people think this answer is useful

Also, in case you consider a whitespace filled string as “empty”.

You can test it with this regular expression:

!/\S/.test(string); // Returns true if blank.

The Answer 17

16 people think this answer is useful

I usually use something like this,

if (!str.length) {
    // Do something

The Answer 18

12 people think this answer is useful

If one needs to detect not only empty but also blank strings, I’ll add to Goral’s answer:

function isEmpty(s){
    return !s.length;    

function isBlank(s){
    return isEmpty(s.trim());    

The Answer 19

12 people think this answer is useful

Starting with:

return (!value || value == undefined || value == "" || value.length == 0);

Looking at the last condition, if value == “”, its length must be 0. Therefore drop it:

return (!value || value == undefined || value == "");

But wait! In JavaScript, 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

The Answer 20

11 people think this answer is useful

I have not noticed an answer that takes into account the possibility of null characters in a string. For example, if we have a null character string:

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

To test its nullness one could do something like this:

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
"\0".isNull() // true

It works on a null string, and on an empty string and it is accessible for all strings. In addition, it could be expanded to contain other JavaScript empty or whitespace characters (i.e. nonbreaking space, byte order mark, line/paragraph separator, etc.).

The Answer 21

11 people think this answer is useful

Meanwhile we can have one function that checks for all ’empties’ like null, undefined, ”, ‘ ‘, {}, []. So I just wrote this.

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        return false;
    }else if(typeof(data) === 'string'){
            return true;
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
        return false;

Use cases and results.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

The Answer 22

11 people think this answer is useful

As of now there is no direct method like string.empty to check whether a string is empty or not. But in your code you can use a wrapper check for an empty string like:

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.


Using this you can also make sure that string is not undefined or null too. Remember, undefined, null and empty are three different things.

The Answer 23

11 people think this answer is useful

I didn’t see a good answer here (at least not an answer that fits for me)

So I decided to answer myself:

value === undefined || value === null || value === "";

You need to start checking if it’s undefined. Otherwise your method can explode, and then you can check if it equals null or is equal to an empty string.

You cannot have !! or only if(value) since if you check 0 it’s going to give you a false answer (0 is false).

With that said, wrap it up in a method like:

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PS.: You don’t need to check typeof, since it would explode and throw even before it enters the method

The Answer 24

10 people think this answer is useful

All these answers are nice.

But I cannot be sure that variable is a string, doesn’t contain only spaces (this is important for me), and can contain ‘0’ (string).

My version:

function empty(str){
    return !str || !/[^\s]+/.test(str);

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

Sample on jsfiddle.

The Answer 25

10 people think this answer is useful

To check if it is exactly an empty string:


To check if it is an empty string OR a logical equivalent for no-value (null, undefined, 0, NaN, false, …):


The Answer 26

9 people think this answer is useful

Try this:

export const isEmpty = string => (!string || !string.length);

The Answer 27

9 people think this answer is useful

I did some research on what happens if you pass a non-string and non-empty/null value to a tester function. As many know, (0 == “”) is true in JavaScript, but since 0 is a value and not empty or null, you may want to test for it.

The following two functions return true only for undefined, null, empty/whitespace values and false for everything else, such as numbers, Boolean, objects, expressions, etc.

function IsNullOrEmpty(value)
    return (value == null || value === "");
function IsNullOrWhiteSpace(value)
    return (value == null || !/\S/.test(value));

More complicated examples exists, but these are simple and give consistent results. There is no need to test for undefined, since it’s included in (value == null) check. You may also mimic C# behaviour by adding them to String like this:

String.IsNullOrEmpty = function (value) { ... }

You do not want to put it in Strings prototype, because if the instance of the String-class is null, it will error:

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // Could be set
myvar.IsNullOrEmpty(); // Throws error

I tested with the following value array. You can loop it through to test your functions if in doubt.

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // Valid number in some locales, not in JavaScript
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]

The Answer 28

8 people think this answer is useful

There’s no isEmpty() method, you have to check for the type and the length:

if (typeof test === 'string' && test.length === 0){

The type check is needed in order to avoid runtime errors when test is undefined or null.

The Answer 29

8 people think this answer is useful

Try this

str.value.length == 0

The Answer 30

8 people think this answer is useful

You can easily add it to native String object in JavaScript and reuse it over and over…
Something simple like below code can do the job for you if you want to check '' empty strings:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
  return !(!!this.length);

Otherwise if you’d like to check both '' empty string and ' ' with space, you can do that by just adding trim(), something like the code below:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
   return !(!!this.trim().length);

and you can call it this way:

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false

Add a Comment