在Javascript中，如何连接结果不是字符串的数组？

我有一个数组

[1,2,3,4,5,6]

和一个分隔符

'~'

，我想将它们合并到一个新数组中，

'~'

作为分隔符

我希望输出为

[1'，2'，3'，4'，5'，6]

使用我得到了如下结果：

var my_array = [1,2,3,4,5,6]
var separator = '~'
_.flatten(_.zip(my_array, new Array(my_array.length).fill(separator)))

但这感觉很难看，我相信有更好的办法

---

编辑：即使上面的数组有

int

s，我也希望它适用于任何类型的对象。

为什么不在pue Javascript中：

次要更新：用于说明大于9的值

• 首先将它连接到字符串

  my\u数组。连接（“~”

• 然后拆分每个字符

  。拆分（/\b/gi）

var my_数组=[1,2,3,4,5,6,10,11]
变量分隔符=“~”
console.info（my_array.join（“~”）.split（/\b/gi））为什么不在pue Javascript中：

次要更新：用于说明大于9的值


首先将它连接到字符串
my\u数组。连接（“~”
然后拆分每个字符
。拆分（/\b/gi）


var my_数组=[1,2,3,4,5,6,10,11]
变量分隔符=“~”
console.info（my_array.join（“~”）.split（/\b/gi））这里有一个使用forEach的选项

var a = [1,2,3]
var sep = '~'
var b = []
a.forEach(function(x) { b.push(x, sep) })
b.pop() // remove the last `~`

这里有一个使用forEach的选项

var a = [1,2,3]
var sep = '~'
var b = []
a.forEach(function(x) { b.push(x, sep) })
b.pop() // remove the last `~`

如有必要，您可以使用和使用瓷砖


var数组=[1,2,3,4,5,6]，
结果=数组.reduce（函数（r，a，i）{
返回r.concat（i？“~”：[]，a）；
}, []);
控制台日志（结果）
。作为控制台包装{max height:100%！important；top:0；}
如果需要，您可以使用并使用波浪线


var数组=[1,2,3,4,5,6]，
结果=数组.reduce（函数（r，a，i）{
返回r.concat（i？“~”：[]，a）；
}, []);
控制台日志（结果）
.as控制台包装{max height:100%！important；top:0；}
Nice simple
forEach
没有十几个临时数组，等等：


var my_数组=[1,2,3,4,5,6]；
var result=[my_数组[0]]；
my_array.forEach（函数（条目、索引）{
如果（索引>0）{
结果。推送（“~”，输入）；
}
});
控制台日志（结果）Nice simple
forEach
没有十几个临时数组等：


var my_数组=[1,2,3,4,5,6]；
var result=[my_数组[0]]；
my_array.forEach（函数（条目、索引）{
如果（索引>0）{
结果。推送（“~”，输入）；
}
});
控制台日志（结果）使用传统的
for
循环


var nums=[1,2,3,4,5,6]；
var dash=“~”；
var-res=[]；
for（var i=0；i使用传统的
for
循环


var nums=[1,2,3,4,5,6]；
var dash=“~”；
var-res=[]；
对于（var i=0；i使用

更新：

确保删除尾随的
~
。
使用

更新：

确保拖尾的
~
被删除。
把我的帽子扔进去：

arr.map(x => [x, '~']).reduce((p, c) => p.concat(c));

这不是很简单，它将每个元素映射为两个元素并将它们连接在一起，很容易概括：

const intercalate = (arr, sep) => arr.map(x => [x, sep])
                                     .reduce((p, c) => p.concat(c))
                                     .slice(0, -1);

或者使用单个reduce：

const intercalate = (arr, sep) => arr.reduce((p, c) => p.concat(c, sep)).slice(0, -1);

只是把我的帽子扔进去：

arr.map(x => [x, '~']).reduce((p, c) => p.concat(c));

这不是很简单，它将每个元素映射为两个元素并将它们连接在一起，很容易概括：

const intercalate = (arr, sep) => arr.map(x => [x, sep])
                                     .reduce((p, c) => p.concat(c))
                                     .slice(0, -1);

或者使用单个reduce：

const intercalate = (arr, sep) => arr.reduce((p, c) => p.concat(c, sep)).slice(0, -1);

为什么不只是一个漂亮的简单循环呢？一个漂亮的简单循环可以做到这一点，但它会在长度上指定一个手册
-1
。我们正在寻找更漂亮的东西。“…但在长度上指定一个手册-1…”嗯？
join
是一个很难实现的操作，因为它有一个固有的对称性破坏。问题已经解决了，但是一行ES6将是：
var r=Array。from（{length:（a.length*2）-1}，（v，i）=>i%2？s:a[i/2]）；
其中
a
是你的数组，
s
是你的“~”.Codepen：为什么不只是一个漂亮的简单循环呢？一个漂亮的简单循环就可以了，但是它的长度必须是手动的
-1
。我们在寻找更漂亮的东西。“…但是它的长度必须是手动的-1…”嗯？
join
是一个很难实现的操作，因为它有一个固有的对称性破坏。问题已经解决了，但是一行ES6将是：
var r=Array。from（{length:（a.length*2）-1}，（v，i）=>i%2？s:a[i/2]）；
其中
a
是你的数组，
s
是你的“~”.Codepen：当数组中出现
10
或更高的值，或小于
0
的值，或数字以外的值，或，或，或，或…时，它就会爆炸。此外，它假设每个对象都有一个良好的toString实现。如果数组不能字符串，例如日期，则会失败。这仍然是一种可怕的方法还有很多其他的故障模式（包括我提到的那些负数）。嗯，那是你更新之前的10分钟（很明显）。当数组中有
10
或更高的值，或小于
0
的值，或除数字以外的其他值，或，或，或，或…时，它就会爆炸。此外，它假设每个对象都有一个良好的toString实现。如果数组不能字符串，例如日期，则会失败。用大量数据来处理这一问题仍然是一种可怕的方式其他故障模式（包括我提到的那些负数）。嗯，那是在你更新之前的10分钟（很明显）。所有那些不必要的临时数组！！所有那些不必要的临时数组！！到目前为止，结果是[1，“~”，2，“~”，3，“~”，4，“~”，5，“~”，6，“~”，其中[1，“~”，2，“~”，3，“~”，4，“~”，5，“~”，6]抱歉，更正。到目前为止，这将导致[1，“~”，2，“~”，3，“~”，4，“~”，5，“~”，6，“~”]，其中所需的结果[1，“~”，2，“~”，3，“~”，4，“~”，5，“~”，更正。FTW！！谢谢！！@AgamRafaeli:它假定数组中至少有一个条目，因此如果该假定无效，
var result<