JavaScript - String.split() 但对于数组？

Question

假设我有这个字符串数组（它们是 HTML 元素，但我们可以使用字符串来保持简单）：

["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"]

我需要一种快速的方法来将此数组拆分为 "d"。有点像String.split()，除了数组。最终结果应该是这样的：

[["something", "else", "and"], ["more", "things", "in", "the"], ["array", "etc"]]

是否有任何简单的单行代码？也许JS内置了一个函数，我只是想念它？

Answer 1

如果是你想要的单线，那么你去：

var myArray = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"];

const result = myArray.reduce((a, c) => c === "d" ? (a.arr[++a.i] = []) && a : a.arr[a.i].push(c) && a, {arr: [[]], i: 0}).arr;

console.log(result);

Answer 2

一种选择是用空格连接，然后用' d ' 分割，然后用空格分割每个子数组：

const input = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"];
const output = input
  .join(' ')
  .split(' d ')
  .map(str => str.split(' '));
console.log(output);

或者，在不加入的情况下，找出每个d 和slice 在ds 周围输入的每个部分的索引：

const input = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"];
const dIndicies = input.reduce((a, item, i) => {
  if (item === 'd') a.push(i);
  return a;
}, []);
const output = dIndicies.reduce((a, dIndex, i, arr) => {
  const nextDIndex = arr[i + 1];
  a.push(input.slice(dIndex + 1, nextDIndex));
  return a;
}, [input.slice(0, dIndicies[0] - 1)]);
console.log(output);

Answer 3

let myArray = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"];
let splitArray = [],
    tempArray = [];
myArray.forEach((ele, index) => {
    if(ele !== 'd') {
      tempArray.push(ele);
    }
    if(ele === 'd' || index === myArray.length - 1) {
      splitArray.push(tempArray);
      tempArray = []; 
    }
})

console.log(': ', splitArray);

Answer 4

一个简单的forEach 方法就足够了。

var arr = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"];
var result = [], temp = [];

arr.forEach(function(elem, index){
    elem !=='d' ? temp.push(elem) : (result.push(temp), temp = []);
    index==arr.length-1 && (result.push(temp));
});

console.log(result)

Answer 5

为了回答您的问题，没有想到任何简洁的单行代码，但是您可以通过迭代您的值并且如果单词不是 @987654321 只需几行代码即可完成您想要的@存储它；如果是，则创建一个新数组来保存下一个非“d”值：

const words = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"]

let grouped = words.reduce((response,word)=>{
  if (word!=='d')
    response[response.length-1].push(word)
  else
    response[response.length]=[]
  return response
},[[]])

console.log(grouped)

Answer 6

使用 reduce 从一个累加器开始，该累加器有一个包含空数组的数组。如果当前项是拆分值，则在末尾添加一个额外的空数组，否则将最后一个数组与当前项展开。

const arr = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"];

const splitArray = (array, val) =>
  array && array.length
    ? array.reduce(
        (results, item) =>
          item === val
            ? [...results, []]
            : [...results.filter((_, i) => i < results.length - 1), [...results[results.length - 1], item]],
        [[]]
      )
    : array;
  
  
console.log(splitArray(arr, 'd'));

Answer 7

您可以使用以下代码创建一个非常优雅的递归函数：

let arr = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"]

const spliton = (v, arr, i = arr.indexOf(v)) => (i < 0) 
    ? [arr]
    : [arr.slice(0, i), ...spliton(v, arr.slice(i+1))]


console.log(spliton('d', arr))

Answer 8

这是适用于任何iterable 输入（包括数组）的函数式编码

const None =
  Symbol ()

const prepend = (xs, x) =>
 [ x ] .concat (xs)

const split = (f, [ x = None, ...xs ], then = prepend) =>
  x === None
    ? then ([], [])
    : split
        ( f
        , xs
        , (l, r) =>
            f (x)
              ? then (prepend (l, r), [])
              : then (l, prepend (r, x))
        )

const data = 
  [ 'something', 'else', 'and', 'd', 'more', 'things', 'in', 'the', 'd', 'array', 'etc' ]

console .log
  ( split (x => x === 'd', data)
  )

// [ [ 'something', 'else', 'and' ]
// , [ 'more', 'things', 'in', 'the' ]
// , [ 'array', 'etc' ]
// ]

以及适用于任何array-like 输入的优化

const prepend = (xs, x) =>
 [ x ] .concat (xs)

const split = (f, xs = [], i = 0, then = prepend) =>
  i >= xs.length
    ? then ([], [])
    : split
        ( f
        , xs
        , i + 1
        , (l, r) =>
            f (xs[i])
              ? then (prepend (l, r), [])
              : then (l, prepend (r, xs[i]))
        )

const data = 
  [ 'something', 'else', 'and', 'd', 'more', 'things', 'in', 'the', 'd', 'array', 'etc' ]

console .log
  ( split (x => x === 'd', data)
  )

// [ [ 'something', 'else', 'and' ]
// , [ 'more', 'things', 'in', 'the' ]
// , [ 'array', 'etc' ]
// ]

两种实现都是O(n)。

Answer 9

如果您不关心 mutating 数组，这对于 while 和 Array.shift 来说也很简单：

let r = [[]], data = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"]

while(data.length) {
  let item = data.shift()
  item != 'd' ? r[r.length-1].push(item) : r.push([]) 
}

console.log(r)

如果你这样做，那么Array.reduce 会更短：

let arr = ["something", "else", "and", "d", "more", "things", "in", "the", "d", "array", "etc"]

let f = arr.reduce((r,c) => (c!='d' ? r[r.length-1].push(c) : r.push([]),r),[[]])

console.log(f)

两者的想法都是从[[]] 开始，然后您需要的唯一检查是迭代的当前元素是否为d，如果是，则推送新数组或推送到r[r.length-1]，即前一个@ 987654331@.