Einführung in JavaScript-Array-Deduplizierungs- und -Flatteningfunktionen

const test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]

// Wenn flat keine Parameter übergibt, wird standardmäßig eine Ebene abgeflachttest.flat()
// ["a", "b", "c", "d", ["e", ["f"]], "g"]

// flat übergibt einen Integer-Parameter, der die Anzahl der abgeflachten Schichten angibt test.flat(2)
// ["a", "b", "c", "d", "e", ["f"], "g"]

// Wenn das Schlüsselwort Infinity als Parameter verwendet wird, wird es unabhängig von der Anzahl der Verschachtelungsebenen in ein eindimensionales Array test.flat(Infinity) umgewandelt.
// ["a", "b", "c", "d", "e", "f", "g"]

// Wenn Sie eine Ganzzahl <= 0 übergeben, wird das ursprüngliche Array ohne Abflachung zurückgegeben test.flat(0)
test.flat(-1)
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]

// Wenn im ursprünglichen Array freie Stellen vorhanden sind, überspringt die Methode flat() diese.
["a", "b", "c", "d",,].flat()
// ["ein", "b", "c", "d"]

Funktion flattenDeep(arr) { 
    gibt Array.isArray(arr) zurück
      ? arr.reduce( (acc, cur) => [...acc, ...flattenDeep(cur)] , [])
      : [an]
}

// Test var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
flattenDeep(test)
// ["a", "b", "c", "d", "e", "f", "g"]

Funktion flach(arr, Tiefe = 1) {
    Rücklauftiefe > 0
        ? arr.reduce((acc, cur) => {
        wenn(Array.isArray(cur)) {
            return [...acc, ...flat(aktuell, Tiefe-1)]
        }
        Rückgabewert [...acc, aktuell]
    } , [])
      :arr
}

// Test var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
// Wenn keine Parameter übergeben werden, ist die Standardabflachung eine Ebene flach (Test).
// ["a", "b", "c", "d", ["e", ["f"]], "g"]

// Übergeben Sie einen ganzzahligen Parameter, der die Anzahl der abgeflachten Ebenen angibt flat(test, 2)
// ["a", "b", "c", "d", "e", ["f"], "g"]

// Wenn das Schlüsselwort Infinity als Parameter verwendet wird, wird es unabhängig von der Anzahl der verschachtelten Ebenen in ein eindimensionales Array flat(test, Infinity) konvertiert.
// ["a", "b", "c", "d", "e", "f", "g"]

// Wenn Sie eine Ganzzahl <= 0 übergeben, wird das ursprüngliche Array ohne Abflachung zurückgegeben flat(test, 0)
flach(Test, -10)
// ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]];

// Wenn im ursprünglichen Array freie Stellen vorhanden sind, überspringt die Methode flat() diese.
var arr = ["a", "b", "c", "d",,]
flach (arr)
// ["ein", "b", "c", "d"]

Funktion flattenDeep(arr) {
  const Ergebnis = [] 
  //Array-Elemente auf den Stack kopieren. Direkte Zuweisung ändert das ursprüngliche Array const stack = [...arr]
  // Wenn der Stapel nicht leer ist, durchlaufe while (stack.length !== 0) {
    const val = stack.pop() 
    wenn (Array.isArray(val)) {
      // Wenn das Array wieder auf den Stack geschoben und um eine Ebene erweitert wird stack.push(...val) 
    } anders {
      // Wenn es kein Array ist, fügen Sie es mit der Kopfeinfügung result.unshift(val) in das Ergebnisarray ein.
    }
  }
  Ergebnis zurückgeben
}

// Test var test = ["a", ["b", "c"], ["d", ["e", ["f"]], "g"]]
flattenDeep(Tiere)
// ["a", "b", "c", "d", "e", "f", "g"]

Funktion einzigartig(arr) {
    gibt Array.from(neues Set(arr)) zurück
}
// oder var unique = arr => [...new Set(arr)]

// Testvar arr = [1, 2, 2, 3]
einzigartig(arr); // [1, 2, 3]

Funktion einzigartig(arr) {
    return arr.sort().reduce((acc, cur) => {
     wenn (acc.length === 0 || acc[acc.length - 1] !== cur) {
         acc.push(aktuell);
     }
     Rückgabe-Ac
 }, [])}
;

// Testvar arr = [1, 2, 2, 3]
einzigartig(arr); // [1, 2, 3]

Funktion einzigartig(arr) { 
    return arr.filter( (Element, Index, Array) => {
     return array.indexOf(element) === index
 })
}

// Testvar arr = [1, 2, 2, 3]
einzigartig(arr); // [1, 2, 3]