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

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

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

16 ответов


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

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

if (index < array.length) {
  // do stuff
}
, это is для некоторых значений массива возможно значение null,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 != operator 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
}

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

}else{
   println 'Null'
}

Если вы подразумеваете под "Null" - > его элементы равны 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!='')})}

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

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

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

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
  • неопределено
  • Нэн
  • пустая строка
  • 0
  • false

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

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

вот что происходит с разреженными массивами: не все показатели между 0 и .

так что вы можете проверить, если 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 действительно является индексом массива, см. проверьте, является ли имя свойства индексом массива


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

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 datatables. Я хранил значение JSON под названием properties в журнале действий и хотел показать кнопку, основанную на том, что это значение пусто или нет.

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

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

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


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

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

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
}

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