Каков наилучший способ найти объект в массиве?
Это лучший способ, который я знаю:
function include(arr, obj) {
for(var i=0; i<arr.length; i++) {
if (arr[i] == obj) return true;
}
}
include([1,2,3,4], 3); // true
include([1,2,3,4], 6); // undefined
С ECMAScript 2016 вы можете использовать includes()
arr.includes(obj);
Если вы хотите поддерживать IE или другие старые браузеры:
function include(arr,obj) {
return (arr.indexOf(obj) != -1);
}
EDIT: Это не будет работать на IE6, 7 или 8. Лучшее обходное решение - определить его самостоятельно, если оно отсутствует:
Версия Mozilla (ECMA-262):
if (!Array.prototype.indexOf)
{
Array.prototype.indexOf = function(searchElement /*, fromIndex */)
{
"use strict";
if (this === void 0 || this === null)
throw new TypeError();
var t = Object(this);
var len = t.length >>> 0;
if (len === 0)
return -1;
var n = 0;
if (arguments.length > 0)
{
n = Number(arguments[1]);
if (n !== n)
n = 0;
else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
n = (n > 0 || -1) * Math.floor(Math.abs(n));
}
if (n >= len)
return -1;
var k = n >= 0
? n
: Math.max(len - Math.abs(n), 0);
for (; k < len; k++)
{
if (k in t && t[k] === searchElement)
return k;
}
return -1;
};
}
Версия Daniel James:
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (obj, fromIndex) {
if (fromIndex == null) {
fromIndex = 0;
} else if (fromIndex < 0) {
fromIndex = Math.max(0, this.length + fromIndex);
}
for (var i = fromIndex, j = this.length; i < j; i++) {
if (this[i] === obj)
return i;
}
return -1;
};
}
Array.prototype.hasObject = (
!Array.indexOf ? function (o)
{
var l = this.length + 1;
while (l -= 1)
{
if (this[l - 1] === o)
{
return true;
}
}
return false;
} : function (o)
{
return (this.indexOf(o) !== -1);
}
);
Если вы используете jQuery:
$.inArray(5 + 5, [ "8", "9", "10", 10 + "" ]);
Для получения дополнительной информации: http://api.jquery.com/jQuery.inArray/
Во-первых, внедрите indexOf в JavaScript для браузеров, которые еще не имеют его. Например, см. дополнительные атрибуты Erik Arvidsson (также связанный пост в блоге). И тогда вы можете использовать indexOf, не беспокоясь о поддержке браузера. Здесь немного оптимизированная версия его реализации indexOf:
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (obj, fromIndex) {
if (fromIndex == null) {
fromIndex = 0;
} else if (fromIndex < 0) {
fromIndex = Math.max(0, this.length + fromIndex);
}
for (var i = fromIndex, j = this.length; i < j; i++) {
if (this[i] === obj)
return i;
}
return -1;
};
}
Он изменился, чтобы сохранить длину, так что ей не нужно искать ее на каждой итерации. Но разница не огромна. Менее универсальная функция может быть быстрее:
var include = Array.prototype.indexOf ?
function(arr, obj) { return arr.indexOf(obj) !== -1; } :
function(arr, obj) {
for(var i = -1, j = arr.length; ++i < j;)
if(arr[i] === obj) return true;
return false;
};
Я предпочитаю использовать стандартную функцию и оставляю такую микро-оптимизацию, когда она действительно нужна. Но если вы увлекаетесь микро-оптимизацией, я адаптировал теги , которые связаны с roosterononacid в комментариях, до сравнительный поиск в массивах. Они довольно грубые, хотя полное расследование будет проверять массивы разных типов, разных длин и нахождение объектов, которые встречаются в разных местах.
Если массив несортирован, на самом деле нет лучшего способа (кроме использования вышеупомянутого indexOf, который, по моему мнению, является одним и тем же). Если массив отсортирован, вы можете выполнить двоичный поиск, который работает следующим образом:
Двоичный поиск выполняется во времени, пропорциональном логарифму длины массива, поэтому он может быть намного быстрее, чем смотреть на каждый отдельный элемент.
предполагается .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.prototype.has=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
использование второго аргумента arg (флаг) сравнивает значение по значению вместо ссылки
Это зависит от вашей цели. Если вы программируете для Интернета, избегайте indexOf, он не поддерживается Internet Explorer 6 (многие из них все еще используются!) Или выполняются условно:
if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target);
else result = customSlowerSearch(yourArray, target);
indexOf, вероятно, закодирован в собственном коде, поэтому он быстрее, чем все, что вы можете сделать в JavaScript (кроме бинарного поиска/дихотомии, если массив подходит).
Примечание: это вопрос вкуса, но я бы сделал return false; в конце вашей подпрограммы, чтобы вернуть истинное логическое...
Вот некоторые мета-знания для вас - если вы хотите знать, что вы можете делать с массивом, проверьте документацию - здесь страница Массив для Mozilla
https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array
Там вы увидите ссылку на indexOf, добавленную в Javascript 1.6
Здесь подробно описан надежный способ проверить, является ли объект массивом в 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;
}