[Résumé] Méthodes de fonctionnement courantes des tableaux JS pour vous aider à améliorer l'efficacité du développement !

En développement, il existe de nombreux scénarios d'utilisation des baies, et de nombreuses opérations liées aux baies sont également impliquées dans la vie quotidienne. Cet article résume certaines méthodes de fonctionnement courantes et les partage avec vous. Si vous pouvez les utiliser du bout des doigts pendant le développement, vous pouvez considérablement améliorer l'efficacité du développement.

Tri aléatoire

---

1. Générez des nombres aléatoires

Parcourez le tableau, randomisez un nombre dans la plage de longueur du tableau pour chaque cycle et échangez la position de ce cycle et l'élément de position du nombre aléatoire

function randomSort1(arr) {
  for (let i = 0, l = arr.length; i < l; i++) {
    let rc = parseInt(Math.random() * l)
    // 让当前循环的数组元素和随机出来的数组元素交换位置
    const empty = arr[i]
    arr[i] = arr[rc]
    arr[rc] = empty
  }
  return arr
}

var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
// 下面两次的结果肯定是不一样的；
console.log(randomSort1(arr1))
console.log(randomSort1(arr1))

2. Générez un nouveau tableau

• Déclarez un nouveau tableau vide, utilisez une boucle while, si la longueur du tableau est supérieure à 0, continuez à boucler

• À chaque cycle, il y en a une aléatoire ; la plage de longueur du tableau Le nombre à l'intérieur, poussez l'élément à la position du nombre aléatoire dans le nouveau tableau,

