2021-11-22

一、js引入位置

1.行内式：直接在HTML属性中写JavaScript代码

1.1没有默认行为的html标签

    <div onclick="alert('helloworld')">点击我</div>

1.2有默认行为的html标签

    <a href="javascript:alert('百度')">百度</a>

2.内嵌式

    <script type="text/javascript"> alert('内嵌式引用js代码')</script>

3.外链式

     <script type="text/javascript">alert('内嵌式引用js代码')</script>
     注:位置 body结束标签前

二、js注释

单行注释：Ctrl+/

多行注释：Ctrl+shift+/

三、变量

1.创建一个变量：

   var  变量名

2.变量作用：存储数据的容器值变化量

3.变量命名规则

3.1 变量名必须由数字、字母、下划线、$组成

3.2不能用数字开头

3.3不能使用关键字和保留字

3.4不能使用空格

4.变量命名规范

4.1变量名要有意义

4.2 使用驼峰命名（多个单词，除第一个单词外，其余单词首字母大写）

5.变量赋值

   var num = 100

6.访问变量

 console.log(变量)

四、数据类型（基本数据类型、复杂数据类型又称对象类型或引用类型）

1.基本数据类型

1.number  数值--一切数字都是 数值类型，NaN是一个数字值，非数字值
2.string    字符串--用引号引起来的值
3.Boolean    布尔类型--只有两个值true和false
4.null       空类型--值为null
5.undefined  未定义类型--值为undefined

2.复杂数据类型（对象类型或引用类型）

1.Object
2.Array

3.检查数据类型

 语法 typeof 变量
console.log(typeof 变量)  
     例：
     var num = 100  //创建一个名为num的变量，赋值100
        console.log('num :', typeof num )

4.数据类型的转换

4.1 其他类型->数值类型

语法： Number（变量）->返回值类型变量
''->0
'100'->100
'hello'->NaN
true->1
false->0
parseInt(变量)--返回数值类型变量---可用于取整
'100'->100
'100.25'->100
'hello'->NaN
‘100scff’->100
parseFloat(变量)--返回数值类型变量
‘3.25’->3.25

4.2其他数据类型->字符串

语法：String（变量）---返回字符串类型
100->'100'
true->'true'
undefined->报错，不能转换 
null->报错

4.3其他数据类型->布尔类型

number
string     -->boolean
undefined
null
	
		
		
			   Boolean(变量) 
		

		
			          =>返回布尔类型值 
		

		
			          100 -> true 
		

		
			          0   -> false 
		

		
			          'hello' -> true 
		

		
			            ''   -> false 
		

		
			          undefined -> false 
		

		
			          null -> false

4.4 连接符 +
五、数学运算符

1. +

如果有一边是字符串，进行字符串连接

2. -

=> 两边都是数值类型，进行减法运算，

=> 如果有一边是字符串，进行隐藏转换，将字符串转成数值再运算

3. * / %

=> 两边都是数值类型，进行运算，

=> 如果有一边是字符串，进行隐藏转换，将字符串转成数值再运算

4.赋值

== ===

比较值恒等比较值和数据类型

5.逻辑运算符

 5.1、&& 逻辑与
            => 并且， 左右两边都成立时，表达式才成立，返回true
                      只要有一个不成立，返回false
           
           true && false -> false
           true && true -> true
           注： 一般用于判断两个条件是否同时成立

        5.2、 || 逻辑或
            => 或者   左右两边只要有一个成立，表达式成立， 返回true
                      都不成立，返回false
            false || false -> false
            true || false -> true
        5.3、   ！  逻辑非
            !true -> false
            !false -> true

          注： 比较运算的结果是布尔值

6、自增自减运算

自增自减
          自增 ++
           => 自身加一
           => var num = 100
              num++  // 101 
          自减 --
           => 自身减一
              var num = 100
              num--

         ++在前和在后的一个区别
           参与其它运算，
           var m = 100
           var n = m++    //加加在后，表示先运算再加一
                        n:100  m:101
                     n = m  
                     m = m + 1

           var n = ++m   //加加在前， 表示先加一，再运算
                   m = m + 1
                   n = m

7.检查非数值

  NaN  (not a number)
        number   100
                  NaN
        
        var n1 = 100  
         
        isNaN(变量)
          => true|false
          => 如果变量是非数字符返回true,否则返回false

2021-11-23

一、程序

程序=语句+数据结构+算法

二、条件语句 | 逻辑分支语句

if语句
              语法:  if(条件){
                        代码块
                     }

                     如果(条件成立){
                         执行代码
                     }

            if-else语句
               语法:  if(条件){
                         代码块1
                      }else{
                          代码块2
                      }
            if-else-if语句
                  if(条件1){
                      代码1
                  }else if(条件2){
                      代码2
                  }else{

                  }

