1.数组API

       数组=数据+操作数据的API

       1. 数组 to String:2种：

              var str=arr.toString();

                     -->输出数组中的内容，每个元素用逗号分隔

                     -->自动调用

              var str=arr.join("连接符") *******

                     -->输出数组中的内容,自定义元素间连接符

批量操作页面元素时，可以用join拼接成innerHTML，一次性修改

                     何时使用：2种固定套路

                     1. 将字符组成单词：arr.join("")

                     2. 将单词组成句子：arr.join(" ")

2. 拼接和截取：*API无法直接修改原对象，而返回新对象*

              拼接：var newArr=arr.concat(另一个数组,值1,值2...) 另一个数组会打散成每个元素；

              复制子数组：var subArr=arr.slice(starti,endi+1); **********

                                                 含头不含尾

                                                 endi+1 可省略，截取到最后一位；

                                                 两个参数都可以给负值，负值从后数，从-1开始；含头不含尾不会改变；

       3. splice: 删除   插入    替换

              1. 删除：直接修改原数组对象

                     [var deleted=]arr.splice(starti,删除个数)

                     返回本次删除元素组成的数组

              2. 插入：

                     arr.splice(starti,0,新值1,...)

              3. 替换：

                     arr.splice(starti,删除个数,新值1,...)

       4. arr.reverse(); 颠倒数组中所有元素; 直接修改原数组对象

       优化：

       1.问题：频繁字符串拼接，造成内存浪费；（频繁+=会有浪费的字符串；） (demo1)

         解决：先将要拼接的字符串放入数组；

              最后 arr.join("");

2.数组API

       1.数组排序；arr.sort();  (demo2)

              sort()将一切数组元素默认转成 字符串 比较的；升序排序；

              *比较器函数：

              专门判断或者比较任意两数大小的函数；

              2个特点：

                     - “固定要2个参数”，分别表示要比较的任意两值；

                     - 无论比较逻辑是什么，都要“返回一个数字”(这个数字要说明两个参数的关系)；

              **函数"对象"作为参数：

                     js中函数本质是一个对象；

                     函数名本质是指向函数对象的变量；

                     函数名后加“( )”，表示立即执行，

                     将函数作为对象传递时，不加“( )”；

       如何自定义sort方法的排序？

       arr.sort(比较器函数)

       *颠倒比较器结果的正负，可改升序为降序排列*

       2.栈和队列：数组模拟 (demo3)

              栈和队列：js中没有真正的栈和队列的类型

                       一切都是用数组对象模拟的

              栈：只能从一端进出的数组，另一端封闭

              FILO

              何时使用：今后只要仅希望数组只能从一端进出时

              如何使用：2种情况：

                     1. 末尾出入栈：已入栈元素的下标不再改变

                        入栈: arr.push(新值1,...)

                        出站: var last=arr.pop()

                     2. 开头出入栈：每次入栈新元素时，已入栈元素的位置都会向后顺移。

                        入栈：arr.unshift(新值1,...);

                        出站：var first=arr.shift();

              队列：只允许从末尾进入数组，必须从开头出数组

              FIFO

              结尾入队列：arr.push();

              开头出队列：var first=arr.shift();

Map:对数组中每个元素执行相同的函数；

var arr=[4,9,16];

arr=arr.map(Math.sqrt);

 console.log(arr);//[2,3,4]

var arr=[4,9,16];

function fun(n){

return n+1;

}

arr=arr.map(fun);

console.log(arr);//[5, 10, 17]

Map调用回调函数，不修改原数组；

回调函数要求：

必须要有一个参数；

必须要有一个返回值；

3.二维数组:(demo4)

       数组中的元素，又引用了另一个数组对象

       使用：2种；

              - 保存横行竖列的二维数据；

              - 保存上下级关系；

       如何创建：

              1.先创建空数组，再赋值；

                var arr=[];

                arr[0]=["石家庄","保定","唐山"]

                arr[1]=["德州","济南","烟台"]

              2. 创建数组时，同时初始化子数组：    

                var data=http://www.mamicode.com/[

                    [0,2,2,4],

                    [2,4,4,8],

                    [16,32,16,8],

                    [4,2,128,4]

                ];

             3.如何访问二维数组中的数据：arr[行下标][列下标]

              比如：data中第2行，第3个元素

              data[1][2]

              强调：二维数组中，行下标不能越界！

              console.log(data[1][5]); //undefined

              console.log(data[5][1]); //

              //undefined[1]

              arr.indexOf(值)：在数组中找某个值得位置，找到返回下标，没找到返回-1；

              遍历二维数组：

              固定套路：外层循环遍历行，内层循环遍历列；****

              var arr=[[...],[...]...]

              for(var r=0;r<arr.length;r++){

                     for(var c=0;c<arr[r].length;c++){

                     }

              }

4.string:(demo5)

       多个字符组成的一个只读的集合(数组)；

       凡是数组对象中，不修改原对象的API，字符串都能用。

       .length属性；字符个数，可以用[i]访问每个字符;

       如：slice(),indexOf()

       凡是数组对象中，直接修改原对象的API，字符串都不能用。

       如：push(),sort(),splice()

       内置对象：

              ES标准中已经定义好的，由浏览器厂商已经实现的对象；

              11个：

                  String Number Bollean  包装类型

                  Array Date RegExp  Math(不能new)

                  Error

                  Function Object

                  Global(全局，在浏览器中叫 Window)

       包装类型：(demo5) String Number Bollean（不能new）

              封装原始类型数据，提供了对原始类型数据的操作方法。

              自动使用。

              原始类型的值，本身没有任何方法，当程序中，使用原始类型数据调用方法时（方法前必须是个对象），程序会自动创建“包装类型对象”封装该数据。

              函数调用完，包装类型自动释放。

       String API：*所有API都无法直接修改原字符串*

       转义字符：

              当字符串的内容和程序的特殊符号冲突时

              或字符串中包含功能字符时，都用“\”转化字符的意义，

              \n：换行  \t: 一次缩进Tab键

       大小写转换：

              将字符串中所有字符都统一转为大写或小写

              何时使用：不区分大小写时

              比如：用户名  验证码    电子邮件

              转大写:str=str.toUpperCase();

              转小写:str=str.toLowerCase();

       获取指定位置的字符：3种：

              1. str[i]

              2. str.charAt(i)

              3. str.charCodeAt(i)-->获得字符的unicode号

       查找关键字的位置：2种：

              1. var i=str.indexOf(kword[,starti]);

                 从左向右，查找kword首字符在字符串中的下标

                 如果没找到，返回-1

                 starti：从starti位置开始向后查找下一个

                 如果省略starti，默认从0开始找

              2. var i=str.lastIndexOf(kword[,starti])

                 从starti位置开始，向左找！下一个kword  ；starti是负数时，lastIndexOf会将它变为0；******

lastIndexOf只关心关键字第一个字符在自己的哪边；

解决：如果最后一次找到0就立即退出；break

         转成字符串最快的方法就是：加空字符串+""; *****************

return后不加数据，单独使用，表示退出“函数”执行；

break：停止"当前结构"的执行，并跳出当前结构；不影响程序继续向后运行。单独用；********** 不是每个case都要加break；

面试题：

var str="youcanyouup nozuonodie";

var arr=str.split("").sort().join("").match(/(.)\1+/ig); // \1：与第一个()相同的内容；

arr.sort(function(a,b){return b.length-a.length});

console.log(arr[0][0]);   //出现次数最多的字符是哪个

console.log(arr[0].length);     //出现次数最多的字符的长度

Unit06： 数组的常用方法_2 、 二维数组 、 String_1