避免突变

Question

我有一个我希望分成两半的数组。所以我可以将前半部分放在右侧，将后半部分放在左侧。

我之前使用过拼接功能：

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

但不知道如何将它拼接成两半，无论大小，因为数组的大小会动态变化。

Answer 1

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

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

编辑了Orbit评论中的@Lightness Races后面的代码

Answer 2

避免突变

如果您需要避免突变，例如，如果您必须在反应中拆分数组，则不想改变原始数据，否则可能会在您的应用中导致一些非常奇怪的行为。

使用切片

您可以使用slice代替splice

来解决此问题

实施例

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 3

您可以简单地引用数组的长度：

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

由于.splice()实际上从源数组中删除了元素，因此数组中的其余元素将是右半部分的元素。

Math.floor()将向下舍入，使左侧比奇数长度小一侧。你可以使用Math.ceil()，如果你想要向上舍入，当长度为奇数时，左侧比左侧更多。

Answer 4

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

例如：

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

更多信息： splice in the MDN docs

请注意，这会修改原始数组。如果要保留原始数组，请克隆该数组，然后在克隆数组上使用splice。来自SO question克隆数组：

有一个huuuge BENCHMARKS主题，提供以下信息：



对于blink浏览器slice（）是最快的方法，concat（）有点慢，而while循环慢2.4倍。



对于其他浏览器而while循环是最快的方法，因为这些浏览器没有切片和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 5

看看lodash chunk：

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 6

对于避免突变，这是一个有趣的功能选项：

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

您可以使用交替选项来调用它：

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 7

如果你希望数组的大小保持相等，你只需要替换你写入的数组（例如，在数组上交替.push调用）。你为什么不预先创建2个阵列？

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

如果你想保持2个数组在

之间交替相同的大小，那么就这样做了

leftHalf.push(newElement);

和

yourArray.push(newElement1);

Answer 8

您还可以使用ES6销毁和 slice（），这样原始数组就不会发生突变。

   const yourArray;
   let leftSide,rightSide;
   const m = Math.floor(yourArray.length/2);
   const [leftSide,rightSide] = [yourArray.slice(0,m), yourArray.slice(m,yourArray.length)];
   console.log(leftSide);
   console.log(rightSide);

Answer 9

另一种选择，但您可能不应该使用它。

[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 10

您可以使用过滤器作为解决该问题的另一种方法。

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

无论大小如何，将阵列拼成两半？

10 个答案:

避免突变

使用切片

实施例