var a=new Array('a','b','c');
var b=new Array('d','e','f');
var d=new Array('x','y','z');
var c=a.concat(b,d)

这能解决你的问题吗?

使用concat函数，如下所示:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayA.concat(arrayB);

newArray的值将是[1,2,3,4](arrayA和arrayB保持不变;Concat为结果创建并返回一个新数组)。

如果你的数组不是很大(见下面的警告)，你可以使用你想要添加值的数组的push()方法。Push()可以接受多个参数，因此可以使用它的apply()方法将要推送的值数组作为函数参数列表传递。这比使用concat()在数组中添加元素而不是创建新数组更有优势。

然而，对于大型数组(100,000成员的数量级或更多)，这种技巧可能会失败。对于这样的数组，使用循环是更好的方法。详情见https://stackoverflow.com/a/17368101/96100。

var newArray = [];
newArray.push.apply(newArray, dataArray1);
newArray.push.apply(newArray, dataArray2);

你可能想把它泛化成一个函数:

function pushArray(arr, arr2) {
    arr.push.apply(arr, arr2);
}

．.． 或者将其添加到Array的原型:

Array.prototype.pushArray = function(arr) {
    this.push.apply(this, arr);
};

var newArray = [];
newArray.pushArray(dataArray1);
newArray.pushArray(dataArray2);

．.． 或者模拟原始的push()方法，使用concat()，像push()一样，允许多个参数:

Array.prototype.pushArray = function() {
    this.push.apply(this, this.concat.apply([], arguments));
};

var newArray = [];
newArray.pushArray(dataArray1, dataArray2);

下面是上一个例子的循环版本，适用于大型数组和所有主流浏览器，包括IE <= 8:

Array.prototype.pushArray = function() {
    var toPush = this.concat.apply([], arguments);
    for (var i = 0, len = toPush.length; i < len; ++i) {
        this.push(toPush[i]);
    }
};

在IE中使用concat函数代替push()函数。的例子,

var a=a.concat(a,new Array('amin'));

Тhis是一个工作代码，它工作得很好:

var els = document.getElementsByTagName('input'), i;
var invnum = new Array();
var k = els.length;
for(i = 0; i < k; i++){invnum.push(new Array(els[i].id,els[i].value))}

在ECMAScript 6中，你可以使用Spread语法:

设arr1 = [0,1,2]; Let arr2 = [3,4,5]; arr1.push(…arr2); console.log (arr1)

扩展语法在所有主流浏览器(不包括IE11)中都可用。关于当前的兼容性，请参见这个(不断更新的)兼容性表。

但是，请参阅下面杰克·吉芬的回复，了解更多关于性能的评论。似乎concat仍然比spread算子更好更快。

从MDN找到了一个优雅的方式

var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];

// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']

或者你可以使用ES6的扩展操作符特性:

let fruits = [ 'apple', 'banana'];
const moreFruits = [ 'orange', 'plum' ];

fruits.push(...moreFruits); // ["apple", "banana", "orange", "plum"]

以下对我来说似乎是最简单的:

var newArray = dataArray1.slice();
newArray.push.apply(newArray, dataArray2);

由于“push”的参数数量是可变的，所以可以使用push函数的apply方法来推送另一个数组的所有元素。它的结构 调用push，使用它的第一个参数(这里是"newArray")作为"this"和 数组的元素作为剩余的参数。

第一个语句中的切片获得第一个数组的副本，因此不需要修改它。

如果你正在使用一个可用slice的javascript版本，你可以将push表达式简化为:

newArray.push(...dataArray2)

使用JavaScript ES6，你可以使用…运算符作为展开运算符，它本质上将数组转换为值。然后，你可以这样做:

const myArray = [1,2,3,4,5];
const moreData = [6,7,8,9,10];

const newArray = [
  ...myArray,
  ...moreData,
];

虽然语法很简洁，但我不知道它在内部是如何工作的，以及对大型数组的性能影响是什么。

下面的函数没有数组长度的问题，并且比所有建议的解决方案执行得更好:

function pushArray(list, other) {
    var len = other.length;
    var start = list.length;
    list.length = start + len;
    for (var i = 0; i < len; i++ , start++) {
        list[start] = other[i];
    }
}

不幸的是，jspref拒绝接受我的提交，所以这里是使用benchmark.js的结果

        Name            |   ops/sec   |  ± %  | runs sampled
for loop and push       |      177506 |  0.92 | 63
Push Apply              |      234280 |  0.77 | 66
spread operator         |      259725 |  0.40 | 67
set length and for loop |      284223 |  0.41 | 66

在哪里

For循环和push是:

    for (var i = 0, l = source.length; i < l; i++) {
        target.push(source[i]);
    }

推动应用:

target.push.apply(target, source);

接线员:传播

    target.push(...source);

最后，“set length And for loop”是上面的函数

我们有两个数组a和b，这里的代码是将数组a的值推入数组b。

let a = [2, 4, 6, 8, 9, 15]

function transform(a) {
    let b = ['4', '16', '64']
    a.forEach(function(e) {
        b.push(e.toString());
    });
    return b;
}

transform(a)

[ '4', '16', '64', '2', '4', '6', '8', '9', '15' ]

关于array。prototype。push。apply有很多答案。这里有一个明显的例子:

