මට ජාවාස්ක්‍රිප්ට් අරාවක් ඇත:

[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]

වෙනම අභ්‍යන්තර අරා මෙවැනි එකකට ඒකාබද්ධ කරන්නේ කෙසේද:

["$6", "$12", "$25", ...]

concatඅරා ඒකාබද්ධ කිරීමට ඔබට භාවිතා කළ හැකිය :

var arrays = [
  ["$6"],
  ["$12"],
  ["$25"],
  ["$25"],
  ["$18"],
  ["$22"],
  ["$10"]
];
var merged = [].concat.apply([], arrays);

console.log(merged);

applyක්‍රමවේදය භාවිතා කිරීමෙන් concatදෙවන පරාමිතිය අරාව ලෙස ගනු ඇත, එබැවින් අවසාන පේළිය මෙයට සමාන වේ:

var merged2 = [].concat(["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]);

එහි ද මේ Array.prototype.flat()වුවද, ඔබ පෙලගැස්මක් නැතත් කිරීමට භාවිතා කළ හැකි වන (ES2019 මස හඳුන්වා දුන්) ක්රමය එය Internet Explorer හි සියලු දී අනුවාදය 11 සමඟ ආරම්භ නොව, Node.js පමණක් ලබා ගත හැකි .

const arrays = [
      ["$6"],
      ["$12"],
      ["$25"],
      ["$25"],
      ["$18"],
      ["$22"],
      ["$10"]
    ];
const merge3 = arrays.flat(1); //The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
console.log(merge3);
    

මෙන්න n- මාන අරාවක් සමතලා කිරීම සඳහා නවතම ජාවාස්ක්‍රිප්ට් අරා ක්‍රම කිහිපයක් භාවිතා කරන කෙටි ශ්‍රිතයකි.

function flatten(arr) {
  return arr.reduce(function (flat, toFlatten) {
    return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
  }, []);
}

භාවිතය:

flatten([[1, 2, 3], [4, 5]]); // [1, 2, 3, 4, 5]
flatten([[[1, [1.1]], 2, 3], [4, 5]]); // [1, 1.1, 2, 3, 4, 5]

ව්යාකූල ලෙස සැඟවුණු ක්රමයක් ඇත, එය මුල් එක විකෘති නොකර නව අරාවක් සාදයි:

var oldArray = [[1],[2,3],[4]];
var newArray = Array.prototype.concat.apply([], oldArray);
console.log(newArray); // [ 1, 2, 3, 4 ]

ජාවාස්ක්‍රිප්ට් අඩු කිරීමේ ක්‍රියාකාරිත්වය මඟින් එය වඩාත් හොඳින් කළ හැකිය.

var arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];

arrays = arrays.reduce(function(a, b){
     return a.concat(b);
}, []);

නැතහොත්, ES2015 සමඟ:

arrays = arrays.reduce((a, b) => a.concat(b), []);

js-fiddle

මොසිල්ලා ලියකියවිලි

මෙය හරියටම කිරීමට පැතලි නමින් නව දේශීය ක්‍රමයක් තිබේ.

(2019 අග වන විට, flatදැන් ECMA 2019 ප්‍රමිතියෙන් ප්‍රකාශයට පත් කර ඇති අතර core-js@3(බාබෙල්ගේ පුස්තකාලය ) එය ඔවුන්ගේ පොලිෆිල් පුස්තකාලයට ඇතුළත් කරයි )

const arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

// Flatten 2 levels deep
const arr3 = [2, 2, 5, [5, [5, [6]], 7]];
arr3.flat(2);
// [2, 2, 5, 5, 5, [6], 7];

// Flatten all levels
const arr4 = [2, 2, 5, [5, [5, [6]], 7]];
arr4.flat(Infinity);
// [2, 2, 5, 5, 5, 6, 7];

මෙහි ඇති බොහෝ පිළිතුරු විශාල (උදා: මූලද්‍රව්‍ය 200 000) අරා මත ක්‍රියා නොකරයි, ඒවා එසේ වුවද ඒවා මන්දගාමී වේ. polkovnikov.ph ගේ පිළිතුරට හොඳම කාර්ය සාධනය ඇත, නමුත් එය ගැඹුරු සමතලා කිරීම සඳහා ක්‍රියා නොකරයි.

වේගවත්ම විසඳුම මෙන්න , එය විවිධ මට්ටම්වල කූඩු සහිත අරා වලද ක්‍රියා කරයි :

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

උදාහරණ

විශාල අරා

flatten(Array(200000).fill([1]));

එය විශාල අරා හසුරුවයි. මගේ පරිගණකයේ මෙම කේතය ක්‍රියාත්මක කිරීමට එම්එස් 14 ක් පමණ ගත වේ.

කැදැලි අරා

flatten(Array(2).fill(Array(2).fill(Array(2).fill([1]))));

එය කැදැලි අරා සමඟ ක්‍රියා කරයි. මෙම කේතය නිපදවයි [1, 1, 1, 1, 1, 1, 1, 1].

විවිධ මට්ටම්වල කැදැලි සහිත අරා

flatten([1, [1], [[1]]]);

මේ වගේ අරා සමතලා කිරීම සම්බන්ධයෙන් එයට කිසිදු ගැටළුවක් නොමැත.

යාවත්කාලීන කිරීම: මෙම විසඳුම විශාල අරා සමඟ ක්‍රියා නොකරන බව පෙනී ගියේය. එය ඔබ වඩා හොඳ වේගවත් විසඳුමක් සොයමින් සිටී, මෙම පිළිතුර බලන්න .

function flatten(arr) {
  return [].concat(...arr)
}

හුදෙක් විස්තාරණය arrවී එය තර්ක ලෙස සම්මත කරයි, එය concat()සියලු අරා එකකට ඒකාබද්ධ කරයි. එය සමාන වේ [].concat.apply([], arr).

ගැඹුරු සමතලා කිරීම සඳහා ඔබට මෙය උත්සාහ කළ හැකිය:

function deepFlatten(arr) {
  return flatten(           // return shalowly flattened array
    arr.map(x=>             // with each x in array
      Array.isArray(x)      // is x an array?
        ? deepFlatten(x)    // if yes, return deeply flattened x
        : x                 // if no, return just x
    )
  )
}

JSBin හි නිරූපණය බලන්න .

මෙම පිළිතුර සඳහා භාවිතා කරන ලද ECMAScript 6 මූලද්‍රව්‍ය සඳහා යොමුව:

• පැතිරුණු ක්‍රියාකරු
• ඊතල කාර්යයන්

පැති සටහන: වැනි ක්‍රම find()සහ ඊතල ක්‍රියාකාරිත්වයන් සියලු බ්‍රව්සර් මගින් සහය නොදක්වයි, නමුත් එයින් අදහස් කරන්නේ ඔබට දැන් මෙම විශේෂාංග භාවිතා කළ නොහැකි බවයි. බාබෙල් භාවිතා කරන්න - එය ES6 කේතය ES5 බවට පරිවර්තනය කරයි.

ඔබට අන්ඩර්ස්කෝර් භාවිතා කළ හැකිය :

var x = [[1], [2], [3, 4]];

_.flatten(x); // => [1, 2, 3, 4]

සාමාන්‍ය ක්‍රියා පටිපාටිවලින් අදහස් කරන්නේ අපට නිශ්චිත හැසිරීමක් භාවිතා කිරීමට අවශ්‍ය සෑම අවස්ථාවකම සංකීර්ණත්වය නැවත ලිවිය යුතු නැති බවයි.

concatMap(හෝ flatMap) මෙම තත්වය තුළ අපට අවශ්‍ය වන්නේ හරියටම ය.

// concat :: ([a],[a]) -> [a]
const concat = (xs,ys) =>
  xs.concat (ys)

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs =>
  xs.map(f).reduce(concat, [])

// id :: a -> a
const id = x =>
  x

// flatten :: [[a]] -> [a]
const flatten =
  concatMap (id)

// your sample data
const data =
  [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]

console.log (flatten (data))

දුරදක්නා නුවණ

ඔව්, ඔබ එය නිවැරදිව අනුමාන කළා, එය එක් මට්ටමක් පමණක් සමතලා කරයි, එය හරියටම ක්‍රියා කළ යුතු ආකාරයයි

මේ වගේ දත්ත කට්ටලයක් ගැන සිතන්න

// Player :: (String, Number) -> Player
const Player = (name,number) =>
  [ name, number ]

// team :: ( . Player) -> Team
const Team = (...players) =>
  players

// Game :: (Team, Team) -> Game
const Game = (teamA, teamB) =>
  [ teamA, teamB ]

// sample data
const teamA =
  Team (Player ('bob', 5), Player ('alice', 6))

const teamB =
  Team (Player ('ricky', 4), Player ('julian', 2))

const game =
  Game (teamA, teamB)

console.log (game)
// [ [ [ 'bob', 5 ], [ 'alice', 6 ] ],
//   [ [ 'ricky', 4 ], [ 'julian', 2 ] ] ]

හරි, දැන් කියන්න අපට සහභාගී වන සියලුම ක්‍රීඩකයින් පෙන්වන ලැයිස්තුවක් මුද්‍රණය කිරීමට අවශ්‍ය බව game…

const gamePlayers = game =>
  flatten (game)

gamePlayers (game)
// => [ [ 'bob', 5 ], [ 'alice', 6 ], [ 'ricky', 4 ], [ 'julian', 2 ] ]

අපගේ flattenක්‍රියා පටිපාටිය කැදැලි අරා ද සමතලා කර ඇත්නම් , අපි මෙම කසළ ප්‍රති result ලයෙන් අවසන් වෙමු.

const gamePlayers = game =>
  badGenericFlatten(game)

gamePlayers (game)
// => [ 'bob', 5, 'alice', 6, 'ricky', 4, 'julian', 2 ]

රෝලින් ගැඹුරු, බබා

සමහර විට ඔබට කැදැලි අරා සමතලා කිරීමට අවශ්‍ය නොවන බව නොකියයි - එය සුපුරුදු හැසිරීම නොවිය යුතුය.

අපට deepFlattenපහසුවෙන් ක්‍රියා පටිපාටියක් කළ හැකිය…

// concat :: ([a],[a]) -> [a]
const concat = (xs,ys) =>
  xs.concat (ys)

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs =>
  xs.map(f).reduce(concat, [])

// id :: a -> a
const id = x =>
  x

// flatten :: [[a]] -> [a]
const flatten =
  concatMap (id)

// deepFlatten :: [[a]] -> [a]
const deepFlatten =
  concatMap (x =>
    Array.isArray (x) ? deepFlatten (x) : x)

// your sample data
const data =
  [0, [1, [2, [3, [4, 5], 6]]], [7, [8]], 9]

console.log (flatten (data))
// [ 0, 1, [ 2, [ 3, [ 4, 5 ], 6 ] ], 7, [ 8 ], 9 ]

console.log (deepFlatten (data))
// [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

එතන. දැන් ඔබට සෑම රැකියාවක් සඳහාම මෙවලමක් තිබේ - එකක් කැදැල්ල එක් මට්ටමක තබා flattenගැනීම සඳහා වන අතර එක් කැදැල්ලක් මකා දැමීම සඳහා එකක් deepFlatten.

සමහර විට ඔබට එය ඇමතිය හැකිය obliterateහෝ nukeඔබ නමට අකමැති නම් deepFlatten.

දෙවරක් නැවත කියන්න එපා!

ඇත්ත වශයෙන්ම ඉහත ක්‍රියාත්මක කිරීම් දක්ෂ හා සංක්ෂිප්ත ය, නමුත් .mapඇමතුමකින් පසුව ඇමතුමක් භාවිතා කිරීමෙන් .reduceඅදහස් කරන්නේ අප අවශ්‍ය ප්‍රමාණයට වඩා වැඩි වාර ගණනක් කරන බවයි

මා අමතන්නේ mapReduceවිශ්වාසදායක සංයෝජකයක් භාවිතා කිරීම පුනරාවර්තනයන් අවම මට්ටමක තබා ගැනීමට උපකාරී වේ; එය සිතියම්කරණ ශ්‍රිතයක් m :: a -> b, අඩු කිරීමේ ශ්‍රිතයක් r :: (b,a) ->bගෙන නව අඩු කිරීමේ ශ්‍රිතයක් ලබා දෙයි - මෙම සංයෝජකය සම්ප්‍රේෂකයන්ගේ හදවතේ ඇත ; ඔබ කැමති නම්, මම ඔවුන් ගැන වෙනත් පිළිතුරු ලියා ඇත

// mapReduce = (a -> b, (b,a) -> b, (b,a) -> b)
const mapReduce = (m,r) =>
  (acc,x) => r (acc, m (x))

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs =>
  xs.reduce (mapReduce (f, concat), [])

// concat :: ([a],[a]) -> [a]
const concat = (xs,ys) =>
  xs.concat (ys)

// id :: a -> a
const id = x =>
  x

// flatten :: [[a]] -> [a]
const flatten =
  concatMap (id)
  
// deepFlatten :: [[a]] -> [a]
const deepFlatten =
  concatMap (x =>
    Array.isArray (x) ? deepFlatten (x) : x)

// your sample data
const data =
  [ [ [ 1, 2 ],
      [ 3, 4 ] ],
    [ [ 5, 6 ],
      [ 7, 8 ] ] ]

console.log (flatten (data))
// [ [ 1. 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ]

console.log (deepFlatten (data))
// [ 1, 2, 3, 4, 5, 6, 7, 8 ]

ඔබේ අරාවෙහි අරාව නොවන මූලද්‍රව්‍ය කිහිපයක් තිබිය හැකි විට වඩාත් පොදු අවස්ථාව සඳහා විසඳුමක්.

function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i<a.length; i++){
        if(a[i].constructor == Array){
            r.concat(flattenArrayOfArrays(a[i], r));
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

තනි මූලද්‍රව්‍ය අරා සමූහයක් සමතලා කිරීම සඳහා, ඔබට පුස්තකාලයක් ආයාත කිරීමට අවශ්‍ය නැත, සරල පුඩුවක් යනු සරලම හා කාර්යක්ෂම විසඳුමයි:

for (var i = 0; i < a.length; i++) {
  a[i] = a[i][0];
}

පහත් ඡන්ද දායකයින්ට: කරුණාකර ප්‍රශ්නය කියවන්න, එය ඔබගේ වෙනස් ගැටළුවට නොගැලපෙන නිසා පහත් කොට සලකන්න එපා. මෙම විසඳුම අසන ලද ප්‍රශ්නය සඳහා වේගවත්ම හා සරලම වේ.

reduce(callback[, initialValue])ක්‍රමවේදය භාවිතා කිරීම ගැන කුමක් කිව හැකිද?JavaScript 1.8

list.reduce((p,n) => p.concat(n),[]);

වැඩේ කරයි.

ක්‍රියාකාරී ශෛලියේ තවත් ECMAScript 6 විසඳුමක්:

ශ්‍රිතයක් ප්‍රකාශ කරන්න:

const flatten = arr => arr.reduce(
  (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
);

එය භාවිතා කරන්න:

flatten( [1, [2,3], [4,[5,[6]]]] ) // -> [1,2,3,4,5,6]

 const flatten = arr => arr.reduce(
         (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
       );


console.log( flatten([1, [2,3], [4,[5],[6,[7,8,9],10],11],[12],13]) )

නවීන බ්‍රව්සර්වල අවසාන නිකුතුවල ඇති Array.prototype.flat () (ES6 සඳහා වන යෝජනාව ) ස්වදේශීය ශ්‍රිතයක් ද සලකා බලන්න . Comments (Ван) සහ @ (මාර්ක් අමරි) ට ස්තූතියි එය අදහස් දැක්වීමේදී සඳහන් කර ඇත.

මෙම flatඋත්සවය හා සමාන මාලාවක් කුරුල්ලන් ලැග සිටින, අපේක්ෂිත ගැඹුර නියම කරමින්, එක් පරාමිතිය ඇත 1පෙරනිමියෙන්.

[1, 2, [3, 4]].flat();                  // -> [1, 2, 3, 4]

[1, 2, [3, 4, [5, 6]]].flat();          // -> [1, 2, 3, 4, [5, 6]]

[1, 2, [3, 4, [5, 6]]].flat(2);         // -> [1, 2, 3, 4, 5, 6]

[1, 2, [3, 4, [5, 6]]].flat(Infinity);  // -> [1, 2, 3, 4, 5, 6]

let arr = [1, 2, [3, 4]];

console.log( arr.flat() );

arr =  [1, 2, [3, 4, [5, 6]]];

console.log( arr.flat() );
console.log( arr.flat(1) );
console.log( arr.flat(2) );
console.log( arr.flat(Infinity) );

const common = arr.reduce((a, b) => [...a, ...b], [])

කරුණාකර සලකන්න: විට Function.prototype.apply( [].concat.apply([], arrays)) හෝ පැතිරීම ක්රියාකරු ( [].concat(...arrays)උත්සවයකට සෑම තර්කය අඩුක්කුව ගබඩා කර ඇති නිසා මාලාවක් නැතත් කිරීම සඳහා) භාවිතා කරනු ඇත, යන දෙකම හැකි හේතුවක් අඩුක්කුව විශාල පෙලගැස්මක් සඳහා උතුරා යන.

එකිනෙකාට එරෙහිව වඩාත්ම වැදගත් අවශ්‍යතා කිරා මැන බලන ක්‍රියාකාරී ශෛලියේ සිරස්-ආරක්ෂිත ක්‍රියාත්මක කිරීමක් මෙන්න:

• නැවත භාවිතා කිරීමේ හැකියාව
• කියවීමේ හැකියාව
• සංක්ෂිප්තභාවය
• කාර්ය සාධනය

// small, reusable auxiliary functions:

const foldl = f => acc => xs => xs.reduce(uncurry(f), acc); // aka reduce

const uncurry = f => (a, b) => f(a) (b);

const concat = xs => y => xs.concat(y);


// the actual function to flatten an array - a self-explanatory one-line:

const flatten = xs => foldl(concat) ([]) (xs);

// arbitrary array sizes (until the heap blows up :D)

const xs = [[1,2,3],[4,5,6],[7,8,9]];

console.log(flatten(xs));


// Deriving a recursive solution for deeply nested arrays is trivially now


// yet more small, reusable auxiliary functions:

const map = f => xs => xs.map(apply(f));

const apply = f => a => f(a);

const isArray = Array.isArray;


// the derived recursive function:

const flattenr = xs => flatten(map(x => isArray(x) ? flattenr(x) : x) (xs));

const ys = [1,[2,[3,[4,[5],6,],7],8],9];

console.log(flattenr(ys));

ව්‍යංජන ස්වරූපයෙන්, ක්‍රියාකාරී සංයුතියෙන් සහ ඉහළ පෙළේ ශ්‍රිත වලින් කුඩා ඊතල ශ්‍රිතවලට ඔබ පුරුදු වූ වහාම මෙම කේතය ගද්‍ය වැනි කියවනු ලැබේ. ක්‍රමලේඛනය යනු හුදෙක් අපේක්ෂිත පරිදි ක්‍රියා කරන කුඩා ගොඩනැඟිලි කොටස් එකට එකතු කිරීම පමණි.

ES6 One Line පැතලි

බලන්න lodash නැතත් , underscore නැතත් (නොගැඹුරු true)

function flatten(arr) {
  return arr.reduce((acc, e) => acc.concat(e), []);
}

හෝ

function flatten(arr) {
  return [].concat.apply([], arr);
}

සමඟ පරීක්ෂා කර ඇත

test('already flatted', () => {
  expect(flatten([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});

test('flats first level', () => {
  expect(flatten([1, [2, [3, [4]], 5]])).toEqual([1, 2, [3, [4]], 5]);
});

ES6 එක් පේළියක් ගැඹුරු සමතලා වේ

ලොඩාෂ් පැතලි ඩීප් බලන්න , අවධාරනය කරන්න පැතලි කරන්න

function flattenDeep(arr) {
  return arr.reduce((acc, e) => Array.isArray(e) ? acc.concat(flattenDeep(e)) : acc.concat(e), []);
}

සමඟ පරීක්ෂා කර ඇත

test('already flatted', () => {
  expect(flattenDeep([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});

test('flats', () => {
  expect(flattenDeep([1, [2, [3, [4]], 5]])).toEqual([1, 2, 3, 4, 5]);
});

ඔබට භාවිතා කළ හැකි Array.flat()සමග Infinityපිළිතුරු පැතැලිව මාලාවක් කිසිදු ගැඹුරක් සඳහා.

var arr = [ [1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1,2,3,4]]], [[1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1,2,3,4]]]] ];

let flatten = arr.flat(Infinity)

console.log(flatten)

බ්‍රව්සර් අනුකූලතාව සඳහා මෙහි පරීක්ෂා කරන්න

ඔබට ඇත්තේ 1 නූල් මූලද්‍රව්‍යයක් සහිත අරා පමණි:

[["$6"], ["$12"], ["$25"], ["$25"]].join(',').split(',');

වැඩේ කරයි. ඔබේ කේත උදාහරණයට විශේෂයෙන් ගැලපෙන Bt.

හස්කෙලෙස්ක් ප්රවේශය

function flatArray([x,...xs]){
  return x ? [...Array.isArray(x) ? flatArray(x) : [x], ...flatArray(xs)] : [];
}

var na = [[1,2],[3,[4,5]],[6,7,[[[8],9]]],10];
    fa = flatArray(na);
console.log(fa);

ES6 මාර්ගය:

const flatten = arr => arr.reduce((acc, next) => acc.concat(Array.isArray(next) ? flatten(next) : next), [])

const a = [1, [2, [3, [4, [5]]]]]
console.log(flatten(a))

flattenN-times කැදැලි අරා සඳහා ES3 වැටීම සමඟ ක්‍රියා කිරීමට ES5 මාර්ගය :

var flatten = (function() {
  if (!!Array.prototype.reduce && !!Array.isArray) {
    return function(array) {
      return array.reduce(function(prev, next) {
        return prev.concat(Array.isArray(next) ? flatten(next) : next);
      }, []);
    };
  } else {
    return function(array) {
      var arr = [];
      var i = 0;
      var len = array.length;
      var target;

      for (; i < len; i++) {
        target = array[i];
        arr = arr.concat(
          (Object.prototype.toString.call(target) === '[object Array]') ? flatten(target) : target
        );
      }

      return arr;
    };
  }
}());

var a = [1, [2, [3, [4, [5]]]]];
console.log(flatten(a));

ඔබට නව Array.Flat()ක්‍රමය ද උත්සාහ කළ හැකිය . එය පහත පරිදි ක්‍රියා කරයි:

let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]].flat()

console.log(arr);

මෙම flat()ක්‍රමය මඟින් සියලු උප-අරා මූලද්‍රව්‍යයන් ගැඹුරට 1 ස්ථරය දක්වා පුනරාවර්තන ලෙස නව අරා නිර්මාණය කරයි (එනම් අරා ඇතුළත අරා)

ඔබට ත්‍රිමාන හෝ ඊටත් වඩා ඉහළ මාන අරා සමතලා කිරීමට අවශ්‍ය නම් ඔබ පැතලි ක්‍රමය කිහිප වතාවක් අමතන්න. උදාහරණයක් ලෙස (මානයන් 3):

let arr = [1,2,[3,4,[5,6]]].flat().flat().flat();

console.log(arr);

පරෙස්සම් වෙන්න!

Array.Flat()ක්‍රමය සාපේක්ෂව නව ය. වැනි පැරණි බ්‍රව්සර් ක්‍රමය ක්‍රියාත්මක නොකරන්නට ඇත. සියලුම බ්‍රව්සර්වල වැඩ කිරීමට ඔබට කේතයක් අවශ්‍ය නම්, ඔබේ ජේඑස් පැරණි අනුවාදයකට සම්ප්‍රේෂණය කළ යුතුය. වත්මන් බ්‍රව්සර් අනුකූලතාව සඳහා MD වෙබ් ලියකියවිලි පරීක්ෂා කරන්න.

var arrays = [["a"], ["b", "c"]];
Array.prototype.concat.apply([], arrays);

// gives ["a", "b", "c"]

(මම මෙය ලියන්නේ වෙනම පිළිතුරක් ලෙසයි, ඩැන්බයර්ගේ අදහස් මත පදනම්ව.)

අවකාශ-කාර්යක්ෂම උත්පාදක ශ්‍රිතයක් මම නිර්දේශ කරමි :

function* flatten(arr) {
  if (!Array.isArray(arr)) yield arr;
  else for (let el of arr) yield* flatten(el);
}

// Example:
console.log(...flatten([1,[2,[3,[4]]]])); // 1 2 3 4

අවශ්‍ය නම්, සමතලා කළ අගයන් පෙළක් පහත පරිදි සාදන්න:

let flattened = [...flatten([1,[2,[3,[4]]]])]; // [1, 2, 3, 4]

මම මුළු අරාවම නූලක් බවට පරිවර්තනය කරමි, නමුත් වෙනත් පිළිතුරු මෙන් නොව, අනවශ්‍ය ප්‍රති .ලයක් ලබා JSON.stringifyදෙන toString()ක්‍රමය භාවිතා කිරීම සහ භාවිතා නොකිරීම .

එම JSON.stringifyප්‍රතිදානය සමඟ ඉතිරිව ඇත්තේ සියලු වරහන් ඉවත් කිරීම, ප්‍රති result ලය ආරම්භක සහ අවසන් වරහන් සමඟ නැවත ඔතා, ප්‍රති JSON.parsestring ලය නැවත “ජීවයට” ගෙන ඒමයි.

• කිසිදු වේග පිරිවැයකින් තොරව අනන්ත කැදැලි අරා හැසිරවිය හැකිය.
• කොමාව අඩංගු නූල් වන අරා අයිතම නිවැරදිව හැසිරවිය හැකිය.

var arr = ["abc",[[[6]]],["3,4"],"2"];

var s = "[" + JSON.stringify(arr).replace(/\[|]/g,'') +"]";
var flattened = JSON.parse(s);

console.log(flattened)

කේත ස්නිපටය ධාවනය කරන්නප්‍රති .ල සඟවන්න

ස්නිපටය පුළුල් කරන්න

• බහුමානීය නූල් / අංක සඳහා පමණි (වස්තු නොවේ)

පැතිරීමේ ක්‍රියාකරු භාවිතා කිරීම:

const input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];
const output = [].concat(...input);
console.log(output); // --> ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

එය අමාරු නැත, අරා හරහා නැවත ඒවා ඒකාබද්ධ කරන්න:

var result = [], input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"]];

for (var i = 0; i < input.length; ++i) {
    result = result.concat(input[i]);
}

මෙය පුනරාවර්තනය සඳහා රැකියාවක් සේ පෙනේ!

• කැදැල්ලේ විවිධ මට්ටම් හසුරුවයි
• හිස් අරා සහ අරා නොවන පරාමිතීන් හසුරුවයි
• විකෘතියක් නොමැත
• නවීන බ්‍රව්සර් විශේෂාංග මත රඳා නොපවතී

කේතය:

var flatten = function(toFlatten) {
  var isArray = Object.prototype.toString.call(toFlatten) === '[object Array]';

  if (isArray && toFlatten.length > 0) {
    var head = toFlatten[0];
    var tail = toFlatten.slice(1);

    return flatten(head).concat(flatten(tail));
  } else {
    return [].concat(toFlatten);
  }
};

භාවිතය:

flatten([1,[2,3],4,[[5,6],7]]);
// Result: [1, 2, 3, 4, 5, 6, 7] 

මම එය පුනරාවර්තනය සහ වසා දැමීම් භාවිතා කර ඇත

function flatten(arr) {

  var temp = [];

  function recursiveFlatten(arr) { 
    for(var i = 0; i < arr.length; i++) {
      if(Array.isArray(arr[i])) {
        recursiveFlatten(arr[i]);
      } else {
        temp.push(arr[i]);
      }
    }
  }
  recursiveFlatten(arr);
  return temp;
}

මම පසුගිය දින ඊඑස් 6 උත්පාදක යන්ත්රය සමඟ විකාරරූපී වෙමින් මෙම සාරාංශය ලිවීය . එහි අඩංගු ...

function flatten(arrayOfArrays=[]){
  function* flatgen() {
    for( let item of arrayOfArrays ) {
      if ( Array.isArray( item )) {
        yield* flatten(item)
      } else {
        yield item
      }
    }
  }

  return [...flatgen()];
}

var flatArray = flatten([[1, [4]],[2],[3]]);
console.log(flatArray);

මූලික වශයෙන් මම උත්පාදක යන්ත්‍රයක් නිර්මාණය කරන්නේ මුල් ආදාන අරාව හරහා ලූපයක් වන අතර, එය අරාවක් සොයා ගන්නේ නම් එය අභ්‍යන්තර අරා අඛණ්ඩව සමතලා කිරීම සඳහා පුනරාවර්තනය සමඟ ඒකාබද්ධව අස්වැන්න * ක්‍රියාකරු භාවිතා කරයි . අයිතමය අරාව නොවේ නම් එය තනි අයිතමය ලබා දෙයි . ඉන්පසු ES6 Spread operator (aka splat operator) භාවිතා කරමින් මම උත්පාදක යන්ත්රය නව අරා උදාහරණයකට සමතලා කරමි.

මම මෙහි ක්‍රියාකාරිත්වය පරීක්ෂා කර නැත, නමුත් එය ජනක යන්ත්‍ර සහ අස්වැන්න * ක්‍රියාකරු භාවිතා කිරීම සඳහා කදිම සරල උදාහරණයක් බව මම සිතමි.

නමුත් නැවතත්, මම ගොන් වැඩක් කළෙමි, එබැවින් මෙය කිරීමට තවත් ක්‍රියාකාරී ක්‍රම ඇති බව මට විශ්වාසයි.

ලොඩාෂ් නොමැතිව හොඳම විසඳුම

let flatten = arr => [].concat.apply([], arr.map(item => Array.isArray(item) ? flatten(item) : item))