[].有（obj）

假设实现了.indexOf（）

Object.defineProperty( Array.prototype,'has',
{
    value:function(o, flag){
    if (flag === undefined) {
        return this.indexOf(o) !== -1;
    } else {   // only for raw js object
        for(var v in this) {
            if( JSON.stringify(this[v]) === JSON.stringify(o)) return true;
        }
        return false;                       
    },
    // writable:false,
    // enumerable:false
})

!!! 不要将Array.protocol.hhas=function（）设置为｛…，因为您将在每个数组中添加一个可枚举元素，js将被破坏。

//use like          
[22 ,'a', {prop:'x'}].has(12) // false
["a","b"].has("a") //  true

[1,{a:1}].has({a:1},1) // true
[1,{a:1}].has({a:1}) // false

第二个参数（标志）的使用强制按值而不是参照进行比较

比较原始对象

[o1].has(o2,true) // true if every level value is same

[].有（obj）

假设实现了.indexOf（）

Object.defineProperty( Array.prototype,'has',
{
    value:function(o, flag){
    if (flag === undefined) {
        return this.indexOf(o) !== -1;
    } else {   // only for raw js object
        for(var v in this) {
            if( JSON.stringify(this[v]) === JSON.stringify(o)) return true;
        }
        return false;                       
    },
    // writable:false,
    // enumerable:false
})

!!! 不要将Array.protocol.hhas=function（）设置为｛…，因为您将在每个数组中添加一个可枚举元素，js将被破坏。

//use like          
[22 ,'a', {prop:'x'}].has(12) // false
["a","b"].has("a") //  true

[1,{a:1}].has({a:1},1) // true
[1,{a:1}].has({a:1}) // false

第二个参数（标志）的使用强制按值而不是参照进行比较

比较原始对象

[o1].has(o2,true) // true if every level value is same

这里有一些元知识供您参考-如果您想知道如何使用Array，请查看文档-这里是Mozilla的Array页面

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array

在那里，您将看到在Javascript 1.6中添加的对indexOf的引用

这取决于你的目的。如果您为Web编程，请避免indexOf，它不受Internet Explorer 6支持（其中许多仍在使用！），或者进行条件使用：

if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target);
else result = customSlowerSearch(yourArray, target);

indexOf可能是用本机代码编写的，所以它比用JavaScript做的任何事情都要快（如果数组合适的话，除了二进制搜索/二分法）。注意：这是一个品味问题，但我会做一个错误的返回；在例程结束时，返回一个真正的布尔值。。。

如果数组是未排序的，那么没有更好的方法（除了使用上面提到的indexOf，我认为这是相同的）。如果数组已排序，则可以执行二进制搜索，其工作方式如下：

拾取阵列的中间元素。你要找的元素比你选择的元素大吗？如果是这样，则消除了阵列的下半部分。如果不是，你已经淘汰了上半场。拾取阵列剩余一半的中间元素，然后继续执行步骤2，消除剩余阵列的一半。最终，您要么找到元素，要么没有数组可供查看。

二进制搜索在时间上与数组长度的对数成正比，因此它可以比查看每个单独的元素快得多。

这里详细介绍了一种检查对象是否为javascript中的数组的健壮方法：

这里是xa.js框架中的两个函数，我将它们附加到utils={}“容器”。这些应该可以帮助您正确检测阵列。

var utils = {};

/**
 * utils.isArray
 *
 * Best guess if object is an array.
 */
utils.isArray = function(obj) {
     // do an instanceof check first
     if (obj instanceof Array) {
         return true;
     }
     // then check for obvious falses
     if (typeof obj !== 'object') {
         return false;
     }
     if (utils.type(obj) === 'array') {
         return true;
     }
     return false;
 };

/**
 * utils.type
 *
 * Attempt to ascertain actual object type.
 */
utils.type = function(obj) {
    if (obj === null || typeof obj === 'undefined') {
        return String (obj);
    }
    return Object.prototype.toString.call(obj)
        .replace(/\[object ([a-zA-Z]+)\]/, '$1').toLowerCase();
};

如果你想检查一个对象是否在一个数组中，我也会包括以下代码：

/**
 * Adding hasOwnProperty method if needed.
 */
if (typeof Object.prototype.hasOwnProperty !== 'function') {
    Object.prototype.hasOwnProperty = function (prop) {
        var type = utils.type(this);
        type = type.charAt(0).toUpperCase() + type.substr(1);
        return this[prop] !== undefined
            && this[prop] !== window[type].prototype[prop];
    };
}

最后，这个in_array函数：

function in_array (needle, haystack, strict) {
    var key;

    if (strict) {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] === needle) {
                return true;
            }
        }
    } else {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] == needle) {
                return true;
            }
        }
    }

    return false;
}