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

Будет ли это работать для проверки наличия или отсутствия значения в позиции "index" или есть лучший способ:

if(arrayName[index]==""){
     // do stuff
}

ОТВЕТЫ

Ответ 1

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

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

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

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

Чтобы определить, является ли данное значение чем-то значимым или определено. То есть не undefined или 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
}

Ответ 2

Разве мы не можем это сделать:

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

Ответ 3

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

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

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

Object.keys(__array__).length

Ответ 4

if(!arrayName[index]){
     // do stuff
}

Ответ 5

if(arrayName.length > index && arrayName[index] !== null) {
    //arrayName[index] has a value
}

Ответ 6

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

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

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
}

Ответ 7

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!='')})}

Ответ 8

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

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

Вы можете называть его следующим образом:

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

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

(Обычно рекомендуется программировать при программировании в Javascript.)

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

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

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

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

Для допустимого ввода вы получите только true, если arrayName [indexVal] - любое из следующего:

  • NULL
  • undefined
  • NaN
  • пустая строка
  • 0
  • ложь

Ответ 9

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

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

Что происходит с разреженными массивами: не все индексы между 0 и array.length-1 существуют.

Итак, вы можете проверить, есть ли array[index] === undefined.

Однако свойство index может существовать со значением undefined. Если вы хотите отфильтровать этот случай, вы можете использовать оператор in или hasOwnProperty, как описано в Как проверить, имеет ли объект свойство в JavaScript?

index in array;
array.hasOwnProperty(index);

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

Если вы знаете, что массив не разрежен, вы можете сравнить index с array.length. Но чтобы быть в безопасности, вы можете убедиться, что index действительно является индексом массива, см. Проверить, является ли имя свойства индексом массива

Ответ 10

попробуйте это, если array [index] имеет значение null

if (array[index] != null)

Ответ 11

С помощью Lodash вы можете:

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

if(_.has(req,'documents')) должен проверить, имеет ли наш объект запроса свойство с именем documents, и если он имеет эту опору, следующий if (req.documents.length) должен проверить, не является ли он пустым массивом, поэтому другие вещи, такие как forEach можно продолжить.

Ответ 12

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

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

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

Чтобы проверить, не было ли оно определено, было удалено ИЛИ - пустое или логическое пустое значение (NaN, пустая строка, ложь):

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

Ответ 13

Я столкнулся с этой проблемой, используя larvel datatables. Я сохранял значение JSON под названием properties в журнале активности и хотел показать кнопку на основе этого значения, которое пусто или нет.

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

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

Объект не имеет свойства длины.

Ответ 14

Хорошо, давайте сначала посмотрим, что произойдет, если значение массива не существует в JavaScript, поэтому, если у нас есть массив, как показано ниже:

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

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

arr[5];

и мы получаем undefined...

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

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

Лучше НЕ делать это в этом случае:

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. undefined: если значение не определено и оно undefined
  2. нуль: если ноль, например, если элемент DOM не существует...
  3. пустая строка: ''
  4. 0: число ноль
  5. NaN: не число
  6. ложный

Ответ 15

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

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
}

Ответ 16

Я думаю, что это решение подходит для парней, которые предпочитают декларативное функциональное программирование, а не императивное ООП или процедурное. Если ваш вопрос " Есть ли какие-то значения внутри? (Истинное или ложное значение)", вы можете использовать метод .some для проверки значений внутри.

[].some(el => el || !el);
  • Он не идеален, но не требует применения каких-либо дополнительных функций, содержащих ту же логику, например, function isEmpty(arr) {... }.
  • Это все еще звучит лучше, чем "Это нулевая длина?" когда мы делаем это [].length результате чего 0 что в некоторых случаях опасно.
  • Или даже это [].length > 0 говорящее "Его длина больше нуля?"

Расширенные примеры:

[    ].some(el => el || !el); // false
[null].some(el => el || !el); // true
[1, 3].some(el => el || !el); // true

Ответ 17

Вы можете использовать библиотеку 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>