Question

我发现Array.prototype.join的功能非常有用，因为它仅将联接值应用于数组元素的“内部”连接。像这样：

['Hey', 'there'].join('-') // Hey-there

在此示例中，Array.protoype.map在其中产生“剩余”破折号：

['Hey', 'there'].map(value => value + '-') // Hey-there-

我一直在寻找一种简洁的方法来映射数组而不转换将它们转换为字符串，可能转换为新数组，如下所示：

// Intended behaviour ['Hey', 'there'].mapJoin('-') // ['Hey', '-', 'there']

我并不是在寻找一种当务之急的解决方案，因为我可以自己写下来并将其放置在某个地方的全球范围内。我正在寻找一种本机的方式（ES6很好）来表达它所以我可以在我所有的项目中写它。

Answer 1

您可以使用所需的分隔符进行连接，并用加号（或其他值，如果用于连接）进行分割。

var array = ['Hey', 'there'],
    separator = '-',
    result = array.join(',' + separator + ',').split(',');
    
console.log(result);

另一种解决方案是采用新索引并用分隔符填充previos索引。

var array = ['Hey', 'there'],
    separator = '-',
    result = Object.assign(
        [],
        ...array.map((v, i) => ({ [i * 2 - 1]: separator, [i * 2]: v }))
    );
    
console.log(result);

Answer 2

您正在寻找Ramda's intersperse。

R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']

尽管它必须为implemented。

Answer 3

它并不漂亮或优雅，但是

['Hey', 'there'].reduce(
  (acc, value, i, arr) => (acc.push(value), i < arr.length - 1 ? acc.push('-') : 0, acc),
  [],
)

Answer 4

@ AKX的答案的替代版本。

vec == &(0..vec.len())

Answer 5

您可以尝试这个

const mapJoin = (arr, joiner) => {  
  return arr.reduce( (curr, t) => curr.concat(t, joiner), []).slice(0, arr.length*2-1)
}

const data = ["Hey", "There"]

console.log(mapJoin(data, "-"))

Answer 6

简单的递归编码

const intersperse = (sep, [ x, ...rest ]) =>
  // base case; return empty result
  x === undefined
    ? []
  
  // one remaining x, return singleton
  : rest.length === 0
    ? [ x ]

  // default case; return pair of x and sep and recur
  : [ x, sep ] .concat (intersperse (sep, rest))
  
  
console.log
  ( intersperse ("~", [])              // []
  , intersperse ("~", [ 1 ])           // [ 1 ]
  , intersperse ("~", [ 1, 2 ])        // [ 1, ~, 2 ]
  , intersperse ("~", [ 1, 2, 3 ])     // [ 1, ~, 2, ~, 3 ]
  , intersperse ("~", [ 1, 2, 3, 4 ])  // [ 1, ~, 2, ~, 3, ~, 4 ]
  )

Answer 7

您正在寻找易于定义的intersperse函数：

const intersperse = (x, ys) => [].concat(...ys.map(y => [x, y])).slice(1);

console.log(intersperse("-", ["Hey", "there"])); // ["Hey", "-", "there"]
console.log(intersperse(0, [1, 2, 3]));          // [1, 0, 2, 0, 3]
console.log(intersperse(0, []));                 // []

或者，您可以将其分解为较小的函数：

const concat = xss => [].concat(...xss);
const concatMap = (f, xs) => concat(xs.map(f));
const intersperse = (x, ys) => concatMap(y => [x, y], ys).slice(1);

console.log(intersperse("-", ["Hey", "there"])); // ["Hey", "-", "there"]
console.log(intersperse(0, [1, 2, 3]));          // [1, 0, 2, 0, 3]
console.log(intersperse(0, []));                 // []

您甚至可以将它们安装在Array.prototype上：

Object.assign(Array.prototype, {
    concatenate() {
        return [].concat(...this);
    },
    concatMap(f) {
        return this.map(f).concatenate();
    },
    intersperse(x) {
        return this.concatMap(y => [x, y]).slice(1);
    }
});

console.log(["Hey", "there"].intersperse("-")); // ["Hey", "-", "there"]
console.log([1, 2, 3].intersperse(0));          // [1, 0, 2, 0, 3]
console.log([].intersperse(0));                 // []

在Haskell中，您可以这样编写：

intersperse :: a -> [a] -> [a]
intersperse x = drop 1 . concatMap (\y -> [x, y])

可以看到相似之处吗？

与Java

7 个答案: