Couper un tableau en deux, peu importe sa taille?

Question

Je dispose d'un tableau que je voudrais diviser en deux. Ainsi, je peux positionner la première moitié du côté droit et la deuxième moitié du côté gauche.

J'ai déjà utilisé la fonction splice :

var leftSide = arrayName.splice(0,2);

Mais je ne suis pas sûr comment le diviser en deux peu importe sa taille, car le tableau changera de taille dynamiquement.

Answer 1

let leftSide = myArray.splice(0, Math.ceil(myArray.length / 2));
//Le côté droit est stocké dans "myArray"

Par exemple :

let letters = ['a', 'b', 'c', 'd', 'e'];
let leftSide = letters.splice(0, Math.ceil(letters.length /2));
let rightSide = letters;
console.log(leftSide);
=> ['a', 'b', 'c']
console.log(rightSide);
=> ['d', 'e']

Plus d'informations : splice dans la documentation de MDN

---

Remarque que cela modifie votre tableau d'origine. Si vous souhaitez conserver le tableau d'origine, clonez le tableau, puis utilisez splice sur le tableau cloné. D'après une question SO sur le clonage des tableaux :

Il y a eu un immense fil de BENCHMARKS, fournissant les informations suivantes :

• pour les navigateurs Blink slice() est la méthode la plus rapide, concat() est légèrement plus lent, et la boucle while est 2,4 fois plus lente.

• pour les autres navigateurs la boucle while est la méthode la plus rapide, car ces navigateurs n'ont pas d'optimisations internes pour slice et concat.

//Le plus rapide pour les navigateurs Blink (Opera/Chromium) :
let clonedArray = originalArray.slice();
//Pour les autres navigateurs :
let clonedArray = [];
var i = myArray.length;
while (i--) clonedArray[i] = myArray[i];

Answer 2

Ceci est une fonction amusante pour Éviter les mutations avec des options:

function splitArray({ alternate, array }) {
  const halfIndex = Math.ceil(array.length / 2) - 1;
  let firstArray = true;
  return array.reduce((res, item, index) => {
    if (firstArray) {
      res[0].push(item);
      if (alternate || index >= halfIndex) {
        firstArray = false;
      }
    } else {
      res[1].push(item);
      if (alternate) {
        firstArray = true;
      }
    }
    return res;
  }, [[], []]);
}

Et vous pouvez l'appeler avec une option alternée:

const myArray = [1,2,3,4,5,6,7,8];
const splitAlternate = splitArray({ alternate: true, array: myArray });
const splitNoAlternate = splitArray({ alternate: false, array: myArray });

console.log(myArray);
console.log(splitAlternate);
console.log(splitNoAlternate);

Answer 3

Si vous voulez que la taille du tableau reste égale, il vous suffit d'alterner lequel des tableaux vous écrivez (par exemple, alternez les appels .push sur les tableaux).. Pourquoi ne créez-vous pas simplement 2 tableaux au départ?

var lelftHalf = yourArray.splice(0,arrayName.length / 2);

Après avoir fait cela, si vous souhaitez que les 2 tableaux restent de la même taille, alternez entre

leftHalf.push(newElement);

et

yourArray.push(newElement1);

Answer 4

Une autre alternative, vous ne devriez probablement pas l'utiliser cependant.

[1,2,3,4,5,6,7,8,9,10].reduce(([l, r], cur, i, self) => i < self.length / 2 ? [[...l, cur], r] : [l, [...r, cur]], [[], []])

Answer 5

Vous pouvez utiliser filter comme une autre façon disponible de le résoudre.

let arr = [1,2,3,4,5,6];
let half = arr.filter((el, i) => i >= arr.length/2);