matrices de JavaScript a centrarse en nuestro desarrollo diario puede ser descrito como un problema muy común, por lo que la pregunta es? Todo como para resolver una serie de problemas a un uso intensivo qué métodos?
1, tema con el método de peso
Un método utiliza cuando empecé a aprender JS, este método puede principiantes solución pensado en primer lugar, porque de acuerdo a los atributos de objeto se sobrescribirá si el mismo objeto, permitiendo de este modo la presencia de los mismos elementos de juicio para uso.
const unique = (arr) => {
let map = {};
let res = [];
for (let i = 0; i < arr.length; i++) {
if (!map[arr[i]]) {
map[arr[i]] = 1;
res.push(arr[i]);
}
}
return res;
}
2, para usar indexOf pesada
IndexOf principio del método es también muy sencillo de pesado, pero se determinará de acuerdo con el índice de matriz, la memoria matriz si la existencia de este elemento indica que el elemento que ya se repite, por lo que no hay acceso.
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (res.indexOf(arr[i]) < 0) {
res.push(arr[i]);
}
}
return res;
}
3, y el uso de la determinación del valor de índice indexOf
IndexOf se utiliza para juez, según el índice de juicio indexOf hizo con el valor actual del índice, si el valor de índice y los valores de índice no son iguales, lo que indica la presencia de elementos repetitivos, puede ser eliminado.
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (arr.indexOf(arr[i]) == i) {
res.push(arr[i]);
}
}
return res;
}
4, y el uso de la determinación del valor de índice lastIndexOf
Y en un principio similar, pero en lugar de utilizar
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (arr.lastIndexOf(arr[i]) == i) {
res.push(arr[i]);
}
}
return res;
}
5, el número de round robin veintidós
Un ciclo utilizando dos determina adyacentes si el número de repetición (por adelantado para ordenar la matriz), si la repetición retira
const unique = (arr) => {
let res = [];
// 需要先排序
arr.sort((a, b) => a - b);
res[0] = arr[0];
for (let i = 1; i < arr.length; i++) {
if (arr[i] !== arr[i - 1]) {
res.push(arr[i]);
}
}
return res;
}
6, el método incluye el uso de una matriz (Un nuevo método para ES6)
La incluye un método para determinar si se almacena temporalmente en la matriz, si no hay necesidad de añadir
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (!res.includes(arr[i])) {
res.push(arr[i]);
}
}
return res;
}
7, utilizando una matriz de la función de filtro determina + indexOf
El método de uso de la red de filtros es recorrido y también el valor de índice para juzgar indexOf
const unique = (arr) => {
return arr.filter((item, index, _arr) => {
return _arr.indexOf(item) === index;
})
}
8, la deduplicación de empalme
Por variedad de métodos de empalme directamente en la matriz original que ser modificado para nota que si usted no cambia la matriz original, entonces usted necesita para ser una copia, y luego con el método puede ser
const unique = (arr) => {
arr.sort((a, b) => a - b);
for (let i = 0; i < arr.length - 1; i++) {
if (arr[i + 1] === arr[i]) {
arr.splice(i, 1);
i--;
}
}
return arr;
}
9, la estructura de datos para re-utilizar el mapa
Deduplication se puede realizar de acuerdo con la operación de la no repetibilidad mapa, pero que requiere una cierta pérdida de memoria.
const unique = (arr) => {
let res = [];
let map = new Map();
for (let i = 0; i < arr.length; i++) {
if (!map.has(arr[i])) {
res.push(arr[i]);
map.set(arr[i], true);
}
}
return res;
}
10, a reducir el uso de pesada (Nuevo método para ES6)
Código es simple, si usted no está familiarizado con el método de reducir los socios pequeños pueden utilizar para aprender a mirar a este método, este método es bueno si es de gran utilidad.
const unique = (arr) => {
return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
}
11, la estructura de datos para re-utilizar el conjunto
Esto se puede utilizar el método de volver a aprender después de la ES6, simple y conveniente, fácil de usar, una pequeña cantidad de código
const unique = (arr) => {
return [...new Set(arr)];
}
Si la necesidad de re-estructuras complejas tales como una matriz de palabras también se puede utilizar para re-estructura Set
let arr = [1, {a: 1, b: 2}, [1, 2, 3], {a: 1, b: 2}, [1, 2, 3]
const unique = (arr) => {
return [...new Set(arr.map(item => JSON.stringify(item)))].map(item => JSON.parse(item));
}
El código de seguridad sólo se aplican a la matriz simple operación de eliminación de datos duplicados
Escrito en los últimos
Debido a que más métodos, por lo que podemos utilizar diferentes métodos de acuerdo a diferentes escenarios, la complejidad de tiempo y la complejidad del espacio de dicho menudo necesitan ser considerados. Ser seleccionados de acuerdo a las diferentes necesidades de espacio-tiempo o espacio de tiempo.
Espero que les sirva de algo! Ah todavía no entiendo el punto de conocimientos, y aprender rápidamente!
