【面向JS--数组API】

数组API：浏览器厂商已经实现的方法，开发人员直接调用，不需要了解具体实现。

将数组转化为字符串：

2个，hash数组不是正经的数组。

1). var str=arr.toString(); 返回数组中元素的内容，用逗号分隔
    （除了null和undefined都有toString，返回数组中元素的内容，用逗号分隔）
2). var str=arr.join("连接符"); 可自定义连接符，不修改原数组，返回一个字符串

固定套路：
    1、无缝拼接数组每个元素：var str=arr.join("")
          如果不加""，分隔符为空，等效于toString，默认按逗号分割
    2、将单词拼接为句子: var str=arr.join(" ");，与上一个的区别是双引号之间有空格。
    3、将数组拼接为html元素：“<开始标签>”+Arr.join(“”)+”<结束标签>”

var arr = ["原","生","J","S"]；
console.log(arr.join(""));//原生JS

var arr2 = ["语文"，"数学","英语"];
var html = ""+arr2.join("")+"";
document.write(html);

优化：数组的拼接比字符串拼接效率更高！（因为字符串创建了不能更改）
建议：凡是频繁的字符串拼接，都要2步：
     1、先将要拼接的子字符串放入一个数组中
     2、调用数组的join方法，一次性生成结果字符串

拼接和选取:

拼接: concat，将其它元素或另一个数组，拼接到当前数组结尾

newArr=arr1.concat(值1,值2,arr2,......) //将值1,值2,arr2，拼接到arr1结尾
强调: 
    1、concat无权修改原数组，只能返回新数组，所以必须用变量接住拼接后的返回值。
    2、concat会打散参数中的子数组为单个元素，单个拼接。

var hz = ["路飞","索隆","乌索普","娜美","山治","乔巴","罗宾","弗兰奇","布鲁克"];
var hz1 = ["微微公主","大师"];
//拼接两个数组，把两个数组都打散
var hz2 = as.concat(hz1);
console.log(String(hz2));//路飞,索隆,乌索普,娜美,山治,乔巴,罗宾,弗兰奇,布鲁克,微微公主,大师

选取: slice，获取原数组中指定位置开始到结束位置之间的所有元素, 组成临时子数组

arr.slice(starti,endi+1);
选取starti下标位置开始到endi下标位置(不包含)的所有元素，组成临时子数组
强调: 
    1、无权修改原数组，只是复制原数组中的元素组成新数组
    2、含头不含尾: 当两个参数都是下标时
         开始下标的元素包含在结果中
         结束下标的元素不包含在结果中
简写: 
    1、支持负数参数，表示倒数第n个位置
          -n, 相当于.length-n
    2、省略第二个参数，表示从指定位置一直截取到结尾
    3、两个参数都省略，表示完整复制一个数组。

//从0复制到第6位，不包含第6位
var hz3 = hz2.slice(0,6);
console.log(String(hz3));//路飞,索隆,乌索普,娜美,山治,乔巴
//写一个参数，表示从该位置到末尾
var hz4 = hz2.slice(6);
console.log(String(hz4));//罗宾,弗兰奇,布鲁克,微微公主,大师
//不写参数，表示复制原数组
var hz5 = hz2.slice();
console.log(String(hz5));//路飞,索隆,乌索普,娜美,山治,乔巴,罗宾,弗兰奇,布鲁克,微微公主,大师
//复制的数组和原数组地址不同，是两个数组
console.log(hz2==hz3);//false

修改splice: 包括: 删除, 插入, 替换元素

splice直接修改原数组对象

删除: 删除arr中starti开始的n个元素

arr.splice(starti,n);
强调: 1、直接修改原数组
      2、不考虑含头不含尾
返回值: 被删除的元素组成的临时子数组
  var deletes = arr.splice(starti,n)
简写: splice也支持负数参数

插入: 将值1,值2,……插入到arr中starti位置，原位置的值，向后顺移

arr.splice(starti,0,值1,值2,......)    
强调: 不会打散数组参数。整个子数组保存在一个元素中

替换: 先删除arr中starti位置开始的n个元素，再在starti位置插入值1,值2,…

arr.splice(starti,n,值1,值2,...)
强调: 1、删除的元素个数和插入的新元素个数不必一致
     2、不会自动打散参数中的数组

console.log("删除前："+String(hz));//删除前：路飞,索隆,乌索普,娜美,山治,乔巴,罗宾,弗兰奇,布鲁克
var hz6 = hz.splice(-2,2);
console.log("删除后："+String(hz));//删除后：路飞,索隆,乌索普,娜美,山治,乔巴,罗宾
//使用concat添加
//在末尾添加
var hzx1 = hz.concat(hz6);
//在前面添加
//var hzx1 = hz6.concat(hz);
hz = hzx1;
console.log("添加后："+String(hz));//添加后：路飞,索隆,乌索普,娜美,山治,乔巴,罗宾,弗兰奇,布鲁克

排序: arr.sort();

问题一: 默认仅支持按字符串升序排列

解决: 自定义比较器函数: 2步:
    什么是比较器函数: 专门比较任意两值大小的函数
    Step1: 定义比较器函数: 
       要求: 2个参数: a , b
          返回值: 如果a>b，就返回正数
                 如果a

函数 vs 方法：(都是function对象，函数和方法本质一样的)

函数：不属于任何对象的叫函数(不需要通过.访问)
     函数也是引用类型的对象
方法：属于特定对象的函数叫方法(需要通过对象.才可访问)

问题二: 所有排序算法都只有升序，没有降序

解决: 颠倒比较器结果的正负，可改升序为降序
最简单的降序比较器: function cmp(a,b){return -(a-b);//b-a;}

翻转: arr.reverse();

强调: 1、不负责排序，仅原样颠倒数组元素
     2、直接改变原数组

栈和队列: js中没有专门的栈和队列类型，都是用普通数组模拟的

何时: 只要希望按一定的顺序访问数组中元素时
栈stack: 一端封闭，只能从另一端进出的数组
特点：LIFO
   1、结尾出入栈: 
     入: arr.push(值)
     出: var last = arr.pop();//需要接收
     特点: 每次出入栈，剩余元素的位置不受影响 -- 效率高
   2、开头出入栈: 
     入: arr.unshift(值)
     出: var first=arr.shift();
     特点: 每次出入栈，都会导致剩余元素的位置改变 -- 效率低
   开头入栈的结果和结尾入栈的结果是相反的

队列queue: 只能从一端进入，从另一端出的数组
特点：FIFO
   1、结尾入: arr.push(值)
   2、开头出: var first=arr.shift();

//队列 栈的混搭 push shift
function que(){
    var p = 5;
    var qs = [];
    for(var i=1;i<=p;i++){
        qs.push("顾客："+i);
        console.log(String(qs));
    }
    while(p>0){
        p--;
        console.log(String(qs));
        var frist = qs.shift();
        console.log("卖了一台，还剩"+p+"台");
    }
}