javascript - attribute - img html title

¿Empalma una matriz a la mitad, sin importar el tamaño?

Question

Tengo una matriz que me gustaría dividir por la mitad. Así que puedo colocar la primera mitad en el lado derecho y la segunda mitad en el lado izquierdo.

He usado la función de empalme antes:

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

Pero no estoy seguro de cómo dividirlo en dos, sin importar el tamaño, ya que la matriz cambiará de tamaño dinámicamente.

Answer 1

Evitar mutaciones

Si necesita evitar las mutaciones, por ejemplo, si tiene que dividir una matriz para reaccionar, no desea mutar el original o podría provocar un comportamiento muy extraño en su aplicación.

Use Slice

Puedes evitar esto usando slice lugar de splice

Ejemplo

let yourArray = props.someArray;
let halfWayThough = Math.floor(yourArray.length / 2)

let arrayFirstHalf = yourArray.slice(0, halfWayThough);
let arraySecondHalf = yourArray.slice(halfWayThough, yourArray.length);

Answer 2

Echa un vistazo a la chunk lodash:

var myArray = [1, 2, 3, 4, 5, 6, 7, 8];
var pivot = _.ceil(myArray.length / 2);
// => 4
console.log(_.chunk(myArray, pivot));

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

Answer 3

Esta es una función divertida para evitar mutaciones con opciones:

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

Y puedes llamarlo con una opción alternativa:

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 4

Puede simplemente referirse a la longitud de la matriz:

var leftSide = arrayName.splice(0, Math.floor(arrayName.length / 2));

Como .splice() realidad elimina elementos de la matriz de origen, los elementos restantes de la matriz serán los elementos de la mitad derecha.

Math.floor() se redondeará hacia abajo para dar al lado izquierdo uno menos que al lado derecho para longitudes impares. Podría usar Math.ceil() si desea redondear hacia arriba para darle al lado izquierdo uno más que al lado derecho cuando la longitud es impar.

Answer 5

Si desea que el tamaño de la matriz se mantenga igual, solo necesita alternar en qué matriz escribe (por ejemplo, alternar llamadas .push en las matrices). ¿Por qué no crea 2 matrices por adelantado?

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

Después de hacer eso, si quieres mantener los 2 arreglos del mismo tamaño, alterna entre

leftHalf.push(newElement);

y

yourArray.push(newElement1);

Answer 6

let leftSide = myArray.splice(0, Math.ceil(myArray.length / 2));
//The right side is stored in "myArray"

Por ejemplo:

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

Más información: splice en los documentos MDN.

Tenga en cuenta que esto modifica su matriz original. Si desea conservar la matriz original, clone la matriz y luego use el empalme en la matriz clonada. De una pregunta de SO sobre los arreglos de clonación:

Ha habido un subproceso de BENCHMARKS que proporciona la siguiente información:

• para los navegadores con parpadeo, slice () es el método más rápido , concat () es un poco más lento, y mientras que el bucle es 2.4x más lento.

• para otros navegadores, si bien loop es el método más rápido , ya que esos navegadores no tienen optimizaciones internas para slice y concat.

//Fastest for Blink browsers (Opera/Chromium):
let clonedArray = originalArray.slice();
//For other browsers:
let clonedArray = [];
var i = myArray.length;
while (i--) clonedArray[i] = myArray[i];

Answer 7

var half_length = Math.ceil(arrayName.length / 2);    

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

Editado el código siguiendo el comentario de @Lightness Races in Orbit.