[Zusammenfassung] Gemeinsame Betriebsmethoden von JS-Arrays helfen Ihnen, die Entwicklungseffizienz zu verbessern!

In der Entwicklung gibt es viele Anwendungsszenarien für Arrays, und viele Array-bezogene Vorgänge sind auch im täglichen Leben beteiligt. In diesem Artikel werden einige gängige Betriebsmethoden zusammengefasst und mit Ihnen geteilt. Wenn Sie sie während der Entwicklung jederzeit zur Hand haben, können Sie die Entwicklungseffizienz erheblich verbessern.

Zufällige Sortierung

---

1. Durchlaufen Sie das Array, sortieren Sie für jeden Zyklus eine Zahl innerhalb des Array-Längenbereichs und tauschen Sie die Position dieses Zyklus und die Position der Zufallszahl aus Element

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. Erzeugen Sie ein neues Array.

Deklarieren Sie ein neues leeres Array. Verwenden Sie eine While-Schleife. Wenn die Array-Länge größer als 0 ist, fahren Sie mit der Schleife fort Schieben Sie das Element an der Position der Zufallszahl in den Array-Längenbereich und verschieben Sie es in das neue Array.

• und ändern Sie auch die ursprüngliche Länge des Arrays ;

• Wenn CompareFunction(a, der Rückgabewert von b) gleich 0 ist, dann bleibt die relative Position von a und b unverändert;

• Wenn der Rückgabewert von CompareFunction(a, b) größer ist 0, dann wird b vor a angeordnet.

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))

Array-Abflachung
1. Rufen Sie die flache Methode in ES6 auf
• Array zur Wiedervereinigung

• 1. Zur Abfrage

• 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))

  2. Sortieren Sie zuerst das ursprüngliche Array, vergleichen Sie es mit dem angrenzenden und speichern Sie es im neuen Array, wenn es anders ist.

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')))

3. Nutzen Sie die Existenz von Objektattributen. Wenn es kein solches Attribut gibt, speichern Sie es in einem neuen Array.

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;)
    }
  }
},

---

4. Verwenden Sie die Includes-Methode für das Array-Prototypobjekt.

ary = arr.flat(Infinity)

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



5. Verwenden Sie den Filter und die Includes-Methoden für das Array-Prototypobjekt.

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))

6. Verwenden Sie die Set-Methode von ES6.

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))

Duplikate basierend auf Attributen entfernen

---


Methode Eins

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))

Methode. Zwei

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]))

Schnittpunkt/Vereinigung/Differenz

1. Enthält Methode kombiniert mit Filtermethode

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]))

---

2. ES6 Datenstruktur festlegen

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]))




Array-Summierung

1. Universelle for-Schleife

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]))

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]))

3. ES6-Reduzierungsmethode

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]))

Array-ähnliche Konvertierung

1. Arrays Slice-Methode

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

---

2. Array.from()

3. Spread-Operator


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
    }
  }
}

Bewegen Sie das Array nach oben und down

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]

Konvertieren Sie das Array in eine Baumstruktur.

---

Konvertieren Sie die folgenden Daten in eine Baumstruktur

Das obige ist der detaillierte Inhalt von[Zusammenfassung] Gemeinsame Betriebsmethoden von JS-Arrays helfen Ihnen, die Entwicklungseffizienz zu verbessern!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!