ссылка на источник

    module.exports = function isset () {
  //  discuss at: http://locutus.io/php/isset/
  // original by: Kevin van Zonneveld (http://kvz.io)
  // improved by: FremyCompany
  // improved by: Onno Marsman (https://twitter.com/onnomarsman)
  // improved by: Rafał Kukawski (http://blog.kukawski.pl)
  //   example 1: isset( undefined, true)
  //   returns 1: false
  //   example 2: isset( 'Kevin van Zonneveld' )
  //   returns 2: true

  var a = arguments
  var l = a.length
  var i = 0
  var undef

  if (l === 0) {
    throw new Error('Empty isset')
  }

  while (i !== l) {
    if (a[i] === undef || a[i] === null) {
      return false
    }
    i++
  }

  return true
}

phpjs.org это в основном пенсионеры в пользу locutus Вот новая ссылка http://locutus.io/php/var/isset

if (!('foo' in obj)) {
  // not set.
}

старый поток, но вот новый способ запустить эквивалент isset().

ответ

см. ниже для объяснения. обратите внимание, я использую StandardJS синтаксис

Пример Использования

// IMPORTANT pass a function to our isset() that returns the value we're
// trying to test(ES6 arrow function)
isset(() => some) // false

// Defining objects
let some = { nested: { value: 'hello' } }

// More tests that never throw an error
isset(() => some) // true
isset(() => some.nested) // true
isset(() => some.nested.value) // true
isset(() => some.nested.deeper.value) // false

// Less compact but still viable except when trying to use `this` context
isset(function () { return some.nested.deeper.value }) // false

Функции Ответа

/**
 * Checks to see if a value is set.
 *
 * @param {Function} accessor Function that returns our value
 */
function isset (accessor) {
  try {
    // Note we're seeing if the returned value of our function is not
    // undefined
    return typeof accessor() !== 'undefined'
  } catch (e) {
    // And we're able to catch the Error it would normally throw for
    // referencing a property of undefined
    return false
  }
}

---

объяснение

PHP

обратите внимание, что в PHP вы можете ссылаться на любую переменную на любой глубине - даже не пытается доступ в номера-массив как массив будет возвращать просто true или false:

// Referencing an undeclared variable
isset($some); // false

$some = 'hello';

// Declared but has no depth(not an array)
isset($some); // true
isset($some['nested']); // false

$some = ['nested' => 'hello'];

// Declared as an array but not with the depth we're testing for
isset($some['nested']); // true
isset($some['nested']['deeper']); // false

JS

в JavaScript у нас нет такой свободы, мы всегда получим ошибку, если мы это сделаем то же самое, потому что JS немедленно пытается получить доступ к значению deeper прежде чем мы сможем завернуть его в наш

//
//  tring to reference non-existing variable throws ReferenceError 
//  before test function is even executed
//
//  example, if you do:
//    
//     if ( isset( someVar ) ) 
//        doStuff( someVar );
//   
//  you get a ReferenceError ( if there is no someVar... ) 
//  and isset fn doesn't get executed.
//
//  if you pass variable name as string, ex. isset( 'novar' );, 
//  this might work:
//
function isset ( strVariableName ) { 

    try { 
        eval( strVariableName );
    } catch( err ) { 
        if ( err instanceof ReferenceError ) 
           return false;
    }

    return true;

 } 
//
//

Это простое решение работает, но не для глубокой проверки объекта.

function isset(str) {
    return window[str] !== undefined;
}

Я всегда использую эту универсальную функцию для предотвращения ошибок на примитивных переменных, а также массивов и объектов.

isset = function(obj) {
  var i, max_i;
  if(obj === undefined) return false;
  for (i = 1, max_i = arguments.length; i < max_i; i++) {
    if (obj[arguments[i]] === undefined) {
        return false;
    }
    obj = obj[arguments[i]];
  }
  return true;
};

console.log(isset(obj));                   // returns false
var obj = 'huhu';
console.log(isset(obj));                   // returns true
obj = {hallo:{hoi:'hoi'}};
console.log(isset(obj, 'niet'));           // returns false
console.log(isset(obj, 'hallo'));          // returns true
console.log(isset(obj, 'hallo', 'hallo')); // returns false
console.log(isset(obj, 'hallo', 'hoi'));   // returns true

