Pra*_*sad 1300 javascript arrays contains
我需要确定数组中是否存在值.
我使用以下功能:
Array.prototype.contains = function(obj) {
var i = this.length;
while (i--) {
if (this[i] == obj) {
return true;
}
}
return false;
}
上面的函数总是返回false.
数组值和函数调用如下:
arrValues = ["Sam","Great", "Sample", "High"]
alert(arrValues.contains("Sam"));
eye*_*ess 996
var contains = function(needle) {
// Per spec, the way to identify NaN is that it is not equal to itself
var findNaN = needle !== needle;
var indexOf;
if(!findNaN && typeof Array.prototype.indexOf === 'function') {
indexOf = Array.prototype.indexOf;
} else {
indexOf = function(needle) {
var i = -1, index = -1;
for(i = 0; i < this.length; i++) {
var item = this[i];
if((findNaN && item !== item) || item === needle) {
index = i;
break;
}
}
return index;
};
}
return indexOf.call(this, needle) > -1;
};
你可以像这样使用它:
var myArray = [0,1,2],
needle = 1,
index = contains.call(myArray, needle); // true
cod*_*ape 988
jQuery有一个实用功能:
$.inArray(value, array)
返回valuein的索引array.-1如果array不包含则返回value.
Gab*_*ley 874
这通常是indexOf()方法的用途.你会说:
return arrValues.indexOf('Sam') > -1
Dal*_*ale 361
在ES2016中,有Array.prototype.includes().
该
includes()方法确定数组是否包括某个元素,返回true或false适当.
["Sam", "Great", "Sample", "High"].includes("Sam"); // true
可以使用Babel(使用babel-polyfill)或扩展支持core-js.MDN还提供了polyfill:
if (![].includes) {
Array.prototype.includes = function(searchElement /*, fromIndex*/ ) {
'use strict';
var O = Object(this);
var len = parseInt(O.length) || 0;
if (len === 0) {
return false;
}
var n = parseInt(arguments[1]) || 0;
var k;
if (n >= 0) {
k = n;
} else {
k = len + n;
if (k < 0) {k = 0;}
}
var currentElement;
while (k < len) {
currentElement = O[k];
if (searchElement === currentElement ||
(searchElement !== searchElement && currentElement !== currentElement)) {
return true;
}
k++;
}
return false;
};
}
nca*_*ral 134
因为跨浏览器兼容性和效率的所有问题,使用像lodash这样的库几乎总是更安全.
效率是因为可以保证在任何给定时间,像下划线这样非常受欢迎的库将具有完成这样的实用功能的最有效方法.
_.includes([1, 2, 3], 3); // returns true
如果您担心通过包含整个库而添加到应用程序中的批量,请知道您可以单独包含功能:
var includes = require('lodash/collections/includes');
注意:对于旧版本的lodash,这_.contains()不是_.includes().
Tre*_*vor 46
TL;博士
function includes(k) {
for(var i=0; i < this.length; i++){
if( this[i] === k || ( this[i] !== this[i] && k !== k ) ){
return true;
}
}
return false;
}
例
function includes(k) {
for(var i=0; i < this.length; i++){
if( this[i] === k || ( this[i] !== this[i] && k !== k ) ){
return true;
}
}
return false;
}
function log(msg){
$('#out').append('<div>' + msg + '</div>');
}
var arr = [1, "2", NaN, true];
arr.includes = includes;
log('var arr = [1, "2", NaN, true];');
log('<br/>');
log('arr.includes(1): ' + arr.includes(1));
log('arr.includes(2): ' + arr.includes(2));
log('arr.includes("2"): ' + arr.includes("2"));
log('arr.includes(NaN): ' + arr.includes(NaN));
log('arr.includes(true): ' + arr.includes(true));
log('arr.includes(false): ' + arr.includes(false));#out{
font-family:monospace;
}<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id=out></div>更长的答案
我知道这个问题并不是关于是否扩展内置对象,但是OP的尝试和对这个答案的评论突出了这个争论.我从2013年2月12日的评论中引用了一篇文章,该文章非常清楚地概述了这一争论,但是由于时间太长,我无法编辑原始评论,因此我将其包含在此处.
如果您希望使用方法扩展内置Array对象contains,可能最好和最负责任的方法是使用MDN中的此polyfill .(另请参阅MDN关于原型继承的文章的这一部分,该文章解释说"扩展内置原型的唯一理由是向后移植新JavaScript引擎的功能;例如Array.forEach等")
if (!Array.prototype.includes) {
Array.prototype.includes = function(searchElement /*, fromIndex*/ ) {
'use strict';
var O = Object(this);
var len = parseInt(O.length) || 0;
if (len === 0) {
return false;
}
var n = parseInt(arguments[1]) || 0;
var k;
if (n >= 0) {
k = n;
} else {
k = len + n;
if (k < 0) {k = 0;}
}
var currentElement;
while (k < len) {
currentElement = O[k];
if (searchElement === currentElement ||
(searchElement !== searchElement && currentElement !== currentElement)) {
return true;
}
k++;
}
return false;
};
}
不想要严格平等,还是想要选择？
function includes(k, strict) {
strict = strict !== false; // default is true
// strict = !!strict; // default is false
for(var i=0; i < this.length; i++){
if( (this[i] === k && strict) ||
(this[i] == k && !strict) ||
(this[i] !== this[i] && k !== k)
) {
return true;
}
}
return false;
}
Nic*_*las 44
从ECMAScript6开始,可以使用Set:
var myArray = ['A', 'B', 'C'];
var mySet = new Set(myArray);
var hasB = mySet.has('B'); // true
var hasZ = mySet.has('Z'); // false
Mat*_*epa 21
我的小贡献:
function isInArray(array, search)
{
return array.indexOf(search) >= 0;
}
//usage
if(isInArray(my_array, "my_value"))
{
//...
}
rlo*_*ang 17
鉴于IE的indexOf的实现(如eyelidlessness所述):
Array.prototype.contains = function(obj) {
return this.indexOf(obj) > -1;
};
SoE*_*zPz 17
如果您可以访问ECMA 5,则可以使用某种方法.
arrValues = ["Sam","Great", "Sample", "High"];
function namePresent(name){
return name === this.toString();
}
// Note:
// namePresent requires .toString() method to coerce primitive value
// i.e. String {0: "S", 1: "a", 2: "m", length: 3, [[PrimitiveValue]]: "Sam"}
// into
// "Sam"
arrValues.some(namePresent, 'Sam');
=> true;
如果您有权访问ECMA 6,则可以使用包含方法.
arrValues = ["Sam","Great", "Sample", "High"];
arrValues.includes('Sam');
=> true;
Woj*_*ski 11
您可以使用_.indexOf方法,或者如果您不想在应用程序中包含整个Underscore.js库,您可以查看它们是如何做到的并提取必要的代码.
_.indexOf = function(array, item, isSorted) {
if (array == null) return -1;
var i = 0, l = array.length;
if (isSorted) {
if (typeof isSorted == 'number') {
i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
} else {
i = _.sortedIndex(array, item);
return array[i] === item ? i : -1;
}
}
if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
for (; i < l; i++) if (array[i] === item) return i;
return -1;
};
另一种选择是以下列方式使用Array.some(如果可用):
Array.prototype.contains = function(obj) {
return this.some( function(e){ return e === obj } );
}
传递给的匿名函数Array.some将返回true当且仅当数组中的元素与...相同时obj.如果没有这样的元素,函数将不会返回true数组的任何元素,因此Array.some也将返回false.
哇,这个问题有很多很棒的答案.
我没有看到一个采取reduce方法,所以我将其添加:
var searchForValue = 'pig';
var valueIsInArray = ['horse', 'cat', 'dog'].reduce(function(previous, current){
return previous || searchForValue === current ? true : false;
}, false);
console.log('The value "' + searchForValue + '" is in the array: ' + valueIsInArray);
小智 5
提供的答案对我不起作用，但给了我一个主意：
Array.prototype.contains = function(obj)
{
return (this.join(',')).indexOf(obj) > -1;
}
这不是完美的，因为超出分组的相同项目最终可能会匹配。如我的例子
var c=[];
var d=[];
function a()
{
var e = '1';
var f = '2';
c[0] = ['1','1'];
c[1] = ['2','2'];
c[2] = ['3','3'];
d[0] = [document.getElementById('g').value,document.getElementById('h').value];
document.getElementById('i').value = c.join(',');
document.getElementById('j').value = d.join(',');
document.getElementById('b').value = c.contains(d);
}
当我分别使用包含1和2的'g'和'h'字段调用此函数时，它仍然可以找到它，因为联接产生的字符串为：1,1,2,2,3,3
由于在我的情况下我会遇到这种情况值得怀疑，所以我正在使用它。我以为可以分享，以防别人也无法使所选答案起作用。
小智 5
使用数组 .map 函数为数组中的每个值执行一个函数对我来说似乎最干净。
此方法适用于简单数组和需要查看对象数组中是否存在键/值的对象数组。
function inArray(myArray,myValue){
var inArray = false;
myArray.map(function(key){
if (key === myValue){
inArray=true;
}
});
return inArray;
};
var anArray = [2,4,6,8]
console.log(inArray(anArray, 8)); // returns true
console.log(inArray(anArray, 1)); // returns false
function inArrayOfObjects(myArray,myValue,objElement){
var inArray = false;
myArray.map(function(arrayObj){
if (arrayObj[objElement] === myValue) {
inArray=true;
}
});
return inArray;
};
var objArray = [{id:4,value:'foo'},{id:5,value:'bar'}]
console.log(inArrayOfObjects(objArray, 4, 'id')); // returns true
console.log(inArrayOfObjects(objArray, 'bar', 'value')); // returns true
console.log(inArrayOfObjects(objArray, 1, 'id')); // returns false