javascript

JS

一、开发环境

客户端——浏览器      服务器端——node.js

二、

1、变量

声明：var a=1,b=2；

命名规则：可由字母，数字，下划线，美元符号组成； 不能以数字开头； 不能使用关键字

赋值：声明后为赋值为undefind；   可以多次赋值，赋不同类型的值

node.js的计算规则：

2、常量

声明：const pi = 3.14;

常量也是用于存储数据的容器

常量一旦声明必须赋值，不允许重新赋值

三、数据类型：

分为原始类型和引用类型

原始类型：数值型、字符串型、布尔型、未定义型、空

（1）数值型

10进制

1   2   3   4   ...   7   8     9     10     11   12      ...   15    16

8进制:以0开头的数字，例如010

1   2   3   4   ...   7   10   11    12    13    14

16进制：以0x开头的数字，例如0xa , 不区分大小写

1   2   3   4   ...   7     8    9     10      a     b     ...      f      10   

浮点型：

314.15

314.1415e+1  (一位）

314.1415e+2  (两位）

typeof    检测数据类型 'number' 'string' 'boolean' 'undefined' 'object'

 

 

 

 

 

（2）字符串型

被引号包围的数据就是字符型，不区分单双引号

查看任意一个字符的编码: 's'.charCodeAt()

（3）布尔型

只有两个值：true /false表示真和假  表示只有两个结果的数据，例如是否登录，是否注册...

（4）未定义型

只有一个值undefined  属于一种空值

（5）空

只有一个值null

数据类型是object ；  常结合引用类型数据使用

 

四、数据类型转换

分为隐式转换和显式转换

1、隐式转换

（1）数字+字符串  数字转为字符串

2 + ‘1’   // ‘21’

（2）数字+布尔型   布尔型转为数值 true-1   false-0

1+true      //2

1+true      //1

（3）字符串+布尔型    布尔型转为字符串型

‘5’+true   //'5true'

练习：查看以下程序的运行结果

var a =2, b=true,c='tedu';

console.log(a+b+c);     //'3tedu'

console.log(b+c+a);    //'truetedu2'

console.log(c+a+b);    //'tedu2true'

加号（+）的作用： （1）加法运算 （2）字符串之间的拼接

 

 

 

 

//练习：假设从后端获取到了一个用户的用户名和手机号码，最后打印以下形式：
//欢迎：xxx     您当前绑定的手机号码是xxx
var username = 'xiaoling';
var phone = '18827788141';
console.log('欢迎：'+username+'  您当前绑定的手机号码是'+phone);

NaN :  Not a Number,不是一个数字，是在将数据转数值的时候转换失败的结果

隐式转换为数值自动的调用函数Number（）:

  2、强制转换

（1）强制转换为数值

//强制转换成数值
var c1 = Number(true);     //1
var c2 = Number(false);    //0
var c3 = Number('2');      //2
var c4 = Number('2a');     //NaN
var c5 = Number(undefined);//NaN
var c6 = Number(null);     //0

（2）强制转换成整型

parseInt（）

通常将小数或者字符串转换为整型，其他转换为NaN

//转整型
var d1 = parseInt(8.9);   //8
var d2 = parseInt('3.14');//3
var d3 = parseInt('6.18a');//6
var d4 = parseInt('a6.18');//NaN
var d5 = parseInt(true);   //NaN

（3）强制转换成浮点型

parseFloat（）

通常将字符串转为浮点型，其他的转换为NaN

//转浮点型
var e1 = parseFloat('5.18');  //5.18
var e2 = parseFloat('7a');    //7
var e3 = parseFloat('a3.14'); //NaN

（4）将布尔型和数值型转为字符串

tostring（）

//数值，布尔型转字符串
var num = 2;
num.toString();//产生一个新的字符串数据；‘2’

3、运算符：算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符、三目运算符

表达式：有数据或者运算符连接的操作数据组成的形式

（1）算术运算符：   整个算术运算符都会将数据隐式转换为数值型

++ 自增，在原来的基础上+1；       

--   自减 ，在原来的基础上-1；

 

 

var b = 2;
//先把b赋值给c ,然后b再自增
var c = b++;  



var d = 2;
//d先自增，再将自增后的值赋给e
var e = ++d;  

（2）比较运算符

>     <     >=     <=       ==（等于）     ！=      ===（全等于）   ！==（不全等于）

==（等于）：只是比较两个值是否相同，可能会发生隐式转换

===（全等于）：  先比较类型，再比较值

！=（不等于）：比较值不等于

！==（不全等于）：类型不同或者值不同

console.log(3 > '10a',3 < '10a', 3 == '10a');//false false false
console.log(NaN == NaN);//false

注意：NaN和任何值比较（>   <   >=   <=    ==   ===）结果都是false

（3）逻辑运算符

&& 逻辑与：关联的两个条件都是true结果是true,否则是false;

||  逻辑或，关联的两个条件有一个是true结果是true ，否则是false;     

！ 逻辑非 ，取反

 

短路逻辑：当执行第一个条件后不再执行第二个条件了，就会产生短路逻辑 

关注点在于第二个条件（表达式）是否执行：&&  当第一个条件为false就不再执行第二个条件

                                                                        ||   当第一个条件为true就不再执行第二个条件

练习： 查看以下程序是否报错

var  a = 5;

a > 5 &&  console.log(num);

a > 2  ||   console.log(num);

 

（4）位运算符

模拟计算机底层的运算，先将数据转为二进制，然后进行运算，当运算完再把结果转回成十进制

1       2         3        4             5         6          7     ......

1      10      11      100        101      110      111    ......

&   按位与:   上下两位比较，如果都是1，结果为1；否则是0

|     按位或：上下两位比较，如果含有1，结果为1；否则是0

^    按位异或：上下两位比较，不同为1；相同为0

>>  按位右移：删除末尾的数字

<<  按位左移：在末尾补0

5   &   7                                                           8  |  13                                                7   ^  12                              32  >> 1                        16  <<  1

   101                                                               1000                                                    0111                                  100000                         10000

& 111                                                             |  1101                                                 ^ 1100                                    10000                         100000

   101                                                                1101                                                    1011

 

（1）思维导图

（2）声明变量保存任意一个年份 判断是否闰年，如果是闰年，用短路逻辑打印‘闰年’   （被4整除但不能被100整除或者能被400整除）  四年一闰，百年不闰，四百年再闰

（3）预习if...else...

 

 

 

 

（5）赋值运算符

赋值：=     

运算赋值：先执行运算，再执行赋值   +=      -=      *=      /=      %=      ...

练习：声明变量保存商品的价格，让该商品在原来的基础上打九折，最后打印价格。

 

（6）三目运算符

一目运算符：由一个运算符连接的一个操作数据或者表达式  ++  --  ！

二目运算符：由一个运算符连接的两个操作数据或者表达式

三目运算符：由两个运算符连接的三个操作数据或者表达式

条件表达式      ？   表达式1     ：     表达式2

如果条件表达式为true执行表达式1

如果条件表达式为false执行表达式2

 

 

 

五、逻辑结构

alert()       弹出警示框

promot()   弹出提示框（输入框），需要使用变量保存用户输入的值，类型是字符串型，如果直接点击取消返回null。如果什么也没输入点击确定得到的是空字符串（''）

 

程序 = 数据 + 算法

程序的执行方式： 顺序执行、选择执行、循环执行

 

1、流程控制（选择执行）   

（1）if

                                                                              

if（条件表达式）{

语句块

}

 

 

 

 

如果if后的语句块中只有一行代码，则大括号可以省略

以下数据作为条件表达式会隐式转换为false： 0    ' '      undefined      null      NaN

练习：声明变量保存用户的签名内容，如果签名内容为空设置默认内容为：‘这家伙很懒，什么也没留下’，最后打印这行内容

 

（2）if ——else语句

if （条件表达式）{

语句1

}else{

语句2     }

 

 

 

 

 

（3）if - else嵌套

if（条件表达式1）{

语句1

}else（条件表达式2）{

语句2

}else （条件表达式2）{

                                          

 

 

（4）switch-case 语句

switch（表达式）{

case 值1：

     语句1；

     break;

case 值n：

     语句n；

    break;

default:

     语句n+1;

}

 

 

 

对比if-else嵌套和switch-case的区别

相同：两者都可以用于多项判断

不同：if-else 既可以进行等于，也可以进行不等于的比较；switch-case 只能进行全等于的比较；

           if-else的适用范围更加广泛，switch-case结构更为清晰，执行效率更高。

 

 

 

练习：（1）复习今天内容，整理思维导图

           （2）弹出两次提示框分别输入商品的单价和数量，计算出总价，如果总价满1000元打九折，假设会员卡内有余额1200，

                    如果足以支付，警示框弹出'pay success'，否则警示框弹出'pay error'。

 

2、循环

 

循环是一遍又一遍执行相同或相似的代码

循环两要素 ：       循环条件: 控制循环是否要继续执行

                              循环体：  要执行的相同或者相似的代码

（1）while循环

while(循环条件）{         循环体 }

                            

 

（2）break语句   

 在循环体中使用，用于强制结束循环

 

（3）do-while语句

 

do{ 循环体 }while（循环条件）

                     

 

（4）for 循环

for （初始值；循环条件；增量）{    循环体 }

                                                                                                        

（5）break 和 continue

break:  强制结束循环，后续不再执行任何循环中代码

continue: 跳过剩余的循环体，后续还会执行其它代码

 

（6）循环嵌套

在任意一个循环体中，包含了其它的循环

任意两个循环都可以相互嵌套

*****

*****

*****

*****

*****

 

 

 

课后练习

（1）复习 ，思维导图

（2）

打印2000~2100之间前10个闰年

声明变量保存任意一个数字，查看该数字是否为素数   打印‘是素数’或‘不是素数’

使用循环嵌套打印乘法口诀表

 

 

 

 

 

六、函数

函数

变量的作用域

函数的作用域

递归

1.函数

 Number()/parseInt()/parseFloat()/alert()/prompt()...

 函数分为系统函数和自定义函数

 函数：是一个功能体，需要提供若干个数据，返回处理的结果；用于封装重复执行的代码

 (1)创建普通函数

function 函数名称(){

函数体 —— 要封装的重复执行的代码

}

                             调用函数

                                          函数名称()   //执行函数体中封装的代码

  

 

练习：创建函数getSum，在函数体中封装计算1~100之间所有整数的和并打印结果；调用多次

//练习：创建函数getSum（） 在函数体中封装计算1~100之间所有整数的和并打印结果；调用多次
function getSum(){
    for (var i =1,sum = 0; i <= 100; i++){
           sum += i;
    }
    console.log(sum);
}
//调用函数
getSum();
getSum();

 (2)创建带有参数的函数

function  函数名称(参数列表){

函数体

}

                                  调用

                                   函数名称(参数列表)

                                    创建函数时的参数称作形参，调用函数时的参数称作实参，实参会赋值给形参，

                                    实参数量可以和形参的数量不匹配，如果形参未被赋值则为undefined。

  练习：创建函数getSum，计算1~任意数字之间所有整数的和，调用多次

//练习：创建函数getSum（）计算1~任意数字 之间所有整数的和，调用多次
function getSum(n){
    for (var i =1,sum = 0; i <= n; i++){
           sum += i;
    }
    console.log(sum);
}
//调用函数
//getSum(3);
//getSum(4);

  练习：创建函数getRun，传递任意两个年份，统计出两个年份之间所有闰年的个数，调用多次

//练习：创建函数grtRun,传递任意两个年份，统计出两个年份之间所有闰年的个数，调用多次
function getRun(n1 , n2){
    //循环得到年份
    for(var i = n1,count = 0; i<=n2; i++){
        //判断年份是不是闰年
        if(i % 4 ===0 && i % 100 !== 0 || i % 400 ===0){
            count ++;
            console.log(i);
        }
      
    }
    
    console.log(count);

}
//getRun(2000,2010);

 (3)创建带有返回值的函数

function 函数名称(参数列表){

函数体

return 值; //返回值，返回函数调用后的结果

}

                   调用

                  函数名称(参数列表)

                   return用于返回函数调用后的结果，如果函数中没有return或者return后不加任何值则返回undefined

                      一旦return执行就会跳出函数，结束函数的执行。

 

  练习：创建函数getMax，传递任意两个数字返回最大值

  练习：创建函数getMax2，传递任意三个数字返回最大值

//练习：创建函数getMax（），传递任意两个数字返回最大值。
function getMax(a,b){
     return a > b ? a : b;
}
var res = getMax(12,10);
//console.log(res);

//练习：创建函数getMax（），传递任意三个数字返回最大值。
function getMax2(m, n, v){
    /*if(m>n && m>v){
        return m;
    }else if(n>v){
        return n;
    }else{
        return v;
    }
    */
   var max = m > n ? m : n;
   return max > v ? max : v;
}

var res = getMax2(7,5,8);
//console.log(res);

  练习：创建函数getStatus，根据订单的状态码返回对应的汉字状态

  1-等待付款   2-等待发货   3-运输中  4-已签收  5-已取消  其它-无法追踪

   使用switch-case判断

//练习：创建函数Status，根据订单的状态码返回对应的汉字状态
//1-等待付款  2-等待发货  3-运输中  4-已签收  5-已取消    其他-无法追踪
function getStatus(n){
    switch(n){
        case 1:
            return '等待付款';
            break;
        case 2:
            return '等待发货';
            break;
        case 3:
            return '运输中';
            break;   
        case 4:
            return '已签收';
            break;   
        case 5:
            return '已取消';
            break;
        default:
            return '无法追踪';

    }
}

var status = getStatus(3);
console.log(status);

对比break和return

break用于循环和switch-case语句中，跳出所在的这组语句

return用于函数中，跳出函数，结束函数的调用

  练习：创建函数isPrime，传递任意一个数字，检测是否为素数，返回布尔型的值。

//练习：创建函数isprime,传递任意一个数字，检测是否为素数，返回布尔型的值
function isPrime(n){
    //排除1
    if(n === 1){
        return false;
    }

    //检测是否为素数
    // 如果有能被整除的数字就不是素数
    for (var i = 2; i < n; i++){
        if( n % i ===0){
            return false;   //遇到能被整除的返回false
        }       
    }
    //循环结束，没有被整除的，返回true
    return true;
}
var res = isPrime(7); 
console.log(res);           

  练习：创建函数isRun，传递人一个年份，检测是否为闰年，返回布尔型的值

 

2.变量的作用域

 全局变量：在全局作用域下声明的变量，可以在任意的作用域下访问到

 局部变量：在函数作用域下声明的变量，只能在当前的作用域下访问到

 在函数内不加var声明的变量是全局变量，不推荐，后期再严格模式下会报错。

 在程序执行前，会将var声明的变量提升到所在作用域的最前边，只是提升声明，不提升赋值

 

 

 

3.函数的作用域

 全局函数：在全局作用域下创建的函数，可以在任意作用域下调用

 局部函数：在函数作用域下创建的函数，只能在当前作用域下调用

 

函数提升：程序执行前会将函数提升到所在作用域 的最前边

 

斐波那契数列

第1、2项固定是1，从第3项开始每项的值是前两项相加的和

1   1   2   3   5   8   13   21

课后任务                                                                                                                                         

 (1)复习今天内容，整理思维导图

 (2)练习：创建函数fib，传递任意一个数字，返回斐波那契数列下某一项的值   

          

     fib(6) -> 8   fib(7) -> 13

    循环的方法

function fib(n){
    //第一项和第二项固定是1
    var n1 = 1,n2 = 1;
    //如果要求第n项的值，需要先求出第三项的值，然后一直往后求出每一项的值，到第n项
    for(var i = 3; i <= n; i++){
        //每一项的求法
        //n2 === 上一次n1 + 上一次n2
        //n1 ===上一次n2的值
        //n2代表求出的每一项的值
        var t = n2;
        n2 = n1 + n2;
        n1 = t;
    //打印每一项的值
    //console.log(n2);
    }
    //返回n2最后的结果，即所求的值；
    return n2;
}

 

 (3)预习递归、匿名函数、对象

 

4、递归

在一个函数的内部调用了这个函数

如何使用递归函数：

              要有边界条件

              结合着return使用，最后跳出函数

递归：https://www.codece.com/archives/102

练习：使用递归计算任意数字~1之间所有整数的乘积

//练习：使用递归计算任意数字~1之间所有整数的乘积 getCj(5)
function getCj(n){
    //边界条件
    if(n === 1){
        return 1;
    }
    //规律  第n项的值 = n * (n-1)项~1之间所有整数的乘积
    return n* getCj(n-1);
}
console.log( getCj(2) )

5、匿名函数

function（）{      }

（1）创建函数

函数声明 function fn（）{ }

函数表达式 变量名称就是函数名称 var fun =  function（）{ }

                                 调用：

                                           在匿名函数后面加上一个括号即可立即执行

                                            倘若需要传值，直接将参数写到括号内即可

 

 

 

对比函数名称（）和函数名称

函数名称（）：调用函数，得到函数的返回结果 

函数名称：本质上是一个变量，保存了一个函数

对比函数声明和函数表达式创建函数的区别

函数声明创建的函数存在函数提升，顺序上可以先写调用在写创建

函数表达式创建的函数只是存在变量声明的提升，必须先写创建再写调用

 

//练习：使用函数表达式创建函数，传递任意两个数字，返回两个数字之间所有整数的和

 

（2）匿名函数自调用

全局污染：全局变量的出现产生的影响

（function（）{

函数作用域下，变量是局部变量，可以防止污染全局

}）（）；

 

 

 

 

（3）回调函数

将函数以实参的形式传递，这个传递的函数称为回调函数

function tao (madai){

madai（） //调用传递进来的回调函数

}

function（）{       }

tao（dong）

tao（function（）{       }）

 

 

 

 

 

 

 

6、系统函数

is NaN（）  检测一个值是否为NaN   常用于检测用户输入的值是否含有非数字

                会将检测的值隐式转换为数值，然后查看是否为NaN，是->true    不是->false

isFinite（） 检测一个值是否为有限值  只有Infinity是无限值，其他所有值都是有限值

                     是有限值->true       不是有限值-> false

eval（）      执行字符串表达式（‘1+2’）

                     练习：弹出提示框，输入一组字符串表达式，使用eval执行输入这组表达式

七、对象

属于引用类型数据

对象是一组属性和方法                                  万物皆对象

1、分类：

自定义对象：用户自己创建的对象

内置对象（ES对象）：js中提供的对象

宿主对象：根据不同的执行环境划分

（1）自定义对象

创建方式：

对象字面量

      {属性名：属性值，属性名：属性值}

      属性名中的引号可以省略      如果含有特殊字符必须加上引号

练习:创建一个商品对象，包含的属性包括编号、标题、价格、是否在售、库存量；

访问属性：

对象.属性名

对象['属性名’]

如果属性名不存在则返回undefined

练习：创建图书对象，包含的属性有编号，书名、作者、价格；打印图书的价格，修改图书的价格，添加图书的出版社属性，打印对象

练习：创建图书对象，包含的属性有编号，书名、作者、价格；打印图书的价格，修改图书的价格，添加图书的出版社属性，打印对象
var book = {
    bid:10086,
    bookName:'兔子产后护理',
    auto:'Tao',
    price:179
};
console.log(book.bookName);
book.price = 199;
book['publish'] = '非洲出版社';
console.log(book);

 

（2）内置构造函数

创建一个空对象，需要单独添加每个属性

遍历属性：依次访问对象中的每个属性

for（var  key in 对象）{

//k  代表属性

对象【k】  属性名对应的属性值

}

（3）自定义构造函数

课后任务：

（1）思维导图，复习

（2）使用内置函数创建对象，添加若干个成绩，遍历对象得到每个成绩哦盘，最终计算出总成绩和平均成绩

（3）预习js中数组

 

 

 

（4）检验属性是否存在：

对象.属性名    === undefined        true->不存在      false->存在

对象.hasOwnProperty('属性名')          true->存在         false->不存在

（5）对象的方法

方法对应的是一个函数

var person = {

name:'涛哥',

play:function(){

this 指代调用方法的对象

}

}；

person.play()     //调用方法，play中的this指向person

 

练习：创建一个圆的对象，包含的属性有半径 和圆周率，添加计算周长和计算面积的两个方法，最后调用这两个方法。

练习：创建一个计算器对象，包含计算任意两个数字相加，计算任意两个数字相减的方法，调用两个方法。

//练习：创建一个圆的对象，包含的属性有半径 和圆周率，添加计算周长和计算面积的两个方法，最后调用这两个方法。
var circle = {
    //成员属性
    r:5,
    pi:3.14,
    //成员方法
    length:function(){
        return 2*this.pi*this.r;
    },
    area:function(){
        return this.pi*this.r*this.r;
    }
};
console.log(circle.length());
console.log(circle.area());

//创建一个计算器对象，包含计算任意两个数字相加，计算任意两个数字相减的方法，调用两个方法。
var calc = {
    //成员方法
    add: function(m,n){
        return m + n;
    },
    subtraction:function(m,n){
        return m - n ;
    },
};
//调用方法并打印计算结果
console.log(calc.add(27,5));
console.log(calc.subtraction(27,5));

 

（6）数据的存储

a.原始数据存储

直接存储在栈内存中

b.引用类型存储

将数据存储在堆内存中，同时会自动生成一个地址，然后把这个地址保存到栈内存中

引用类型数据占用内存较大，如果要销毁，没有任何地址可指向，就会自动销毁。直接赋值为null即可销毁。

 

 

 

 

八、数组

就是一组数据的集合，每个数据称为元素

（1）数组字面量

【元素1，元素2，...】

练习：创建数组，包含一组商品的名称

           创建数组，包含一组成绩

 

 

 

(2）数组下标

数组【下标】

数组下标默认从0开始，数组下标不存在默认为undefined

 

 

（3）数组长度

数组.length    获取数组元素的个数

数组【数组.length】 = 值；      可以在数组的末尾添加元素

练习：创建一个空数组，使用长度属性不断添加元素

//练习：创建一个空数组，使用长度属性不断添加元素
var array = [];
array[array.length] = 0;
array[array.length] = 1;
array[array.length] = 2;
array[array.length] = 3;
console.log(array)
console.log(array.length)

 

（5）内置构造函数

new Array（元素1，元素2...）

new Array（3）  创建数组，初始化数组长度为3，可以添加更多个元素

练习：创建数组，包含多个国家

           创建数组，初始化长度为5，添加篮球场上的5个位置。

       大前锋       小前锋    中锋      控球后卫     得分后卫

//练习：创建数组，包含多个国家
var country = new Array('日本','印度','瓦坎达');

 //          创建数组，初始化长度为5，添加篮球场上的5个位置。

 //      大前锋       小前锋    中锋      控球后卫     得分后卫

var basketball = new  Array(5);
basketball[0]='大前锋';
basketball[1]='小前锋';
basketball[2]='中锋';
basketball[3]='控球后卫';
basketball[4]='得分后卫';
console.log(basketball)

（6）遍历数组

for（var k in   数组）{

    k  代表下标

    数组【k】   下标对应的元素

}

循环

for（var i = 0；i <= 数组.length;  i++）{

i   代表下标

数组 【i】   下标对应的元素

}

练习：创建数组，包含一组成绩，将所有成绩在60分以下加10分；打印数组

var score =[81,54,71,58,63];
//遍历数组，得到每一个成绩
for(var k in score){
    //判断成绩是否在60分以下
    if(score[k] < 60){
        score[k] += 10;
    }
}
console.log(score);

  练习：创建数组，包括含所有学生的成绩，遍历数组，计算总分和平均分

var score =[81,54,71,58,63];
for(var i = 0,sum = 0; i < score.length; i++){
    sum += score[i];
}
console.log(sum);
console.log(sum/score.length);

 

课后任务：

（1）复习，思维导图

（2）练习

创建数组，遍历数组，翻转数组中的元素；

【‘a’,‘b’, ‘c’, ‘d’】->【‘d’,‘c’,‘b’,‘a’】

//创建数组，遍历数组，翻转数组中的元素
var str = ['a','b','c','d'];
var str2 = [];
//遍历数组
for(var i = 0; i < str.length; i++){
    console.log(str.length-1-i);
    str2[i] = str[str.length-1-i];
}
console.log(str2);

创建数组包含一组数字，遍历数组，将数字进行从小到大排序（冒泡排序））

【7  8   6  45  23】->【6,23 45 7 8】

//创建数组包含一组数字，遍历数组，将数字进行从小到大排序（冒泡排序））
var arr = [7,8,6,45,23];
//外层循环：控制循环的轮数
//0   5    4
//1   5    3
//2   5    2
//3   5    1
for(var i = 0; i < arr.length - 1; i++){
    //内层循环：控制每轮比较的次数
    //循环条件：
    //i        j
    //0 1轮   4次
    //1 2轮   3次
    //2 3轮   2次
    //3 4轮   1次
    for(var j = 0; j < arr.length-i-1;j++){
        //j代表当前元素的下标
        //j+1代表下一元素的下标
        //如果当前元素大于下一元素则交换位置
       if(arr[j] > arr[j+1]){
        var t = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = t;
       }
    }
}
console.log(arr);

API是指应用程序编程接口   js下指提供好的函数或者方法

2、数组API

toString():

reverse（）   翻转数组中的元素

sort（） 对数组进行排序，默认按照编码排序

sort（function（a,b）{           return a-b;//按照数字从小到大排列           // return b-a; //按照数字从大到小排列 }）

 

 

 

 

如何学习API:API的作用、有哪些参数、哪些参数可选，哪些参数必选，返回结果是什么

concat(arr2,arr3...)      拼接多个数组，arr2，arr3表示要拼接的数组，返回拼接后的数组

slice(start,end)    截取数组元素，start开始的下标，end结束的下标，不包含end本身；如果下标是负数表示倒数，返回截取的元素，格式为数组。

练习：创建数组包含a~f，每个字母是一个元素；分别截取bc,ef;最后将这两组数组拼接成一个新的数组。

var arr = ['a','b','c','d','e','f'];
//截取字符
var str1 = arr.slice(1,3);
var str2 = arr.slice(4);
console.log(str1,str2);
//拼接字符
var str3 = str1.concat(str2);
console.log(str3);

Splice（start，count，v1,v2...）  删除数组中的元素，start开始下标，count（可以为0，即直接添加元素），删除的数量，count为空删除到最后，下标是负数表示倒数；v1,v2...表示删除后补充的元素，返回删除的元素，原数组会发生变化

练习：创建数组包含a~h,删除cd，替换f为m,在下标为1的位置插入z

//练习：创建数组包含a~h,删除cd，替换f为m,在下标为1的位置插入z
var arr = ['a','b','c','d','e','f','g','h']
console.log( arr.splice(2,2));
console.log(arr.splice(-3,1,'m'));
console.log(arr.splice(1,0,'z'));
console.log(arr);

indexOf（）   查找数组中是否含有某个元素，返回找到的第一个下标，如果找不到返回-1

push（）   往数组的末尾添加元素，返回数组的长度

pop（）      删除数组末尾的一个元素，返回删除的元素

unshift（）  往数组的开头添加元素，返回数组的长度

shift（）      删除数组开头的一个元素，返回删除的元素

 

3、二维数组

用于对一组数据进行二次分类

【【元素1，元素2】，【】，【】，...】

访问：数组【下标】【下标】

 

 

 

九、字符串对象

包装对象目的是为了让原始类数据像引用类型数据，具有属性和方法，一共有三种包装对象：String、   Number  、 Boolean

new String（） 将数据转为字符串,返回对象

String（）    将数据转为字符串，返回字符串

1、转义字符 \

\'   将特殊意义的引号转义为普通引号

\n  将普通的字符n转义为换行符

\t   将普通的字符t转义为制表符（tab键效果）

练习：打印出‘c:\users\web’

//练习：打印出‘c:\users\web’
var str4 = 'c:\\users\\web';
console.log(str4)

2、API

length   获取字符串长度

charAt（下标）   获取下标对应的字符，也可以使用数组形式，字符串【下标】

面试题：统计一个字符串中出现做多的字符串及次数：

练习：声明变量保存字符串‘javaScript’,遍历字符串，统计出a字符出现的次数

//练习：声明变量保存字符串‘javaScript’,遍历字符串，统计出a字符出现的次数
var str = 'javascript';
//遍历字符串
for(var i = 0, count = 0; i<str.length; i++){
//判断任意一个字符是否为a
    if(str[i] === 'a'){
        count ++;
    }
    //console.log(str[i]);
};
console.log(count);

indexOf（）         查看是否含有某个字符串，返回第一次出现的下标，找不到返回-1

lastIndexOf（）   查看是否含有某个字符串，返回最后一次出现的下标，找不到返回-1

练习：声明变量保存用户输入的邮箱，如果邮箱中不含有@，打印‘邮箱格式错误’，否则打印‘邮箱格式正确’

//练习：声明变量保存用户输入的邮箱，如果邮箱中不含有@，打印‘邮箱格式错误’，否则打印‘邮箱格式正确’
var str = 'tao123@tedu.cn';
//判断是否含有@字符串
if(str . indexOf('@') === -1){
    console.log('邮箱格式错误');
}else{
    console.log('邮箱格式正确');
}

slice（start，end）   截取字符串，start开始的下标，end结束的下标，不包含end，如果end为空会截取到最后，如果是负数表示倒数，返回截取到的字符串

//练习：声明变量保存邮箱，分别截取出邮箱的用户名和域名   tao123@tedu.cn

//练习：声明变量保存邮箱，分别截取出邮箱的用户名和域名
var email = 'tao123@tedu.cn';
//先查找@字符的下标
var index = email.indexOf('@');
console.log(index);
var username = email.slice(0,index);
var domain = email.slice(index+1);
console.log(username,domain);

substr（start，count）按照长度截取字符串，start开始的下标，count截取的长度，如果count为空截取到最后，如果下标是负数表示倒数，返回截取到的字符串

练习：声明变量保存一个人的身份证号，分别截取生日中的年月日和性别，

最后打印格式：xxxx年xx月xx日  性别x

 

     110235197307151870

//练习：声明变量保存一个人的身份证号，分别截取生日中的年月日和性别，

//最后打印格式：xxxx年xx月xx日  性别x

 //    110235197307151870
var id = '110235197307151870'
var year = id.substr(6,4);
var month = id.substr(10,2);
var day = id.substr(12,2);
var sex = id.substr(-2,1);
//判断性别
var s = sex%2 === 1 ? '男' : '女';
console.log(year + '年' + month +'月' + day + '日'+ '  ' + '性别' + s )

toUpperCase（）  英文字母转大写

toLowerCase（）  英文字母转小写

split （字符） 将字符串按照指定的字符分割为数组

练习：上传文件——1.jpg    ->  .jpg

 截取文件名称的后缀名    web.2014.tao.jpg

//截取文件名称的后缀名    web.2014.tao.jpg
var str = 'web.2014.tao.jpg'
var arr = str.split('.');
console.log(arr);
//打印最后一个元素
console.log(arr[arr.length-1]);

十、Math对象

不需要new来创建对象，可以直接使用对象下的API

PI:   获取圆周率

abs（） 获取绝对值

ceil（） 向上取整

floor（）向下取整

round（） 四舍五入取整

random（）获取随机，范围 >=0    <1

 pow(x, y)  计算x的y次方

 max()   获取一组数字的最大值

 min()  获取一组数字的最小值

 

 

课后任务：

（1）复习，思维导图

（2）练习：

将一句英文中每个单词的首字母大写，其余字母小写

hOw aRe yOU   ->     How  Are   You

//将一句英文中每个单词的首字母大写，其余字母小写

//hOw aRe yOU   ->     How  Are   You
var str = 'hOw aRe yOU'
//将字符串按照空格字符分割为数组
var arr = str.split(' ');
//console.log(arr)
//循环遍历数组
for(var i = 0; i < arr.length; i++){
    //截取数组首字母转大写
    var s = arr[i].slice(0,1).toUpperCase();
    //截取数组剩余字母转小写
    var o = arr[i].slice(1).toLowerCase();
    //重新拼接
    arr[i] = (s+o);
}
console.log(arr.join(' '));

随机获取a~z之间的四个字母   放到一个新数组

格式：【‘b’,'c','z','t'】

（3）预习js第九天，重点Date对象

 

 

双色球

红球：在1~33之间随机取6个，不能重复，放入到数组，进行从小到大的排序

蓝球：在1~16之间随机取1个，这个数字可以和之前的红球重复，放入到数组

  [2 ,3, 9, 20, 30, 33, 9]

 

十一、Date对象

 用于对日期时间的存储和计算

 (1)创建

  new Date('2021/5/18 10:27:30')

  new Date(2021,4,18,10,27,30)  月份0~11 对应1月~12月

  new Date()   存储当前操作系统的时间

  new Date(1608336000000)   存储的是距离计算机元年的毫秒数，会产生一个具体的日期时间

    计算机元年：0时区1970-1-1 0:0:0

 (2)获取存储的日期时间

  getFullYear/getMonth/getDate

     获取的月份0~11   对应1~12月

  getHours/getMinutes/getSeconds/getMilliseconds毫秒

  getDay  获取星期 0~6  对应星期日~星期六

  getTime  获取距离计算机元年的毫秒数

  练习：创建Date对象，保存当前操作系统的时间，获取日期时间，打印以下格式     今天是xxxx年xx月xx日 xx时xx分xx秒  星期二

 (3)转为本地字符串格式

  存在兼容性问题，常用于调试

  toLocaleString()   日期+时间

  toLocaleDateString()   日期

  toLocaleTimeString()   时间

 (4)设置日期时间

  修改Date对象中存储的日期时间

  setFullYear/setMonth/setDate

   月份1~12  对应的值  0~11

  setHours/setMinutes/setSeconds/setMilliseconds

  setTime   设置距离计算机元年的毫秒数，产生一个具体的日期

 (5)拷贝Date对象

   var d1 = new Date();

   var d2 = new Date(d1); //拷贝d1对象

  练习：创建Date对象，保存'2020/5/20'，作为入职时间；拷贝入职时间的对象作为到期时间，设置合同期为3年(3年后)；分别打印两个对象的本地字符串格式。

十二、Number对象

 new Number()  将数据转为数值，返回对象

 Number()   将数据转为数值，返回数值

 toFixed(n)  保留小数点后n位

 toString(n)  将数值转为字符串，可以设置显示的进制

十三、Boolean对象

 new Boolean()  将数据转为布尔型，返回对象

 Boolean()  将数据转为布尔型，返回布尔型

 !!  隐式转换为布尔型  

    !!null   ->  false

十四、错误处理

 (1)常见的错误

  语法错误(SyntaxError)：不符合语法规范，例如出现中文的符号，缺少半块括号

  引用错误(ReferenceError)：使用了未声明的变量

  类型错误(TypeError)：把一个非函数当做函数调用

  范围错误(RangeError)：数据的使用超出了JS的规定范围

  自定义错误：程序员自己制定的错误

     throw  错误内容

 (2)错误处理

  在运行过程中产生的错误，不再影响后续代码的执行

try{   尝试执行，可能产生错误，一旦产生会被catch捕获 }catch(err){   将错误信息放入到err中，不再影响后续代码执行   进行错误处理 }

课后任务

 (1)复习今天内容，整理思维导图

 (2)练习

   创建函数，传递任意一个日期，返回这一天是一年中的第几天

     例如  getDays(2021,5,18)

 

 (3)预习nodejs第一天