Если вы используете underscorejs Я всегда использую

if (!_.isUndefined(data) && !_.isNull(data)) {
     //your stuff
}

Это решение работает для меня.

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

это довольно пуленепробиваемое решение для тестирования, если переменная существует:

var setOrNot = typeof variable !== typeof undefined ? true : false;

к сожалению, вы не можете просто оформить его в виде функции.

вы могли бы подумать о том, чтобы сделать что-то вроде этого :

function isset(variable) {
    return typeof variable !== typeof undefined ? true : false;
}

однако это приведет к ошибке ссылки, если переменная variable не был определен, потому что вы не можете передать несуществующую переменную в функцию :

Uncaught ReferenceError: foo is not определено

С другой стороны, это позволяет проверить параметры функции неопределены :

var a = '5';

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

test(a);

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

хотя нет y передается в функцию test, наш isset функция прекрасно работает в этом контексте, потому что y известно, что в функции test как undefined значение.

function isset(variable) {
    try {
        return typeof eval(variable) !== 'undefined';
    } catch (err) {
        return false;
    }
}

укажите путь объекта в виде строки, затем вы можете разбить эту строку на путь и разрешить hasOwnProperty на каждом шаге при перезаписи самого объекта с каждой итерацией.

Если вы кодируете в среде ES6, взгляните на в этом сайте StackOverflow вопросы.

var a;

a = {
    b: {
        c: 'e'
    }
};

function isset (obj, path) {
    var stone;

    path = path || '';

    if (path.indexOf('[') !== -1) {
        throw new Error('Unsupported object path notation.');
    }

    
    path = path.split('.');
    
    do {
        if (obj === undefined) {
            return false;
        }

        stone = path.shift();
        
        if (!obj.hasOwnProperty(stone)) {
            return false;
        }
        
        obj = obj[stone];
        
    } while (path.length);

    return true;
}

console.log(
    isset(a, 'b') == true,
    isset(a, 'b.c') == true,
    isset(a, 'b.c.d') == false,
    isset(a, 'b.c.d.e') == false,
    isset(a, 'b.c.d.e.f') == false
);

window.isset = function(v_var) {
    if(typeof(v_var) == 'number'){ if(isNaN(v_var)){ return false; }}
    if(typeof(v_var) == 'undefined' || v_var === null){ return false;   } else { return true; }
};

плюс тесты:

https://gist.github.com/daylik/24acc318b6abdcdd63b46607513ae073

чтобы проверить, существует ли html-блок или нет, я использую этот код:

if (typeof($('selector').html()) != 'undefined') {
    // $('selector') is existing
    // your code here
}

(typeof SOMETHING) !== 'undefined'

Это слишком долго писать при использовании. Но мы не можем упаковать typeof ключевое слово в функцию, потому что ошибка будет брошена перед вызовом функции, например:

function isdef($var) {
    return (typeof $var) !== 'undefined';
}

isdef(SOMETHING); ///// thrown error: SOMETHING is not defined

так что я придумал способ:

function isdef($type) {
    return $type !== 'undefined';
}

isdef(typeof SOMETHING);

Он может работать как с отдельными переменными (переменные, которые вообще не существуют), так и со свойствами объекта (несуществующие свойства). И только 7 больше символов, чем PHP isset.

if (var) {
  // This is the most concise equivalent of Php's isset().
} 

PHP руководство сказать:

isset и - определите, установлена ли переменная и не является NULL

и интерфейс что-то вроде этого:

bool isset ( mixed $var [, mixed $... ] )

параметр $var - это переменная, которая должна быть проверена. он может иметь любое количество параметров.

isset() и возвращает TRUE если var существует и имеет значение, отличное от NULL. FALSE в противном случае.

некоторые пример:

$foo = 'bar';
var_dump(isset($foo));        -> true

$baz = null;
var_dump(isset($baz));        -> false

var_dump(isset($undefined));  -> false

поскольку это в виду, по-видимому, невозможно написать точный эквивалент php

$baz = null;
var_dump(isset($baz));        -> false

Итак, мы можем включить это в javascript, тогда это выглядит так:

if (typeof some_var !== 'undefined' && some_var !== null) {
   // your code here
}