JavaScript基础知识（5）

回顾：

 循环三要素：

 1.循环条件：继续循环的条件

 2.循环变量：循环条件中用作判断的变量，向着循环退出的趋势不断变化，充当循环计数器

 3.循环体：

 while：不确定循环次数，或者循环变量的变化规律不固定

 do while:如果第一次条件即使不满足，也要执行一次

 for：循环次数确定，循环变量变化规律固定

 var i=0;

 while(i<10){

 i++;

 }

 console.log(i);     //10

 var i=0;

 do{

 i++;

 }while(i<10)

 console.log(i);     //10

 var i=100;

 while(i<10){

 i++;

 }

 console.log(i);     //100

 var i=100;

 do{

 i++;

 }while(i<10)

 console.log(i);     //101

 正课：

 程序=数据结构+算法

 良好的数据结构，可以极大提高程序的执行效率！

 数组（array）：

     存储：连续存储多个数据的存储空间

     使用：相当于多个变量的集合

 为什么要使用数组：因为现实中数据都是批量分类管理。

 何时使用：只要批量管理多个数据，就要用数组保存

 如何使用：创建，初始化，访问数组中的数据

 创建：数组都是用[]创建出来的。

 var arr=[];   -->创建了一个数组对象，数组中包含0个元素

 var arr=[95,61,99];  -->创建了一个数组对象，数组中连续存储3个元素：95，61,99

 js中数组2个不限制：不限制元素个数、不限制元素数据类型

 数组是引用类型的对象。

 原始类型：数据保存在变量本地。

 引用类型：数据不保存变量本地，保存在“堆”中。

 在“堆”中保存的数据都是由地址指向实际数据。

 原始类型中只能保存1个值，但是现实生活中1个值无法精确描述一个东西，需要用多个属性共同描述一样东西。

 引用类型特点：可以保存多个数据，而且数据个数随时变化

 例：

 var week=["日","一","二","三","四","五","六"];

 栈中创建一个变量空间：名为week

 堆中创建一个大存储空间：地址可能是0x901

 栈中变量中存储的是实际数据

 week变量“引用了”堆中的一个数组对象

 对象：凡是存储在堆中的，都是对象！

 元素是对象里面的内容。

 如何使用引用类型的对象：使用变量，等效于使用对象的地址；使用对象地址，等效于使用对象本身。

 数组对象支持直接输出数组内容。

 其他数组创建语法：不推荐使用，容易有歧义：

 var arr=new Array(num);

 注释：   new:说明要在堆总开辟空间

          Array:ECMAScript标准中的内置类型

          new Array:在堆中创建一个数组类型的存储区域

          (num):初始创建num个元素

 如果元素类型没有初始化，每个元素默认类型就是undefined,但是undefined在输出时都会变为一个空字符

 var arr=new Array(7);则-->[undefined,undefined，undefined，undefined，undefined，undefined，undefined]

 另一种创建方法：

 var arr=new Array(元素1，元素2，...元素n);

 null：代表一个变量没有指向任何对象。

 何时使用null：主动释放对象时使用。主动释放的对象不能被找回。

 null和undefined区别：null专用于主动释放对象，undefined专用于自动初始化任何未赋值的变量

 垃圾回收：js引擎自动销毁不再被引用的对象。

 垃圾回收程序：随js程序运行而后台同时运行

 只要见到中括号[],就会重新创建新的对象。如同时创建了两个对象赋值给同一个变量，那么原来的那个对象就会被释放，指向新的对象。但是只要对象还有变量引用，就不回收。

 week=["SUN","MON","TUS","SAT"];

 新创建一个数组对象

 将新对象地址保存到原week变量中替换旧地址

 旧数组对象释放，等待垃圾回收

 注意：如果旧数组对象还在占用，则不会回收。

 week变量“引用了”新数组对象

 语句

 var week=["日","一","二","三","四","五","六"];

 var day=week;

 此时day是一个赋值运算，day和week两个变量都指向同一个变量

 var week=["日","一","二","三","四","五","六"];

 var day=week;

 week=["SUN","MON","TUS","SAT"];

 此时的week引用了新的对象，但是day依然引用了原来的对象，所以原来的对象不会被回收。

 访问数组：数组是一组变量的集合。如何获得其中一个变量或者数据？使用下标。

 下标：数组中唯一标识一个元素的序号。从0开始，最后一个元素的下标是“元素个数-1”。

 console.log(week[4]);   //取出下标为4位置的变量，week[4]就可以当做一个变量使用，变量能做的事它都可以做，本质上就是变量

 如果下标越界，读取元素不会出错，返回undefined。

 js内置对象不但封装存储，而且封装常用API

 API：内置应用程序接口。实际上就是已经实现的方法。可以直接调用。

 Array API:

 1.  arr.length:属性，是数组的长度，返回一个数，后面没有圆括号()。返回数组中的元素个数

 应用：访问任意数组的最后一个元素：arr[arr.length-1]

 length属性值，随数组长度变化而自动变化。

 js数组可以根据程序的需要，“自动扩容”，保证程序正常执行。

 week=[];      //此时length=0

 console.log(week.length);

 week[0]="日";     

 console.log(week.length);   //此时length=1

 week[2]="二";     

 console.log(week.length);   //此时length=3，值为["日",undefined,"二"]

 week[4]="四";     

 console.log(week.length);   //此时length=5，值为["日",undefined,"二",undefined,"四"]

 document.write(week);

 数组扩容和缩容：都是设置length属性的值。如果length属性值>旧值，会扩容；反之，缩容（截断）。

 缩容后被截断的元素仍属于数组当中，仍然占用着空间，不会被回收，但是找不回来，只能随数组对象一起回收。

 固定用法：在任意数组结尾追加一个新元素,不管数组元素有多少个：arr[arr.length]=新值;

   arr.length-1是最后一个元素，arr.length就是最后一个元素后边

 例：

 var input;

 var emps=[];

 while(true){

      input=prompt("请输入员工姓名");

      if(input!="exit"){

            emps[emps.length]=input;

     }else{

           break;

           }

   }

 document.write(emps);

 上述写法可用下面的方法实现：

 var input;

 var emps=[];

 while((input=prompt("请输入员工姓名"))!="exit"){

 emps[emps.length]=input;

 }

 document.write(emps);

 栈中的变量何时消失？栈中变量的生命周期和堆完全不同，不归垃圾回收器管。

 var a=5;          //全局变量随网页生命周期

 function fun(){

   var b=10;

 }

 fun();       //作用域环境栈

 /*fun()的作用域环境栈出栈

   fun()中的局部变量，一同消失*/

 全局变量归window所有，只要网页不关掉，全局变量就不会丢掉，随网页生命周期。

 作用域环境栈：局部变量的生命周期和所在方法的作用域环境栈有关。作用域创建，局部变量一同创建。作用域结束，局部变量会一同消失。

 什么是数组遍历：对数组中的每个元素进行批量相同的操作。

 遍历数组元素：用for循环实现。

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

 arr[i]-->拿到当前元素

 }

 例：

 var week=["日","一","二","三","四","五","六"];

 document.write(week+"<br/>");

 for(var i=0;i<week.length;i++){

 week[i]="星期"+week[i];

 }

 document.write(week);

 注意：week[i]="星期"+week[i];不能用week[i]+="星期";否则星期会加在数字后面

 关联数组：数组下标可以自定义名称，内部存的是key/value对的值。

 关联数组每个数据都有一个名字。

 何时使用关联数组：如果数组元素的内容无法描述自己的意义时，就要使用关联数组为每个元素起名。

 注意：关联数组的length属性作废了。

 for in循环：专门遍历关联数组用的！

 for(var key in arr){

   //从第一个元素开始，将元素的key赋值给临时变量key

   arr[key]  -->当前正在遍历的元素的值（value）

 }

 例：

 var fbb=[];

 fbb["姓名"]="范冰冰";

 fbb["数学"]=90;

 fbb["语文"]=61;

 fbb["英语"]=95;

 for(var key in fbb){

 document.write(key+":"+fbb[key]+"<br/>");

 }

 如果出现两个相同的赋值，前面的就会被后面覆盖掉，如：

 arr[0]=100;    //创建

 arr[0]=10;     //替换已有的位置0

 arr[4]=26;     //创建位置1，2,3,4，没有赋值的值是undefined

 arr[3]=4;      //替换原有位置的undefined

 关联数组下标用数字赋值的话会被关联扩容，如果是汉字就不会自动扩容。

 关联数组可以同时声明多个元素值(关联数组直接量定义方式)：

 var arr={"key1":value1,"key2":value2,...};

 注意要用花括号

 例：

 var fbb={"姓名":"范冰冰","数学":90,"语文":61,"英语":95};

 for(var key in fbb){

 document.write(key+":"+fbb[key]+"<br/>");

 }

 创建一个函数bubbleSort(arr)，使用冒泡法对数组中元素进行排序：从第一个开始，依次取出相邻两个元素进行比较，大的放在后面，小的放在前面，第一轮比较结束，最大的值就会拍到最后。以此类推进行比较。

 第一次比较：

 var arr=[5,3,2,6,4,9,8,7];

 for(var i=0; i<arr.length-1;i++){

     if (arr[i]>arr[i+1]){

          var box=arr[i];

          arr[i]=arr[i+1];

          arr[i+1]=box;

    }

 }

 document.write("<br/>"+arr);

 第j次比较

 var arr=[5,3,2,6,4,9,8,7];

 for(var j=1;j<arr.length-1;j++)

 for(var i=0; i<arr.length-j;i++){

     if (arr[i]>arr[i+1]){

          var box=arr[i];

          arr[i]=arr[i+1];

          arr[i+1]=box;

    }

 }

 document.write("<br/>"+arr);

 也可用下面的实现：

 var arr=[5,3,2,6,4,9,8,7];

 for(var j=arr.length-1;j>2;j--)

 for(var i=0; i<j;i++){

     if (arr[i]>arr[i+1]){

          var box=arr[i];

          arr[i]=arr[i+1];

          arr[i+1]=box;

    }

 }

 document.write("<br/>"+arr);

 数组常用方法：

 toString方法：任何对象都有toString方法，将任何对象转为字符串。一般不主动调用，js在需要时自动调用。是默认用逗号分隔每个元素。

 语法：x.toString()

 x.valueOf()方法：同toString()完全相同

 var str=arr.join("分隔符")：将数组转为字符串。可自定义分隔符。

 用法：将字符拼接为单词或句子。

 例：

 var chars=['H','e','l','l','o'];

 document.write("<br/>"+chars);    //H,e,l,l,o

 var str1=chars.join();

 var str2=chars.join('');

 document.write("<br/>"+str1);     //join()里面没有分隔符无法进行拼接

 document.write("<br/>"+str2);     //用空字符串分隔后连起来

 arr.concat(一个元素值,[数组])：括号里面可以是一个元素值，也可是一个数组，能将参数拆散成单个元素，追加到数组中，但是不会修改原数组，只能返回新数组对象,所以需要新建一个新的变量接着，即var newArr=arr.concat();

 例：

 var arr1=[1,2,3];

 var arr2=[12,23,123]

 var newArr=arr1.concat(arr2，31);   //将arr2拆散，和31拼接到arr1后面

 document.write("<br/>"+arr1); 

 document.write("<br/>"+newArr);

 字符串其实就是一串字符的数组。

 var subArr=arr.slice(start,end+1);截取数组下标从start开始，到end位置的元素，生成子数组对象。*含头不含尾*

 例：

 var arr=[1,2,3,12,23,123,78,90,99];

 var subArr=arr.slice(2,5);

 document.write("<br/>"+subArr);      //取数组中下标从2到下标为4的元素

 var subArr1=arr.slice(2,arr.length-2);  //从下标为2（也就是第三个元素）开始到倒数第3个元素

 document.write("<br/>"+subArr1);

 var subArr2=arr.slice(-4,-2+1);     //含头不含尾，所以后面有-2+1表示倒数第二个

 document.write("<br/>"+subArr2);  //从倒数第四个到倒数第二个

 arr.splice：删除、插入、替换数组元素，可以直接修改原数组。

 删除数组元素：可在任意位置删除任意个元素。

 语法：arr.splice(start,count)

 替换元素：arr.splice(start,count,值1，值2，...)

 插入元素：arr.splice(start,0,值1，值2，...)

 例：

 var arr=[1,2,3,12,23,123,78,90,99];

 var removed=arr.splice(2,2);

 document.write("<br/>"+arr);   //从下标为2开始删除两个元素

 document.write("<br/>"+removed);  //删除的元素组成的新数组

 arr.splice(2,2,16,6,22); 

 document.write("<br/>"+arr); //从下标为2开始删除两个元素，并新增三个元素

 arr.splice方法有返回值的，会返回每次删除的元素组成的新数组，可以接也可以不接。

 arr.reverse():颠倒所有数组元素，会改变原来的数组。

 arr.sort():排序，是一个默认升序排列，直接修改原数组。默认都转为字符串排序，是按字符串pk排列的，不是按数字大小。