Как проверить в JavaScript, существует ли значение по определенному индексу массива?

Все массивы в JavaScript содержат элементы array.length, начиная с array[0] и заканчивая array[array.length - 1]. По определению, элемент массива с индексом i считается частью массива, если i находится в диапазоне от 0 до array.length - 1 включительно.

То есть массивы JavaScript линейны, начинаются с нуля и идут к максимуму, и у массивов нет механизма исключения определенных значений или диапазонов из массива. Чтобы узнать, существует ли значение в заданном индексе позиции (где индекс - 0 или целое положительное число), можно буквально просто использовать

if (index < array.length) {
  // do stuff
}

Однако возможно, что некоторые значения массива могут быть нулевыми, неопределенными, NaN, Infinity, 0 или множеством других значений. Например, если добавить значения массива, увеличив свойство array.length, то все новые значения будут неопределенными.

Чтобы определить, является ли данное значение чем-то значимым или уже определено. То есть не не определено, или null:

if (typeof array[index] !== 'undefined') {

или

if (typeof array[index] !== 'undefined' && array[index] !== null) {

Интересно, что благодаря правилам сравнения JavaScript'а мой последний пример можно оптимизировать следующим образом:

if (array[index] != null) {
  // The == and != operators consider null equal to only null or undefined
}  

Может'т мы просто сделать это:

if(arrayName.length > 0){   
    //or **if(arrayName.length)**
    //this array is not empty 
}else{
   //this array is empty
}

Используя только `.длина не является безопасным и приведет к ошибке в некоторых браузерах. Вот лучшее решение:

if(array && array.length){   
   // not empty 
} else {
   // empty
}

или, мы можем использовать:

Object.keys(__array__).length

Быстрый и универсальный подход

Если вы хотите проверить любой массив, если это имеет значения ложь (как и ложь, неопределено, null или пустые строки) вы можете просто использовать каждый() метод такой:

array.every(function(element) {return !!element;}); // returns true or false

Например:

['23', null, 2, {key: 'value'}].every(function(element) {return !!element;}); // returns false

['23', '', 2, {key: 'value'}].every(function(element) {return !!element;}); // returns false

['23', true, 2, {key: 'value'}].every(function(element) {return !!element;}); // returns true

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

let falsyIndex; 

if(!['23', true, 2, null, {key: 'value'}].every(function(element, index) {falsyIndex = index; return !!element;})) {
  console.log(falsyIndex);
} // logs 3

Если вам просто нужно проверить значение ложь массива для данного индекса можно делать так:

if (!!array[index]) {
  // array[index] is a correct value
}
else {
  // array[index] is a falsy value
}

if(typeof arr ==='object' && arr instanceof Array ){
   if(!arr.length){
      println 'empty'
   }else{
      printn 'not Empty'
   }

}else{
   println 'Null'
}

Если вы имеете в виду под 'нуль' -> его элементы имеют значение null или равен '' , в данном случае : проверить, если массив пуст после фильтрации все 'нуль' элементы

if(!arr.clean().length){return 'is null'}

Конечно ,добавить чистый метод до :

Array.prototype.clean=function(){return this.filter(function(e){return (typeof  e !=='undefined')&&(e!= null)&&(e!='')})}

Это зависит от того, что вы имеете в виду с "пустой" по.

При попытке получить значение свойства объекта, который имеет свойство с таким именем, вы получите значение undefined по.

Что's что происходит с разреженными массивами: не все показатели между 0 и массива.длина-1 не существует.

Так что вы можете проверить, если массив[индекс] === неопределено`.

Тем не менее, индекс недвижимости могли существовать с "неопределенным" значением. Если вы хотите отфильтровать этом случае, вы можете использовать в оператор или метод hasOwnProperty`, как описано в https://stackoverflow.com/q/135448/1529630

index in array;
array.hasOwnProperty(index);

Если вы хотите рассмотреть существующее свойство с не определено или null значение не существует, вы можете использовать массив свободе сравнение [индекс] == неопределено " или " массив[индекс] == нуль.

Если вы знаете массив не редкие, можно сравнить индекс с массива.длина. Но, чтобы быть безопасным, вы можете гарантировать, что Index на самом деле является индексом массива, см. https://stackoverflow.com/q/38163612/1529630

Я бы рекомендовал создать такие функции:

function isEmptyEl(array, i) {
   return !(array[i]);
}

Вы могли бы назвать это так:

if (isEmptyEl(arrayName, indexVal)) {
   console.log('arrayName[' + indexVal + '] is empty');
}

Заставляет разработчиков придерживаться интерфейс isEmptyEl будет отлавливать ошибки ввода, таких как неопределенное имя_массива или переменные indexVal.

(Он'ы обычно хорошая практика, чтобы программа обороне при программировании в JavaScript.)

Вы получите ошибку, как это, если имя_массива не был определен:

Uncaught ReferenceError: arrayName is not defined
    at :2:15
    at Object.InjectedScript._evaluateOn (:895:140)
    at Object.InjectedScript._evaluateAndWrap (:828:34)
    at Object.InjectedScript.evaluate (:694:21)

Аналогичные результаты для неопределенного indexVal.

Вы получите ошибку, если массив или значения Индекса не существует.

Для допустимых входных данных, вы'Лл только правда если имя_массива[indexVal] является любое из следующих действий:

• значение null
• неопределенные
• НАНА
• пустая строка
• 0
• ложные

Ок, пусть's первый посмотреть, что произойдет, если значения массива не существует в JavaScript, так что если у нас есть массив, как показано ниже:

const arr = [1, 2, 3, 4, 5];

и сейчас мы проверяем, если 6 есть в индексе 5 или нет:

arr[5];

и мы получаем "неопределенным"...

Так что'ы в принципе дать нам ответ, на лучший способ, чтобы проверить, если определено, что-то вроде этого:

if("undefined" === typeof arrayName[index]) {
  //array value is not there...
}

Это's лучше **** не делает этого в данном случае:

if(!arrayName[index]) {
  //Don't check like this..
}

Потому что представьте, что у нас есть этот массив:

const arr = [0, 1, 2];

и мы делаем:

if(!arr[0]) {
  //This get passed, because in JavaScript 0 is falsy
}

Итак, как вы видите, даже 0 Нет, это вовсе'т получить признание, есть несколько других вещей, которые могут сделать то же самое и сделать вас приложение глючит, так что будьте осторожны, я перечислю их всех:

1. определен: если значение не определено, и это'с "неопределенным"
2. нуль: если это'с нуля, например, если элемент DOM не существует...
3. пустая строка: ''
4. 0: количество ноль
5. Нана: не число
6. ложь

Я думаю, что это решение подходит для парней, которые предпочитают декларативный функциональное программирование на императивном ООП или процедурный характер. Если ваш вопрос на"есть некоторые значения внутри? (а истина, либо значение ложь) и" Вы можете использовать `.какой метод для проверки значений внутри. [].некоторые(Эль => Эл || !Эл);

• Это вовсе'т совершенным, но это не'т требует применения каких-либо дополнительных функций, содержащих ту же логику, как isEmpty возвращает функция(ОБР) { ... }.
• Она все равно звучит лучше, чем "Это он нулевой длины?&я когда мы делаем это [].длина приводит к 0, который является опасным в некоторых случаях.
• И даже это[].длина и gt; 0` говорят "это его длина больше нуля?&ьquot;

Дополнительные примеры: [ ].некоторые(Эль => Эл || !Эл); // ложь [нуль].некоторые(Эль => Эл || !Эл); // верно [1, 3].некоторые(Эль => Эл || !Эл); // верно

Я хотел бы обратить внимание на то, несколько, кажется, упустили, а именно: можно иметь собой "пустой" в позиции массива, в середине массива. Рассмотрим следующие:

let arr = [0, 1, 2, 3, 4, 5]

delete arr[3]

console.log(arr)      // [0, 1, 2, empty, 4, 5]

console.log(arr[3])   // undefined

Естественный способ проверить, то будет ли элемент массива неопределено, я не уверен, если есть другие способы

if (arr[index] === undefined) {
  // member does not exist
}

попробуйте это, если массив[индекс] является null

if (array[index] != null) 

С Лодашь, вы можете сделать:

if(_.has(req,'documents')){
      if (req.documents.length)
      _.forEach(req.documents, function(document){
        records.push(document);
      });
} else {
}

если(_.есть(Треб,'документы')) - это чтобы проверить, является ли наш объект запроса имеет свойство с именем "документы" и если он имеет, что опора, на следующий если (запр.документы.длина) состоит в том, чтобы проверить, если это не пустой массив, так что другие материалы, такие какобъекту` могут быть продолжены.

Чтобы проверить, если он никогда не были определены, или если он был удален:

if(typeof arrayName[index]==="undefined"){
     //the index is not in the array
}

также работает с ассоциативными массивами и массивами, где вы удалили какой-то коэффициент

Чтобы проверить, если он не был определен, был удален или является null или пустой логическое значение (НАН, пустая строка, false):

if(typeof arrayName[index]==="undefined"||arrayName[index]){
     //the index is not defined or the value an empty value
}

Я столкнулся с этой проблемой, используя фреймворк Laravel объекты DataTable. Я хранить значение JSON с именем "свойства" в журнале операций и хотел показать кнопку в зависимости от этого значение пустым или нет.

Ну, таблицами толкует это как массив, если он был пуст, и объект, если он не был, поэтому следующее решение работает для меня:

render: function (data, type, full) {
    if (full.properties.length !== 0) {
        // do stuff
    }
}

Объект не имеют свойства length.

Вы можете использовать библиотеку Loadsh сделать это более эффективно, например:

если у вас есть массив с именем и Медведь домашние животные;, например:

var pets = ['dog', undefined, 'cat', null];

console.log(_.isEmpty(pets[1])); // true
console.log(_.isEmpty(pets[3])); // true
console.log(_.isEmpty(pets[4])); // false

_.map( pets, (pet, index) => { console.log(index + ': ' + _.isEmpty(pet) ) });

Чтобы проверить все значения массива для null или undefined значения:

в

var pets = ['dog', undefined, 'cat', null];

console.log(_.isEmpty(pets[1])); // true
console.log(_.isEmpty(pets[3])); // true
console.log(_.isEmpty(pets[4])); // false

_.map( pets, (pet, index) => { console.log(index + ': ' + _.isEmpty(pet) ) });

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>

в

Увидеть больше примеров в http://underscorejs.org/