JavaScript基础知识（6）

function bubbleSort(arr){

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

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

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

         var box=arr[i];

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

           arr[i+1]=box;

       }

    }

   }return;

 }/*对任意数组执行冒泡排序*/

 var arr=[5,7,3,2,6,8,4,9];        //全局变量

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

 bubbleSort(arr);                  //调用方法

 document.write("<br/>"+arr);      //方法中修改了数组，引用变

 量的数组也被修改了

 在方法内改arr[]数组的时候，就等效于直接修改了arr数组。即如果

 在方法内把引用类型的值改变了，原来的数组就会发生变化。

 手册：javascript-->js对象-->js数组-->Array对象参考手册

 转为字符串：x.toString() -->任何对象都有toString方法

            var str=arr.join('分隔符')  -->自定义元素间分隔符

  固定用法：arr.join("") -->将数组中的字符无缝拼接为单词或字符

 串

 拼接和截取：var newArr=arr.concat(otherArr,值1，...)

           var sunArr=arr.slice(start,end+1)

 slice方法是复制原数组总的部分元素，原数组不变。另外，slice属

 性是含头不含尾的。

 splice:会直接修改原数组，返回被删除的元素

 删除：arr.splice(start,count)

 替换：arr.splice(start,count，值1，值2,...)=》会自动调整数组

 容量，容纳所有修改的新值

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

 正课：

 arr.sort()：默认按字符串升序排列,按unicode编码顺序排序而不是

 数字大小排序的

 例：

 var arr=[1,2,13,23,123,32,3];

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

 arr.sort();     //sort方法默认升序排列，直接修改原数组

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

 自定义排序：2步：step1：定义比较器函数

                  step2：将比较器传递给sort方法

 什么是比较器函数？定义任意两值比较策略的方法。

    比如：num1-num2>0  -->num1>num2

          num1-num2<0  -->num1<num2

 比较器函数：

 function compare(a,b){

   return a-b;

 }   //如果返回大于0的数，a>b;如果返回小于0的数，a<b;如果刚好

 等于0，说明a=b.

 例：实现任意两数比较

 function compare(a,b){

   return a-b;

 }

 var a=13;

 var b=2;

 var r=compare(a,b);

 if(r>0){

  document.write(a+">"+b);

 }if(r<0){

  document.write(a+"<"+b);

 }if(r==0){

  document.write(a+"="+b);

 }

 比较器是给sort方法用的。

 如何将方法作为参数传递？

 js中方法也是一个对象。方法名其实就是指向方法对象的变量名。

 function compare(a,b){return a-b;}相当于：var compare=new

 Function("a","b","return a-b");

        arr.sort(compare);   //注意将方法作为对象传递时，仅使

 用方法名，后不加圆括号。

 function compare(a,b){return a-b;}可以定义在使用前后的任何位

 置，原因：var声明和function声明自动提前。

 var compare=new Function("a","b","return a-b");必须定义在使用

 之前，原因是仅声明提前，赋值不提前。

 例：

 var arr=[1,2,13,23,123,32,3];

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

 var compare=

     new Function("a","b","return a-b");    //方法参数全都转为

 字符串

 arr.sort(compare);

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

 升序：function compareASC(a,b){return a-b;}

 降序：颠倒比较结果的正负，可以导致升序变降序

 颠倒：function compareDESC(a,b){return -(a-b);}

 上述方法是等效var compare=new Function("a","b","return a-

 b;");

 升序：

 function compare(a,b){return a-b;}

 var arr=[1,2,13,23,123,32,3];

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

 arr.sort(compare);     //sort方法默认升序排列，直接修改原数组

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

 降序：

 function compare(a,b){return -(a-b);}

 var arr=[1,2,13,23,123,32,3];

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

 arr.sort(compare);     

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

 例：

 <script>

   var arr=[12,23,123,31,4];

   function compareASC(a,b){return a-b;}

   function compareDESC(a,b){return -(a-b);}

   function sortASC(){

    arr.sort(compareASC);

   console.log(arr.toString());

   }

  function sortDESC(){

    arr.sort(compareDESC);

    console.log(arr.toString());

   }

 </script>

 <button onclick="sortASC()">升序</button>;

 <button onclick="sortDESC()">降序</button>;

 栈和队列：

 什么是栈？先进的后出。(LIFO,即LAST IN FIRST OUT)栈其实就是数

 组，只不过用一对儿方法模拟了栈的操作。栈的特点是，只能从数组

 一端出栈，入栈。另一端封闭。

 入栈：arr.push(),返回的是新的长度，一般不用这个返回

 出栈：var last=arr.pop(),

 var bus=[];

 for(var i=1;i<=5;i++){

 bus.push("乘客"+i);

 }

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

 while(bus.length>0){

 var customer=bus.pop();

 document.write(customer+"下车"+"<br/>");

 }

 回顾：自定义排序：2步：

 1.定义比较器函数：

   升序比较器：function compareASC(a,b){return a-b;}

   降序比较器：function compareDESC(a,b){return -(a-b);}

 2.将比较器函数对象传递给sort方法，作为参数：arr.sort

 (compareASC);

 比较器仅负责任意两数相减，返回减法的结果。sort方法可以根据比

 较器返回的结果，决定是否交换两数。

 正课：

 栈和队列：js中，其实就是数组！

 栈：只能从一端插入或者弹出元素，另一端封闭。

 最大特点：LIFO

 栈操作：结尾入栈出栈：元素的下标始终不变。最后一个元素始终最

 新。

 入栈：arr.push(值);

 出栈：var last=arr.pop();

 开头入栈出栈：所有元素下标都会随入栈出栈操作而变化，第一个元

 素[0]始终最新。

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

 出栈：var first=arr.shift()

 例：

 var bus=[];

 for(var i=1;i<=5;i++){

 bus.unshift("乘客"+i);

 }

 document.write(bus+"<br>");

 while(bus.length>0){

 var customer=bus.shift();

 document.write(customer+"下车"+"<br/>");

 }

 二进制转换为十进制：拿这个数反复/2，保留每次的余数，相除结果

 为0结束。循环条件就是商不等于0，循环变量就是商。循环体是：上

 一次的商%1,存入数组，然后将商替换为商/2。

 例：

 var bin=[];

 var num=131;

 while(num!=0){

  bin.push(num%2);

  num=parseInt(num/2);

 }

 bin.reverse();  //数组的翻转

 document.write(bin.join(""));

 队列：先到的先得。FIFO

 凡是遇到需要排队才能做的事，都需要用队列。

 队列操作：其实就是栈队列中两种方法的组合

 入队列：arr.push(值);

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

 例：抢票程序：

 var count=5;

 var queue=[];

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

   queue.push("顾客"+i);

 }

 queue.push("你");

 document.write("当前排队顾客："+queue+"<br/>");

 while(count>0){

 var customer=queue.shift();

 document.write(customer+"抢购成功"+"<br/>");

 count--;

 }

 document.write(queue+"没抢上");

 二维数组：数组的元素又是另一个数组对象！

 创建二维数组：创建普通数组，完全一样！只不过将普通元素换为一

 个数组对象而已。

 比如：

 var arr=[1,2,3];     //创建普通数组

 var arr2=[[1,2,3],[4,5,6],[7,8]];  //创建二维数组

 var arr2[2]=[11,12,13];    //重新赋值二维数组元素值

 var arr2[2][1]=3;   //重新赋值第三个数组元素中的第一个元素值

 何时使用二维数组：数组包含明显上下级关系

 例：

 var arr2=[];

 arr2[0]=[101];

 arr2[1]=[201,202];

 arr2[2]=[301,302,303];

 var arr=arr2[1];

 document.write(arr2[2][1]);   //访问二维数组中第三个数组元素

 中的第一个元素值

 arr2=null;  //此时垃圾回收后，只剩一个数组arr2[1]，因为有一个

 东西arr已经在使用了，不能被释放

 arr=null;   //此时垃圾回收后没有数组了

 例：

 <script>

 var provs=['北京市','天津市','河北省'];

 var cities=[['朝阳区','海淀区','东城区'],['南开区','和平区','

 河东区'],['石家庄市区','保定市','廊坊市']];

 function getCitiesByProv(prov){

 //如何确定prov在provs中的下标？遍历比较

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

 if(prov==provs[i]){        //onclick北京市按钮的时候，把'北京

 市'赋值给了prove，然后查询provs中是否有和这个值相等的，相等的

 话就是输出provs中对应的下标，从何输出cities中的下标，关键就在

 于将provs[0]和cities[0]连接起来

 index=i;

 break;

 }

 }if(index!==undefined){      //此处的!==为什么是两个等号？

 console.log(cities[index].toString());

 }

 }

 </script>

 <button onclick="getCitiesByProv('北京市')">北京市</button>;

 //点击按钮，将'北京市'值传递给了prov

 <button onclick="getCitiesByProv('天津市')">天津市</button>;

 <button onclick="getCitiesByProv('河北省')">河北省</button>;

 上述例子可以用关联数组写成下面这样的：

 var provs=['北京市','天津市','河北省'];

 var cities={'北京市':['朝阳区','海淀区','东城区'],'天津市':['

 南开区','和平区','河东区'],'河北省':['石家庄市区','保定市','

 廊坊市']};

 function getCitiesByProv(prov){

 console.log(cities[prov].toString());

 }

 按名称查询数组的话，首选关联数组

 遍历二维数组：

 var cities=[['朝阳区','海淀区','东城区'],['南开区','和平区','

 河东区'],['石家庄市区','保定市','廊坊市']];

 先遍历下标为0的数组：

 for(var i=0;i<cities[0].length;i++){

  console.log(cities[0][i]);

 }

 遍历下标为1的数组：

 for(var i=0;i<cities[1].length;i++){

  console.log(cities[1][i]);

 }

 遍历下标为n的数组：

 for(var i=0;i<cities[n].length;i++){

  console.log(cities[n][i]);

 }

 n的范围：0<=n<cities.length

 遍历二维数组算法如下：

 var cities=[['朝阳区','海淀区','东城区'],['南开区','和平区','

 河东区'],['石家庄市区','保定市','廊坊市']];

 for(n=0;n<cities.length;n++){

  for(var i=0;i<cities[n].length;i++){

  console.log(cities[n][i]);

   }

 }

 内置对象：ECMAScript标准中已经定义好的，由浏览器厂商已经实现

 的标准对象。内置对象封装了专门的数据和操作数据常用的API.

 JavaScript中内置对象有：

 String,Boolean,Number,Array,Date,Math,Error,Function,Object,G

 lobal

 包装类型：专门封装原始类型的数据，并提供对数据常用操作的内置

 类型。

 JavaScript中的包装类型有三个：String类型,Number类型,Boolean类

 型

 如：

 var str="hello";   //原始类型数据，存栈中

 str+="world";

 console.log();

 原始类型的数据是不能进行任何操作的，要想执行操作只能用对象。

 只要用原始类型的数据调用方法或访问属性时，js引擎都会自动创建

 对应的包装类型对象。方法调用完，包装类型对象自动释放。

 var num=5.5;

 //var numObj=new Number(number);包装类，自动创建，自动释放

 num=num.toFixed(2);

 文本String:用于处理文本字符串

 创建原始类型字符串变量：

 var stuName='Smith';                //存在栈中

 var gender='男';                    //存在栈中

 var priceString=String(150.5);      //存在栈中

 创建引用类型字符串对象：

 var varType=new String('BMW528Li');  //存在堆中

 只要有new就是放在堆里,只有new可以在堆里创建对象

 转义字符：作用1.实现功能；2.解决冲突

 \b退格符,\n换行符，\r回车符，\t水平制表符，\'单引号，\''双引

 号，\\反斜线，\xNN由两位十六进制数NN指定Latin-1字符，\uNNN由

 四位十六进制数NNNN指定的Unicode字符

 字符串的使用：字符串一旦创建不可改变。

 String包装类型：

 特点：

 str.length:返回str字符串中的字符个数。

 比如：

 var str="hello马里奥";

 str.length;   //返回值是8，只管数个数

 大小写转换方法：不能直接修改原字符串，如果需要返回值需要用一

 个变量接住。

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

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

 何时使用：希望大小写一视同仁时，就要先转换，再处理，如验证码

 ，用户名，邮箱等等。

 例：

 var emails=[];

 var input=prompt("输入邮箱");

 emails.push(input.toLowerCase());

 input=prompt("输入第二个邮箱");

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

 if(input.toLowerCase()==emails[i].toLowerCase()){

 alert("该邮箱已被使用！");

 break;

 }

 }

 if(i==emails.length){

 emails.push(input.toLowerCase());

 alert("注册成功！");

 }