我创建了一个对象数组，代码如下：
[
{
"lat": 12.123,
"lng": 13.213,
"city": "New York"
},
{
"lat": 3.123,
"lng": 2.213,
"city": "New York"
},
{
"lat": 1.513,
"lng": 1.113,
"city": "London"
}
]
我正在尝试创建一个新数组，过滤掉只包含具有相同city属性的对象（经纬度重复是可以的）。是否有内置的JS或Jquery函数可以实现这一点？
在过滤期间，我可能会使用一个 flags 对象 (编辑：不再使用，关于 ES2015 的 Set 请参见答案末尾的注释)，像这样：
var flags = {};
var newPlaces = places.filter(function(entry) {
if (flags[entry.city]) {
return false;
}
flags[entry.city] = true;
return true;
});
这使用了 ECMAScript5 (ES5) 的 Array#filter，而它是可以被 shimming 的 ES5 增加部分之一（搜索“ es5 shim”以获取几个选项）。
当然，您也可以不使用 filter，只是会变得更冗长：
var flags = {};
var newPlaces = [];
var index;
for (index = 0; index < places.length; ++index) {
if (!flags[entry.city]) {
flags[entry.city] = true;
newPlaces.push(entry);
}
});
以上两种方法都假设给定城市的第一个对象应该被保留，而其他所有对象则应该被丢弃。
注意：如下面的user2736012所指出的，我的测试if (flags[entry.city])会对那些名字恰好与Object.prototype上存在的属性（如toString）相同的城市返回true。在这种情况下可能性非常小，但有四种方法可以避免这种情况：
（我通常喜欢的解决方案）创建没有原型的对象：var flags = Object.create(null);。这是ES5的一个特性。请注意，这不能为像IE8这样的过时浏览器添加shim（除非null是该参数的值）。
使用hasOwnProperty进行测试，例如：if (flags.hasOwnProperty(entry.city))
给你知道不存在于任何Object.prototype属性中的前缀，例如xx：
var key = "xx" + entry.city;
if (flags[key]) {
// ...
}
flags[key] = true;
从 ES2015 开始，您可以使用 Set 替代：
const flags = new Set();
const newPlaces = places.filter(entry => {
if (flags.has(entry.city)) {
return false;
}
flags.add(entry.city);
return true;
});
Object.prototype属性的城市，但使用.hasOwnProperty()仍然不是一个坏主意。 - user2736012constructor属性所困扰。他/她提出了一个非常有用的观点。 - T.J. Crowder以下是 ES6 中最短的解决方案（请参见下面的更新），虽不是最佳实践：
function unique(array, propertyName) {
return array.filter((e, i) => array.findIndex(a => a[propertyName] === e[propertyName]) === i);
}
filter方法和Set数据结构来筛选那些属性值还未被添加到Set中的元素（然后将其添加到Set）。使用逻辑与运算符 (&&) 可以使这一过程仅用一行代码完成。使用这种数据结构的优点是具有亚线性的查找时间（通常为 O(1)）。arr)中根据特定属性(prop)获取唯一数组的对象。请注意，在重复的情况下，只会保留具有该属性值的第一个对象。const getUniqueBy = (arr, prop) => {
const set = new Set;
return arr.filter(o => !set.has(o[prop]) && set.add(o[prop]));
};
演示:
var places = [{
lat: 12.123,
lng: 13.213,
city: 'New York'
}, {
lat: 3.123,
lng: 2.213,
city: 'New York'
}, {
lat: 3.123,
lng: 4.123,
city: 'Some City'
}];
const getUniqueBy = (arr, prop) => {
const set = new Set;
return arr.filter(o => !set.has(o[prop]) && set.add(o[prop]));
};
console.log(getUniqueBy(places, 'city'));https://lodash.com/docs#uniqBy
https://github.com/lodash/lodash/blob/4.13.1/lodash.js#L7711
/**
* This method is like `_.uniq` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* uniqueness is computed. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Array|Function|Object|string} [iteratee=_.identity]
* The iteratee invoked per element.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* _.uniqBy([2.1, 1.2, 2.3], Math.floor);
* // => [2.1, 1.2]
*
* // The `_.property` iteratee shorthand.
* _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 1 }, { 'x': 2 }]
*/
Array.prototype.unique = function(selector) {
return this.filter((e, i) => this.findIndex((a) => {
if (selector) {
return selector(a) === selector(e);
}
return a === e;
}) === i);
};
用法：
// with no param it uses strict equals (===) against the object
let primArr = ['one','one','two','three','one']
primArr.unique() // ['one','two','three']
let a = {foo:123}
let b = {foo:123}
let fooArr = [a,a,b]
fooArr.unique() //[a,b]
// alternatively, you can pass a selector function
fooArr.unique(item=>item.foo) //[{foo:123}] (first "unique" item returned)
这绝不是最高效的方法，但只要选择器简单且数组不是很大，它就可以正常工作。
Array.prototype.unique = function<T>(this: T[], selector?: (item: T) => object): T[] {
return this.filter((e, i) => this.findIndex((a) => {
if (selector) {
return selector(a) === selector(e);
}
return a === e;
}) === i);
};
module.exports = (array, prop) => {
const keyValueArray = array.map(entry => [entry[prop], entry]);
const map = new Map(keyValueArray);
return Array.from(map.values());
};
关于Map和array对象的更多信息请点击此处
我的建议：
Array.prototype.uniqueCity = function() {
var processed = [];
for (var i=this.length-1; i>=0; i--){
if (processed.indexOf(this[i].city)<0) {
processed.push(this[i].city);
} else {
this.splice(i, 1);
}
}
}
使用中：
places.uniqueCity();
或者
Array.prototype.uniqueObjectArray = function(field) {
var processed = [];
for (var i=this.length-1; i>=0; i--) {
if (this[i].hasOwnProperty(field)) {
if (processed.indexOf(this[i][field])<0) {
processed.push(this[i][field]);
} else {
this.splice(i, 1);
}
}
}
}
places.uniqueObjectArray('city');
function uniqueCity(array) {
var processed = [];
for (var i=array.length-1; i>=0; i--){
if (processed.indexOf(array[i].city)<0) {
processed.push(array[i].city);
} else {
array.splice(i, 1);
}
}
return array;
}
places = uniqueCity(places);
.prototype方法来说有点太具体了。这不是技术问题，更多的是概念上的问题，这是主观的。 - user2736012prototype.unique 并添加一些支持，比如指定键名 function(key) { ... }，那么我认为这还可以接受，但是这似乎有点儿小傻。 - Jakub Kotrs另一个选择：
const uniqueBy = prop => list => {
const uniques = {}
return list.reduce(
(result, item) => {
if (uniques[item[prop]]) return result
uniques[item[prop]] = item
return [...result, item]
},
[],
)
}
const uniqueById = uniqueBy('id')
uniqueById([
{ id: 1, name: 'one' },
{ id: 2, name: 'two' },
{ id: 1, name: 'one' },
{ id: 3, name: 'three' }
])
const distinctArrayByCity= [
...new Map(array.map((item) => [item.city, item])).values(),
];
var places = [{ 'lat': 12.123, 'lng': 13.213, 'city': "New York"},
{ 'lat': 3.123, 'lng': 2.213, 'city': "New York"},
{ 'lat': 43.123, 'lng': 12.213, 'city': "London"}];
var cityMap = new Map();
places.forEach(p=> cityMap.set(p.city, p));
console.log([...cityMap.values()]);