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

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

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

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

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

if (i >= 0 && i < array.length) {
  // it is in array
}

Теперь под капотом движки JavaScript почти наверняка не будут распределять пространство массива линейно и непрерывно, как это, поскольку это не имело бы большого смысла в динамическом языке и было бы неэффективно для определенного кода. Вероятно, это хеш-таблицы или какая-то гибридная смесь стратегий, а неопределенные диапазоны массива, вероятно, не выделяются в их собственной памяти. Тем не менее, язык JavaScript хочет представить массивы array.length n как имеющие n членов, и они имеют имена от 0 до n - 1 , и все в этом диапазоне является частью массива.

Однако, вероятно, вам нужно знать, действительно ли значение в массиве определено , то есть нет undefined. Может быть, вы даже хотите знать, если это определено и нетnull . Можно добавлять члены в массив, даже не устанавливая их значения: например, если вы добавляете значения массива путем увеличения 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
}  

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

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

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

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

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

Object.keys(__array__).length

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

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

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

Если вы хотите проверить любой массив, если он имеет ложные значения (например, 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
}

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'}

Конечно, добавьте метод Clean перед:

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

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

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

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

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

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

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

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

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)

Подобные результаты для неопределенного indexVal.

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

Для правильного ввода вы получите значение true, только если arrayName [indexVal]:

• значение NULL
• не определено
• NaN
• пустой строкой
• 0
• ложный

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

Когда вы пытаетесь получить значение свойства объекта, у которого нет свойства с таким именем, вы получите значение 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действительно индекс массива, см. Проверка, если имя свойства является индексом массива.

Хорошо, давайте сначала посмотрим, что произойдет, если значение массива не существует в 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. ложный

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

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
}

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

if (array[index] != null) 

С 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можно было продолжить другие подобные вещи.

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

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

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

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

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

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

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

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

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

Я думаю, что это решение подходит для парней, которые предпочитают декларативное функциональное программирование, а не императивное ООП или процедурное. Если ваш вопрос « Есть ли какие-то значения внутри? (Истинное или ложное значение)», вы можете использовать .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

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

если у вас есть массив с именем "pets", например:

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) ) });

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

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/