You can just check if the variable has a truthy value or not. That means

if (value) {
    // do something..
}

will evaluate to true if value is not:

• null
• undefined
• NaN
• empty string ("")
• 0
• false

The above list represents all possible falsy values in ECMA-/Javascript. Find it in the specification at the ToBoolean section.

Furthermore, if you do not know whether a variable exists (that means, if it was declared) you should check with the typeof operator. For instance

if (typeof foo !== 'undefined') {
    // foo could get resolved and it's defined
}

If you can be sure that a variable is declared at least, you should directly check if it has a truthy value like shown above.

You are declaring true variables here

var corpName = " ";
var allianceName = " "

In JavaScript, the value of a string with whitespace characters is actually truthy. While the above values do look empty, the reality is they're not. Try it out yourself.

Boolean(" ");
=> true

To set these variables empty, you need to declare them without whitespace characters

var corpName = "";
var allianceName = "";

After you have this, there are two ways to check if the variable is empty

if (!corpName || !corpName.length)

Assuming, you did accidentally include the whitespace character, there are several ways to fix this. We can modify these strings in these cases.

Boolean(" ".trim());
=> false

In the above example, the trim() function is used to remove whitespace characters from a string.

You could also search the string for non-whitespace characters

/\S/.test(" ")
=> false

The \S modifier finds all non whitespace characters.

Alternatively, you could also use the replace function

Boolean(" ".replace(/\s/g, ''));

The global flag g finds all references to the previous regular expression.

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
}

Just say:

if (selection) {
    alert(selection);
}

The simple true/false test in Javascript returns true if the member is defined, non-null, non-false, non-empty string, or non-zero.

Also, in Javascript, something can be equal to a value undefined or actually undefined (meaning, no such named object exists). e.g.

var x = undefined;
alert(x===undefined); /* true; */
alert(x); /* false */
x=1;
alert(x); /* true */

alert(y===undefined); /* reference error - there's nothing called y */
alert(y); /* reference error */
alert(typeof y === "undefined"); /* true */

As the comment below notes, if you are not sure if something even exists at all, you should test that first using typeof.

You want to do the check for undefined first. If you do it the other way round, it will generate an error if the array is undefined.

if (array === undefined || array.length == 0) {
    // array does not exist or is empty
}

Update

This answer is getting a fair amount of attention, so I'd like to point out that my original answer, more than anything else, addressed the wrong order of the conditions being evaluated in the question. In this sense, it fails to address several scenarios, such as null values, other types of objects with a length property, etc. It is also not very idiomatic JavaScript.

The foolproof approach
Taking some inspiration from the comments, below is what I currently consider to be the foolproof way to check whether an array is empty or does not exist. It also takes into account that the variable might not refer to an array, but to some other type of object with a length property.

if (!Array.isArray(array) || !array.length) {
  // array does not exist, is not an array, or is empty
  // ⇒ do not attempt to process array
}

To break it down:

1. Array.isArray(), unsurprisingly, checks whether its argument is an array. This weeds out values like null, undefined and anything else that is not an array.
   Note that this will also eliminate array-like objects, such as the arguments object and DOM NodeList objects. Depending on your situation, this might not be the behavior you're after.

2. The array.length condition checks whether the variable's length property evaluates to a truthy value. Because the previous condition already established that we are indeed dealing with an array, more strict comparisons like array.length != 0 or array.length !== 0 are not required here.

The pragmatic approach
In a lot of cases, the above might seem like overkill. Maybe you're using a higher order language like TypeScript that does most of the type-checking for you at compile-time, or you really don't care whether the object is actually an array, or just array-like.

In those cases, I tend to go for the following, more idiomatic JavaScript:

if (!array || !array.length) {
    // array or array.length are falsy
    // ⇒ do not attempt to process array
}

Or, more frequently, its inverse:

if (array && array.length) {
    // array and array.length are truthy
    // ⇒ probably OK to process array
}

With the introduction of the optional chaining operator (Elvis operator) in ECMAScript 2020, this can be shortened even further:

if (!array?.length) {
    // array or array.length are falsy
    // ⇒ do not attempt to process array
}

Or the opposite:

if (array?.length) {
    // array and array.length are truthy
    // ⇒ probably OK to process array
}

If you truly want to confirm that a variable is not null and not an empty string specifically, you would write:

Copyif(data !== null && data !== '') {
   // do something
}

Notice that I changed your code to check for type equality (!==|===).

If, however you just want to make sure, that a code will run only for "reasonable" values, then you can, as others have stated already, write:

Copyif (data) {
  // do something
}

Since, in javascript, both null values, and empty strings, equals to false (i.e. null == false).

The difference between those 2 parts of code is that, for the first one, every value that is not specifically null or an empty string, will enter the if. But, on the second one, every true-ish value will enter the if: false, 0, null, undefined and empty strings, would not.

I check length.

if (str.length == 0) {
}

Because an undefined variable is "falsey", you can simple do

if (body.req.gradeName) {
  // do normal stuff
} else {
  // do error stuff
}

Or if you don't need to do anything if it is defined, then you can do

if (!(body.req.gradeName)) {
 // do error stuff 
}

If you are using jsrender then

{{if name}}

should do the trick

You can find a lot of scenarios solved in the jsrender demo section.

render() {
    return (
      <div>
        <div>{!!(this.myvar)?this.myvar:"whatever you want"}</div>//
      </div>

    );
  }

!!: check for undefined, null, and empty value

If you're testing for an empty string:

if(myVar === ''){ // do stuff };

If you're checking for a variable that has been declared, but not defined:

if(myVar === null){ // do stuff };

If you're checking for a variable that may not be defined:

if(myVar === undefined){ // do stuff };

If you're checking both i.e, either variable is null or undefined:

if(myVar == null){ // do stuff };

First is not standard, it only works for defined empty string.

Other will work if value is not truthy ( means something meaningful)

e.g var a;

a == '' will give false result
! a     will produce true

e.g. var a = null;

a == '', // false
! a      // true

var a = false;

a == '' // fase
! a     // true

var a = NaN

a == ''  // false
! NaN     // true

true == 'true' // false, Boolean true is first converted to number and then compared

0 == '' // true, string is first converted to integer and then compared

== uses The Abstract Equality Comparison Algorithm to compare two operands

For more detail visit http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

You can use the qualities of the abstract equality operator to do this:

if (variable == null){
    // your code here.
}

Because null == undefined is true, the above code will catch both null and undefined.

You did create an empty Array, no problems with your creation code.

An Array in Javascript is considered empty if it holds no elements.

You check for an empty array in Javascript like this:

Copyconsole.log("emptyArr: " + !!emptyArr.length);

Copylet emptyArr = []; // or new Array();
console.log("emptyArr: " + !!emptyArr.length);
if (emptyArr.length) {
  console.log("Array is not empty");
} else {
  console.log("Array is empty");
}

Since the following values evaluate to false in a Boolean expression in Javascript

0, "", undefined, null, false

instead of if (!!emptyArr.length) you simply go if (emptyArr.length) in Javascript. These values (except false) are called falsy in Javascript.