Question: JSLint is not passing this as a valid code:

```
/* global someVar: false */
if (typeof someVar === "undefined") {
    var someVar = "hi!";
}

```

What is the correct way?

Answer: 
```
/**
 * @param {string} nameOfVariable
 */
function globalExists(nameOfVariable) {
    return nameOfVariable in window
}

```

It doesn't matter whether you created a global variable with var foo or window.foo — variables created with var in global context are written into window.
As of ES6 most of other answers, including the accepted answer, are incorrect, because global variables defined by `let` or `const`, or resulting from a `class` declaration, do not have corresponding properties on the global object (`window` in a browser, or `global` in node.js). Several of them—mainly the ones which use `typeof`—can also be fooled by global variables which exist but which are set to `undefined`.

The only fully general way to test to see if a global variable exists—regardless of whether it has been declared using `var`, `let` or `const`, created via a `function` or `class` declaration, created by assignment (i.e., `myVar = value` at the top level of a program without any declaration for `myVar`) or by creating a property on the global object (i.e., `window.myVar = value`)—is to attempt to access it via a global `eval` and see if TypeError is thrown.

(This builds [on an idea presented by Ferran Maylinch](https://stackoverflow.com/a/36432729/4969945), but with a trick to ensure that it will work properly even when encapsulated in a function.)

```
function globalExists(varName) {
  // Calling eval by another name causes evalled code to run in a
  // subscope of the global scope, rather than the local scope.
  const globalEval = eval;
  try {
    globalEval(varName);
    return true;
  } catch (e) {
    return false;
  }
}

undeclared = undefined;
const myConst = undefined;
let myLet;
var myVar;

globalExists('undeclared')    // => true
globalExists('myConst')       // => true
globalExists('myLet')         // => true
globalExists('myVar')         // => true
globalExists('nonexistent')   // => false
globalExists('globalExists')  // => true - can see itself.
globalExists('varName')       // => false - not fooled by own parameters.
globalExists('globalEval')    // => false - not fooled by local variable.

```

Note that this makes use of `eval`, so all the usual caveats apply: you should not supply an untrusted value as the parameter, and if you must use an untrusted value you should check to make sure that `varName` is a valid JavaScript identifier. Doing so is out of scope for this question, but it can be done using a [(rather complex) regular expression](https://mathiasbynens.be/demo/javascript-identifier-regex)—just beware that the correct regexp depends on the version of ECMAScript you are using, whether the code is a script or (ES6) module, whether it is in an async function, etc. etc.