数据1 = [1,2]; 变量dataArray2 = [3,4,5]; var newArray = []; 阵列原型推送。apply (newArray, dataArray1);// newArray = [1,2] 阵列原型推送。apply (newArray, dataArray2);// newArray = [1,2,3,4,5] console . log (JSON stringify (newArray));//输出:[1、2、3、4、5]

如果你有ES6语法:

数据1 = [1,2]; 变量dataArray2 = [3,4,5]; var newArray = []; newArray。push (... dataArray1);// newArray = [1,2] newArray。push (... dataArray2);// newArray = [1,2,3,4,5] console . log (JSON stringify (newArray));//输出:[1、2、3、4、5]

这是ES6的方式

var newArray = []; 数据1 = [1,2,3,4] 请注意数据2 = [5,6,7,8] 纽瓦雷= [..]dataArray1, ... dataArray2] console . log (newArray)

上面的方法适用于大多数情况，在不适用的情况下请考虑concat，比如数组中有数十万项。

数据1 = [1,2,3,4] 请注意数据2 = [5,6,7,8] 让纽瓦雷= dataArray1.concat(dataArray2); console . log (newArray)

如果你想修改原始数组，你可以展开和推:

var source = [1, 2, 3];
var range = [5, 6, 7];
var length = source.push(...range);

console.log(source); // [ 1, 2, 3, 5, 6, 7 ]
console.log(length); // 6

如果你想确保源数组中只有相同类型的项(例如，不要混合数字和字符串)，那么使用TypeScript。

/**
 * Adds the items of the specified range array to the end of the source array.
 * Use this function to make sure only items of the same type go in the source array.
 */
function addRange<T>(source: T[], range: T[]) {
    source.push(...range);
}

试试这个:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayB.reduce((pre, cur) => [...pre, ...cur], arrayA);
console.log(newArray)

性能

我分析了当前的解决方案，并提出了2个新的(F和G在详细部分提出)一个是非常快的中小型阵列

今天2020.11.13我在Chrome v86、Safari v13.1.2和Firefox v82上对所选解决方案的MacOs HighSierra 10.13.6进行测试

结果

适用于所有浏览器

对于中小型数组，基于while-pop-unshift (F,G)的解决方案在所有浏览器上(非常)最快。对于有50000个元素的数组，这个解决方案在Chrome上变慢 解决方案C,D数组500000中断:“RangeError:最大调用堆栈大小超过 解(E)最慢

细节

我执行2个测试用例:

当数组有10个元素时，你可以在这里运行它 当数组有10k个元素时-你可以在这里运行它

下面的代码片段展示了解决方案之间的差异 一个, B, C, D, E, F(我) G(我) H, 我

// https://stackoverflow.com/a/4156145/860099 function A(a,b) { return a.concat(b); } // https://stackoverflow.com/a/38107399/860099 function B(a,b) { return [...a, ...b]; } // https://stackoverflow.com/a/32511679/860099 function C(a,b) { return (a.push(...b), a); } // https://stackoverflow.com/a/4156156/860099 function D(a,b) { Array.prototype.push.apply(a, b); return a; } // https://stackoverflow.com/a/60276098/860099 function E(a,b) { return b.reduce((pre, cur) => [...pre, cur], a); } // my function F(a,b) { while(b.length) a.push(b.shift()); return a; } // my function G(a,b) { while(a.length) b.unshift(a.pop()); return b; } // https://stackoverflow.com/a/44087401/860099 function H(a, b) { var len = b.length; var start = a.length; a.length = start + len; for (var i = 0; i < len; i++ , start++) { a[start] = b[i]; } return a; } // https://stackoverflow.com/a/51860949/860099 function I(a, b){ var oneLen = a.length, twoLen = b.length; var newArr = [], newLen = newArr.length = oneLen + twoLen; for (var i=0, tmp=a[0]; i !== oneLen; ++i) { tmp = a[i]; if (tmp !== undefined || a.hasOwnProperty(i)) newArr[i] = tmp; } for (var two=0; i !== newLen; ++i, ++two) { tmp = b[two]; if (tmp !== undefined || b.hasOwnProperty(two)) newArr[i] = tmp; } return newArr; } // --------- // TEST // --------- let a1=[1,2,3]; let a2=[4,5,6]; [A,B,C,D,E,F,G,H,I].forEach(f=> { console.log(`${f.name}: ${f([...a1],[...a2])}`) })

这里是chrome的示例结果

    public static void main(String[] args) {
    // TODO Auto-generated method stub
    //Scanner sc=new Scanner(System.in);
    
    int[] ij= {1,4,222,455,111};
    int[] ijk=Arrays.copyOf(ij,ij.length);
    for(int i=0;i<ij.length;i++) {
        System.out.print(i);
    }
    System.out.println(" ");
    for(int i=0;i<ijk.length;i++) {
        System.out.print(i);
    }
    
    
}

输出: 01234 01234

我提供了两种简单的方法:

解决方案1:

let dataArray1= [0, 1];
let dataArray1= [2, 3];
dataArray1.push(...dataArray2);
console.log(dataArray1) 

解决方案2:

let dataArray1 = [1, 2];
let dataArray2 = [3, 4];
let newArray = dataArray1.concat(dataArray2);
console.log(newArray)