tableaux JavaScript à se concentrer sur notre développement quotidien peut être décrit comme problème très commun, la question est donc? Tout comme pour résoudre une série de problèmes à une utilisation intensive quelles méthodes?
1, sous réserve de la méthode de poids
Une méthode utilisée quand j'ai commencé à apprendre JS, cette méthode peut débutants d'abord pensé solution, car selon les attributs objet sera écrasé si le même objet, ce qui permet ainsi la présence des mêmes éléments de jugement à l'utilisation.
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, à utiliser indexOf lourd
IndexOf principe de la méthode est aussi très simple à lourd, mais être déterminée conformément à l'indice de tableau, la mémoire de tableau si l'existence de cet élément indique que l'élément qui est déjà répété, donc pas accès.
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, et en utilisant la valeur d'index détermination indexOf
IndexOf est utilisé pour juger, en fonction de l'indice de jugement indexOf fait avec la valeur courante de l'index, si la valeur d'index et les valeurs d'index ne sont pas égales, ce qui indique la présence d'éléments répétés, peuvent être éliminés.
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, et en utilisant la valeur d'index détermination lastIndexOf
Et sur un principe similaire, mais au lieu d'utiliser
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, le nombre de round robin vingt-deux
Un cycle utilisant deux adjacentes détermine si le nombre de répétition (à l'avance pour trier le tableau), si la répétition retirée
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, le procédé comprend l'utilisation d'un réseau (Une nouvelle méthode pour ES6)
Includes une méthode pour déterminer s'il est temporairement stocké dans le tableau, s'il n'y a pas besoin d'ajouter
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, en utilisant un tableau de la fonction de filtre détermine + indexOf
Le procédé d'utilisation de réseau de filtres est traversé ainsi que la valeur d'indice pour juger indexOf
const unique = (arr) => {
return arr.filter((item, index, _arr) => {
return _arr.indexOf(item) === index;
})
}
8, épissure déduplication
Par réseau d'épissage de méthodes directement sur le tableau original à modifier à noter que si vous ne modifiez pas le tableau original, alors vous devez être une copie, puis la méthode peut être
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 structure de données de réutiliser la carte
Deduplication peut être effectuée conformément à l'opération de carte non-reproductibilité, mais qui nécessite une certaine perte de mémoire.
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, afin de réduire l'utilisation de lourds (nouvelle méthode pour ES6)
Le code est simple, si vous n'êtes pas familier avec la méthode à réduire les petits partenaires peuvent utiliser pour apprendre à regarder cette méthode, cette méthode est bonne si en effet d'une grande utilité.
const unique = (arr) => {
return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
}
11, la structure de données Réutiliser Set
Cela peut être utilisé pour réapprendre la méthode après l'ES6, simple et pratique, facile à utiliser, une petite quantité de code
const unique = (arr) => {
return [...new Set(arr)];
}
Si la nécessité de structures re complexes telles que un tableau de mots peut également être utilisé pour définir le re-structure de
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));
}
Code ci-dessus ne sont applicables qu'aux Déduplication de fonctionnement simple tableau
Écrit dans la dernière
Parce que plus les méthodes, donc nous pouvons utiliser différentes méthodes en fonction de différents scénarios, la complexité du temps et de la complexité de l'espace de ce doivent souvent être pris en considération. Être sélectionné en fonction des différents besoins en espace temps ou dans l'espace pour le temps.
J'espère que vous apprenez quelque chose! Ah ne comprends toujours pas le point de savoir, et apprendre rapidement!
