一、concat()
 
concat() 方法将传入的数组或非数组值与原数组合并,组成一个新的数组并返回。该方法会产生一个新的数组，但并不改变原数组。
 
arr1 = [1,2];
arr2 = ["aa","as"];
console.log(arr1.concat(arr2));//[1, 2, "aa", "as"]
//或
console.log([].concat(arr1,arr2));//[1, 2, "aa", "as"]


//原数组不改变
console.log(arr1);//[1,2]
console.log(arr2);//["aa","as"]
 
二、array.push.apply()
 
该方法会改变原数组。
 
var arr1 = [1,2];
var arr2 = ["aa","as"];
arr1.push.apply(arr1, arr2);  

console.log(arr1);    //[1, 2, "aa", "as"]
console.log(arr2);    //["aa", "as"]
 
 
当然你也可以 通过对多个数组遍历，从而将多个数组复制给另一个新数组，但是这么做你不觉得累吗?

js数组也是很重要的一块，所以准备对数组的操作等写一个系列。 
 1.第一部分是二元数组的基础知识。 
 http://blog.csdn.net/github_34514750/article/details/51049935 
 2.本部分讲解数组的几种合并方法优劣比较 
 3.第三部分讲解数组简单复制和深度复制 
 http://blog.csdn.net/github_34514750/article/details/56677750
 
根据第一部分的基础知识，我们最容易想到的是concat、push、unshift
 
1.concat合并数组
 
concat是生成一个新数组，内存则是a和b的和
 
var a = [1,2,3],
    b = ["ab","cd","ef"],
    c = a.concat(b);
console.log(c);
 
如图： 
 
 
2.push循环合并数组
 
push是一个数组的内容加入到另一个中
 
var a = [1,2,3],
    b = ["ab","cd","ef"],
    i,
    len;
for(i = 0,len = b.length;i < len;i++) {
    a.push(b[i]);
}
b = null;//b可以清空
 
 
3.unshift循环合并数组
 
若a比较少，则希望a插入到b前边，这样节省时间
 
var a = [1,2,3],
    b = ["ab","cd","ef"],
    i;
for(i = a.length-1;i >= 0;i--) {
    b.unshift(a[i]);
}
console.log(b);
a = null;//a可以清空
 
 
4.reduce合并数组
 
var a = [1,2,3],
    b = ["ab","cd","ef"],
    i;
b.reduce(function(prev,curr){
   prev.push(curr);
   return prev;
},a);
console.log(a); 
 
 
5.reduceRight合并数组
 
var a = [1,2,3],
        b = ["ab","cd","ef"],
        i;
    a.reduceRight(function(prev,curr){
        prev.unshift(curr);
        return prev;
    },b);
    console.log(b);
 
 
6.用Array.prototype.push.apply合并数组
 
var a = [1,2,3],
    b = ["ab","cd","ef"];
// call和apply可以用来重新定义函数的执行环境，apply中的第一个参数a用于指定将要调用函数push的对象，参数是b
// 其实就是在a的上下文环境中执行Array.prototype.push函数，参数是b
Array.prototype.push.apply(a,b);
console.log(a);
 
 
7.用Array.prototype.unshift.apply合并数组
 
var a = [1,2,3],
    b = ["ab","cd","ef"];
// 其实就是在b的上下文环境中执行Array.prototype.unshift函数，参数是a
Array.prototype.unshift.apply(b,a);
console.log(b);
 
 
 问题 
 1.js引擎都会有拷贝数据长度的限制，若数组很大，肯定会超出push或unshift允许调用堆栈的限制，则可以结合splice使用
 
function combineInto(a,b) {
     var len = a.length;
     for (var i=0; i < len; i=i+5000) {
         b.unshift.apply( b, a.slice( i, i+5000 ) );
     }
 }

1、使用concat()进行数组合并
 
concat()连接两个或更多的数组，并返回结果。
 
var arr1=[1,2];
var arr2=[3,4,5];
var arr3=arr1.concat(arr2);//[1,2,3,4,5]
 
注：使用concat()进行数组合并之后，需要用数组接收concat()返回的数组。
 
2、使用push()进行数组合并
 
遍历长度最少的数组，将该数组的元素依次添加进另外一个数组中。 
 
var arr1=[1,2];
var arr2=[3,4,5];
for(var i=0;i<arr1.length;i++){
    arr2.push(arr1[i]);
}
 
3、使用array.push.apply()进行数组合并
 
函数的apply方法有一个特性，那就是obj.func.apply(obj,argv)，argv是一个数组。
 
var arr1=[1,2];
var arr2=[3,4,5];
arr2.push.apply(arr2,arr1);//[3,4,5,1,2]
 
调用arr2.push这个函数实例的apply方法，同时把arr1当作参数传入，这样arr2.push这个方法就会遍历arr1数组的所有元素，将arr1的元素存入arr2数组，使arr2数组发生改变。

从n个不同元素中，任取m(m≤n)个元素并成一组，叫做从n个不同元素中取出m个元素的一个组合;从n个不同元素中取出m(m≤n)个元素的所有组合的个数，叫做从n个不同元素中取出m个元素的组合数。
 方法一：
 //计算公式C(m,n)=n!/((n-m)!*m!)(m≤n)
 
#include<stdio.h>
#include<string.h>
long fun(int m,int n);
int main()
{
  int m = 3, n = 2;
	long resFact1 = fun1(m, n);
	printf("%d\n", resFact1);
	return 0;
}

long fun(int m, int n)
{
	if (n == 0 || n == m)
	{
		return 1;
	}
	else
	{
		return output(m) /(output(n)*output(m-n));//直接调用output()函数本身，计算阶乘
	}
}
int output(int t) //计算n的阶乘
{
	if (t == 0||t==1)
	{
		return 1;
	}
	else
	{
		return (t*output(t - 1));
	}
}
 
方法二：
 //计算公式 C(m,n)=C(m-1,n-1)+C(m-1,n)
 
#include<stdio.h>
#include<string.h>
long fun1(int m,int n);
int main()
{
  int m = 3, n = 2;
	long resFact1 = fun1(m, n);
	printf("%d\n", resFact1);
	return 0;
}
long fun1(int m, int n)
{
	if (n == 0 || n == m)
	{
		return 1;
	}
	else
	{
		return fun1(m - 1, n) + fun1(m - 1, n - 1);
	}
}