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

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

从概念上讲，JavaScript中的数组包含array.length元素，从array[0]开始直到array[array.length - 1]。如果i位于0和array.length - 1之间，则索引为i的数组元素被定义为数组的一部分。如果i不在这个范围内，它就不在数组中。

因此，从概念上讲，数组是线性的，从0开始，一直到最大值，没有任何机制在这个范围内存在没有条目的“间隙”。要找出一个值是否存在于给定的位置索引(其中索引为0或正整数)，您只需使用

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

现在，在底层，JavaScript引擎几乎肯定不会像这样线性连续地分配数组空间，因为这在动态语言中没有多大意义，而且对于某些代码来说效率很低。它们可能是哈希表或一些策略的混合，数组的未定义范围可能没有分配它们自己的内存。尽管如此，JavaScript语言希望将array.length n的数组表示为具有n成员的数组，并且它们被命名为0到N - 1，在这个范围内的任何内容都是数组的一部分。

然而，您可能想要知道数组中的值是否为实际上是有定义的——也就是说，它不是undefined。也许你甚至想知道它是否被定义和不是# EYZ1。可以在不设置数组值的情况下向数组添加成员:例如，如果您通过增加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
}

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

如果数组[index]为空，请尝试此操作

if (array[index] != null)

我建议创建一个这样的函数:

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

你可以这样称呼它:

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

强制开发人员使用isemptyl接口将捕获输入错误，例如未定义的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也有类似的结果。

如果数组或索引值不存在，就会得到一个错误。

对于有效的输入，如果arrayName[indexVal]是以下任意一个，你只会得到一个true:

• 零
• 未定义的
• 南
• 空字符串
• 0
• 假

你可以使用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>

Check more examples in http://underscorejs.org/

仅使用.length是不安全的，并且会在某些浏览器中导致错误。这里有一个更好的解决方案:

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

或者，我们可以用:

Object.keys(__array__).length

这取决于你对“空”的定义。

当您试图获取一个对象的属性值时，该对象没有该名称的属性，您将获得值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确实是一个数组下标，请参阅检查属性名称是否为数组索引

使用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
}

也适用于关联数组和删除某些索引的数组

要检查它是否从未被定义，was deleted OR是一个空值或逻辑空值(NaN，空字符串，false):

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

我在使用laravel数据表时遇到了这个问题。我在一个活动日志中存储了一个名为properties的JSON值，并希望根据这个值是否为空来显示一个按钮。

好吧，数据表是解释这作为一个数组，如果它是空的，和一个对象，如果它不是，因此，下面的解决方案为我工作:

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

对象没有长度属性。

短而通用的方法

如果你想检查任何数组是否有假值(如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
}

让我们先看看如果JavaScript中不存在数组值会发生什么，所以如果我们有一个如下所示的数组:

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

现在我们检查6是否在索引5处:

arr[5];

，我们得到 # EYZ0…< / p >

这基本上给了我们答案，最好的方法来检查是否未定义，就像这样:

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在那里，它也不会被识别，还有一些其他的东西可以做同样的事情，让你的应用程序有bug，所以要小心，我把它们都列了下来:

1. 未定义的:如果该值没有定义并且是undefined
2. 零:如果它是空的，例如如果一个DOM元素不存在…
3. # EYZ1: # EYZ0
4. 0:数字零
5. 南:不是数字
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
}

我认为这个决定适合那些喜欢声明式函数编程而不是命令式OOP或过程式编程的人。如果你的问题是里面有一些值吗? (true或false值)"，你可以使用.some方法来验证里面的值。

[].some(el => el || !el);

• 它并不完美，但它不需要应用任何包含相同逻辑的额外函数，如function isEmpty(arr) { ... }。
• 当我们这样做[].length导致0时，它听起来仍然比“它是零长度吗?”好，这在某些情况下是危险的。
• 甚至这个[].length > 0表示“它的长度大于0吗?”

先进的例子:

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

真正的检测:in操作符

这个问题的年龄大约是10年，令人惊讶的是，还没有人提到这一点-然而，当我们使用delete操作符时，有些人看到了问题(例如在这里)。这也是一个有点违反直觉的解决方案，但在“对象世界”中工作的in操作符也可以用于数组(因为我们可以像在“键”上一样查看数组索引……)通过这种方式，我们可以检测并区分undefined数组值和delete删除的值(索引)

if(index in arrayName) {
// do stuff
}

let arr = [0, 1, 2, 3, null, undefined,6]


delete arr[2]; // we delete element at index=2


if(2 in arr) console.log('You will not see this because idx 2 was deleted');
if(5 in arr) console.log('This is element arr[5]:', arr[5]);






// Whole array and indexes bigger than arr.length:
for(let i=0; i<=9; i++) {
let val = (i in arr) ? arr[i] : 'empty'
let bound = i<arr.length ? '' : '(out of range)'
console.log(`${i} value: `, val, bound);
}




console.log('Look on below aray on chrome console (not in SO snippet console)');
console.log('typeof arr:', typeof arr);
console.log(arr);

为了获得类似的效果，没有delete定义数组如下

[0, 1,, 3, null, undefined, 6] // pay attention to double comma: ",,"

当你创建的空数组值不是undefined时，它们是empty

var arr = new Array(10); // (10) [empty × 10]

但是当你通过索引获取item时，receive undefined

arr[0]; // undefined

所以你不能通过===比较知道它们是未定义的还是空的

我们可以使用JSON。Stringify，转换整个数组，将空值替换为null

JSON.stringify(arr); // "[null,null,null,null,null,null,null,null,null,null]"
JSON.stringify(arr[0]); // but for single item it returns undefined

对空值的实检查:

arr[0] !== null && JSON.stringify(arr.map(item => !item)).slice(1, -1).split(',')[0] === 'null'

1. 将item与null进行比较(不应等于)
2. 映射数组删除false代替现有值(确保字符串结构用逗号分隔，没有多余的逗号)
3. JSON。stringify数组
4. 从字符串中移除括号
5. 用逗号分割成数组
6. 比较null