在JavaScript中，可以定义一个变量，但保留value undefined，因此最常见的答案在技术上并不正确，而是执行以下操作：

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

这可能足以满足您的目的。以下测试具有更简单的语义，这使得更容易精确地描述代码的行为并亲自理解（如果您关心这样的事情）：

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

当然，这假定您正在浏览器中运行（其中window是全局对象的名称）。但是，如果您想像这样的全局变量，则可能是在浏览器中。从主观上讲，'name' in windowuse在风格上与window.nameuse引用全局变量一致。通过将全局变量作为属性window而不是变量来访问，可以使您在代码中引用的未声明变量的数量最小化（以利于行进），并避免全局变量被局部变量覆盖的可能性。另外，如果全局对象使您的皮肤爬行，则仅用此相对较长的棍子接触它们时，您可能会感到更舒适。

elem != null

if (elem === undefined) ...

var undefined; // really undefined
if (elem === undefined) ...

(function (undefined) {
    if (elem === undefined) ...
})();

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

var setOrNot = typeof variable !== typeof undefined;

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

function isset(variable) {
    return typeof variable !== typeof undefined;
}

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

if (typeof variable === "undefined") {
  ...
}

var values = typeof variable !== 'undefined' ? variable : '';

var values = variable ? variable : '';

if (typeof console != "undefined") {    
   ...
}

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

if (typeof elem === 'undefined')

elem = elem || defaultElem;

elem = (typeof elem === 'undefined') ? defaultElem : elem;

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

"[variable||property]" in [context||root] 
>> true||false

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

typeof window.console === "undefined"

window.console === undefined

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

existy(elem) && doSomething(elem);

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

if (typeof(jQuery) != "undefined")

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

if (variable === undefined) {}

var status = 'Variable exists'

try {
    myVar
} catch (ReferenceError) {
    status = 'Variable does not exist'
}

console.log(status)

function variableExists(x) {
  var status = true
  try {
      x
  } catch (ReferenceError) {
      status = false
  }
  
  return status
}

console.log(variableExists(x))

function globalVariableExists(variable) {
  if (window[variable] != undefined) {
    return true
  }
  
  return false
}

var x = undefined

console.log(globalVariableExists("x"))

console.log(globalVariableExists("y"))

var z = 123

console.log(globalVariableExists("z"))

if(undeclaredvar) {...}

if(eval('typeof undeclaredvar !== "undefined"')) {...}

if(eval("false")) {
  console.log("NO!");
}
if(eval("true")) {
  console.log("YEAH!");
}