三、多分支Switch语句

语法:
            switch-case 多分支语句
            
            switch(表达式){
                case 值1:        //分支1
                   语句块1
                   [break]    //结束switch
                case 值2:
                   语句块2        //分支2
                   [break]
                case 值3:
                   语句块3        //分支3
                   [break]
                case 值4:
                   语句块4        //分支4
                   [break]
                [default:]
                   默认语句       //默认分支
            }

四、三元运算符

		
		
		
		
		
			
			
				 条件表达式? 表达式A ： 表达式B 
			

			
				          如果条件表达式为真，执行表达式A的值，否则执行表达式B的值  
			

			
				        if(条件表达式){ 
			

			
				            表达式A 
			

			
				        }else{ 
			

			
				            表达式B 
			

			
				        }

五、单步调试

1.作用：调试程序错误Bug

2.目的：方便理解程序语句执行的顺序规律

2021-11-24

一、循环语句

1.while循环

while（条件）{
    循环体
}

2.do-while循环

do{
    循环体
}while（条件）

3.for循环

for（初始化值;循环条件；改变条件）

1.初始化值。赋值给一个循环变量
2.循环体有改变条件语句
3.循环条件
4.循环体执行代码

二、跳转语句

1.break

作用：再循环体语句中使用，用于终止循环，结束整个循环

2.contiune

作用：再循环体中使用，结束本次循环，继续下一次循环，在contiune语句后面的代码不会执行

2021-11-25

一、函数

1.函数：任意代码的封装，可以任意时候调佣

2.语法：

function 函数名（）{
    封装代码
}

3.使用函数需要调用函数

语法：
   函数名（）  //函数调用语句

3.函数参数

function 函数名（形参）{  //多个形参用逗号隔开
    封装函数
}
函数名（实参）//多个实参之间用逗号隔开

二、return语句

作用
  1.结束函数执行，返回到函数调用处（在函数体中使用）
  2.将值反回给函数调用语句

三、函数类型

 1. 无参无返回值
           function fn(){
              //函数体
           }
           fn()
        2. 有参无返回值
           function fn(x){
               //函数体
           }
           fn(10)
        3. 无参有返回值
           function fn(){
               return 值
           }
           var f = fn()

        4. 有参有返回值
            function fn(m){
               return 值
           }
           var f = fn(10)

三、传参

        形参与实参个数不相同是时，怎么处理?
            如果形参多了， 多的形参默认值是 undefined
            如果实参多了， 多的实参不起作用

四、参数默认值

 <script>
        function fn(m){
            m = m || 100  // 参数默认值设置方式
            
            console.log('m :',m);
        }

        fn(21)

    </script>
</body>

五、定义函数的方式

        // 声明式定义一个函数
        function fn([形参...]){
            函数体
        }

        fn()
        
        // 赋值式定义一个函数
        var fn = function([形参...]){
            函数体
        }

        声明式与赋值式 区别：
          赋值式定义函数，必须先定义再使用，
          声明式定义函数，调用没有先后限制

六、预解析

1.声明式函数提到代码最上面
2.var 声明的变量提到代码最上面

当遇到同名函数和变量时，预解析优先处理函数
	
		if语句块不管条件是否满足都会执预解析
	

	
		return语句后的代码也会执行预解析

2021-11-26

一、变量作用域

1.全局作用域：函数最外层定义的变量

2.局部作用域：函数体中定义的变量

3.变量使用规则：在自己作用域范围查找。如果自己的作用域没有，在上一级作用域查找，如果上一级没有，到全局作用域查找，全局作用域没有查找到，直接报错

4.作用域链：变量访问或赋值时，现在自己的作用域查找，如果没有找到，在一层一层向上查找，直到最外层全局作用域。这种层层查找关系，叫做作用域链

二、递归

1.递归：函数体内自己调用自己，这样的函数称为递归函数

2.写递归是，要避免死递归

1.一定要有结束递归的条件
2.递归层层调用后，按原路层层返回

三、简单对象

1.创建一个对象

var 对象名={
    属性名1：属性值1，
    属性名2：属性值2，
        方法名1：function（）{
        
    }，
        方法名2：function（）{
        
    }
}


访问对象的属性和方法
        对象名.属性名
        对象名.方法名()

四、对象创建方法

        语法:  
           var obj = {} //字面量方式

           var obj = new Object() // 通过new语句调用构造函数方式创建对象
           obj.name = '小明'
           obj.age = 22
           obj.say = function(){
               //代码
           }

week1

2021-11-22

2021-11-23

2021-11-24

2021-11-25

2021-11-26