• et utilisez splice (les étudiants qui ne comprennent pas l'épissure peuvent lire ici) pour intercepter l'élément à la position du nombre aléatoire, et modifie également l'original La longueur du tableau;

function randomSort2(arr) {
  var mixedArr = []
  while (arr.length > 0) {
    let rc = parseInt(Math.random() * arr.length)
    mixedArr.push(arr[rc])
    arr.splice(rc, 1)
  }
  return mixedArr
}
// 例子
var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

console.log(randomSort2(arr1))

3, arr.sort

• Si la valeur de retour de compareFunction(a, b) est inférieure à 0, alors a sera disposé avant b ;

• Si compareFunction(a , la valeur de retour de b) est égale à 0, alors la position relative de a et b reste inchangée

• Si la valeur de retour de compareFunction(a, b) est supérieure à ; 0, alors b sera disposé avant a ;

function randomSort3(arr) {
  arr.sort(function (a, b) {
    return Math.random() - 0.5
  })
  return arr
}
// 例子
var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

console.log(randomSort3(arr1))

Tri des objets de tableau

---

1. tening

1. Appelez la méthode plate dans ES6

function compare(property) {
  return function (a, b) {
    let value1 = a[property]
    let value2 = b[property]
    return value1 - value2
  }
}

let arr = [
  { name: 'zopp', age: 10 },
  { name: 'gpp', age: 18 },
  { name: 'yjj', age: 8 },
]

console.log(arr.sort(compare('age')))

E2, récursive ordinaire

---

function by(name, minor) {
  return function(o, p) {
    let a, b
    if (o && p && typeof o === 'object' && typeof p === 'object') {
      a = o[name]
      b = p[name]
      if (a === b) {
        return typeof minor === 'function' ? minor(o, p) : 0
      }
      if (typeof a === typeof b) {
        return a < b ? -1 : 1
      }
      return typeof a < typeof b ? -1 : 1
    } else {
      thro(&#39;error&#39;)
    }
  }
},

3, utilisez la fonction Réduire pour itérer

ary = arr.flat(Infinity)

console.log([1, [2, 3, [4, 5, [6, 7]]]].flat(Infinity))

E

4, opérateurs étendus

let result = []
let flatten = function (arr) {
  for (let i = 0; i < arr.length; i++) {
    let item = arr[i]
    if (Array.isArray(arr[i])) {
      flatten(item)
    } else {
      result.push(item)
    }
  }
  return result
}

let arr = [1, 2, [3, 4], [5, [6, 7]]]
console.log(flatten(arr))

E

tableau à réunir

1. Pour interroger

function flatten(arr) {
  return arr.reduce((pre, cur) => {
    return pre.concat(Array.isArray(cur) ? flatten(cur) : cur)
  }, [])
}

let arr = [1, 2, [3, 4], [5, [6, 7]]]
console.log(flatten(arr))

2. Triez d'abord le tableau d'origine, comparez-le avec celui adjacent et stockez-le dans le nouveau tableau s'il est différent.

---

function flatten(arr) {
  while (arr.some((item) => Array.isArray(item))) {
    arr = [].concat(...arr)
  }
  return arr
}

let arr = [1, 2, [3, 4], [5, [6, 7]]]
console.log(flatten(arr))

3. Profitez de l'existence d'attributs d'objet, s'il n'y a pas un tel attribut, stockez-le dans un nouveau tableau.

function unique(arr) {
  var newArr = []
  for (var i = 0; i < arr.length; i++) {
    if (newArr.indexOf(arr[i]) === -1) {
      newArr.push(arr[i])
    }
  }
  return newArr
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

4. Utilisez la méthode include sur l'objet prototype du tableau.

function unique(arr) {
  var formArr = arr.sort()
  var newArr = [formArr[0]]
  for (let i = 1; i < formArr.length; i++) {
    if (formArr[i] !== formArr[i - 1]) {
      newArr.push(formArr[i])
    }
  }
  return newArr
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

5. Utilisez le filtre et inclut les méthodes sur l'objet prototype du tableau.

function unique(arr) {
  var obj = {}
  var newArr = []
  for (let i = 0; i < arr.length; i++) {
    if (!obj[arr[i]]) {
      obj[arr[i]] = 1
      newArr.push(arr[i])
    }
  }
  return newArr
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

6. Utilisez la méthode set d'ES6.

function unique(arr) {
  var newArr = []
  for (var i = 0; i < arr.length; i++) {
    if (!newArr.includes(arr[i])) {
      newArr.push(arr[i])
    }
  }
  return newArr
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

Supprimer les doublons en fonction des attributs

Méthode un

function unique(arr) {
  var newArr = []
  newArr = arr.filter(function (item) {
    return newArr.includes(item) ? '' : newArr.push(item)
  })
  return newArr
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

Méthode deux

---

function unique(arr) {
  return Array.from(new Set(arr)) // 利用Array.from将Set结构转换成数组
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]))

Intersection/Union/Différence

1. comprend la méthode combinée avec la méthode de filtrage

function unique(arr) {
  const res = new Map()
  return arr.filter((item) => !res.has(item.productName) && res.set(item.productName, 1))
}

2. ES6 Définir la structure des données

---

function unique(arr) {
  let result = {}
  let obj = {}
  for (var i = 0; i < arr.length; i++) {
    if (!obj[arr[i].key]) {
      result.push(arr[i])
      obj[arr[i].key] = true
    }
  }
}

Somme du tableau

1 Universel pour la boucle

let a = [1, 2, 3]
let b = [2, 4, 5]

// 并集
let union = a.concat(b.filter((v) => !a.includes(v)))
// [1,2,3,4,5]

// 交集
let intersection = a.filter((v) => b.includes(v))
// [2]

// 差集
let difference = a.concat(b).filter((v) => !a.includes(v) || !b.includes(v))
// [1,3,4,5]

2. 3. Méthode de réduction ES6

---

let a = new Set([1, 2, 3])
let b = new Set([2, 4, 5])

// 并集
let union = new Set([...a, ...b])
// Set {1, 2, 3, 4,5}

// 交集
let intersect = new Set([...a].filter((x) => b.has(x)))
// set {2}

// a 相对于 b 的）差集
let difference = new Set([...a].filter((x) => !b.has(x)))
// Set {1, 3}

Conversion de type tableau

1. Méthode de tranche de tableau

function sum(arr) {
  var s = 0
  for (var i = arr.length - 1; i >= 0; i--) {
    s += arr[i]
  }
  return s
}

sum([1, 2, 3, 4, 5]) // 15

2 Array.from()

function sum(arr) {
  var len = arr.length
  if (len == 0) {
    return 0
  } else if (len == 1) {
    return arr[0]
  } else {
    return arr[0] + sum(arr.slice(1))
  }
}

sum([1, 2, 3, 4, 5]) // 15

3.

---

Déplacez le tableau vers le haut et down

function sum(arr) {
  return arr.reduce(function (prev, curr) {
    return prev + curr
  }, 0)
}

sum([1, 2, 3, 4, 5]) // 15

Convertir le tableau en une structure arborescente

Convertir les données suivantes en une structure arborescente...

let arr = Array.prototype.slice.call(arguments)

Méthode d'implémentation

let arr = Array.from(arguments)

【Recommandations associées : Tutoriel d'apprentissage javascript

】

---

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!