js写入的方式有两种

①引入外部的js—即引入index.js文件—-常用
image.png
②在html文件中写script
image.png

数据类型

弱类型自动推断类型

数字（number）
字符串（string）
布尔型（boolean）

null（空）&undefined（未定义）

注意：空和未定义不是一回事
null是有值但为空，undefined是根本没有被定义

定义变量—var&let（const定义常量）

弱类型—不需要申明这个变量的类型，统一用var

  1. <script>
  2.         // 数字
  3.         var num=3;
  4.         var money=20.5;
  6.         // 字符串
  7.         var str='hello';
  9.         // 布尔型
  10.         var flag=true;
  12.         // 空
  13.         var nul=null;
  15.         // 未定义
  16.         var person;
  18.         console.log('hello js')
  19.         console.log(num)
  20.         console.log(money)
  21.         console.log(str)
  22.         console.log(flag)
  23.         console.log(nul)//null
  24.         console.log(person)//undefined
  25.     </script>

注意：建议js中使用‘ ‘;
用var定义可以重复使用相同的名字，但是会被后者覆盖；用let定义不能重复，会报错,但是使用变量可以重新赋值；用const定义的变量不能被修改，且定义变量时必须要初始化。

  1. // 数字
  2.         let nums=3;
  3.         let nums=618;
  4.         console.log(nums)//会报错
  5.         nums=255; 
  8.         var num=100;
  9.         var num=200;
  10.         console.log(num)//输出结果：200

运算符

算术运算符( + - * / % )

  • 两边都先转换为number，再运算

    1. // + - * / %
    2. var a =3;
    3. var b = 3.3;
    4. var c = 4;
    5. console.log(a/c);//0.75
    6. console.log(a*b) // 9.899999999999999
    7. console.log(b/a) // 1.0999999999999999
    8. console.log(c%a) // 1

    比较运算符( >,<,==,>=,<=,!= )

  • 两边都先转换为number，再比较，返回的是 boolean

    1. var a = true
    2. var b = 1;
    3. console.log(a==b) // true
    4. console.log(a=="1") //true  两边都先转为number
    1. //在js中判断变量相等
    2. var a = '5';
    3. var b = 5;
    4. // 只要求内容相等，不要求数据类型相同
    5. console.log(a == b); //true
    6. // 要求内容相等，要求数据类型相同
    7. console.log(a === b); //false

  • 注意： null == undefined

null 和 undefined 不能转化为其他值
** Number(""),Number(" "),Number(null) => 输出 0**

  1. // Number(""),Number(" "),Number(null) => 输出 0
  2. console.log(false == ""); // true
  3. console.log(true == 1); // true
  4. console.log(null == undefined);  // true
  5. console.log(undefined == false);  // false
  6. console.log(1 == "1"); // true
  7. console.log(null == false); // false
  8. /* 1.只有有一边为 boolean 先两边转为number 
  9.    2.一边为string，一边为number，先将两遍转为number
  11.     // 两边都先转为number
  12.   3. null == undefined
  13.     4. null 和 undefined 不能转化为其他值
  14. */

逻辑运算符( &&，||，! )

  • 两边都先转换为boolean，再判断，返回的是 boolean值 ```javascript // && 逻辑与 两个为true，结果才为true // || 或 只要有一个为true，结果就为true // ! 非
    console.log(3>2 && 4>3) // true && true 结果为true console.log(3>2 && 4<3) // true && false 结果为false

console.log(11>5 || 3<4) // true || false 结果为true

console.log(!(3>4)) //!false 结果为true

  1. ```javascript
  2. /* var a = 0;
  3. var b = 1;
  4. console.log(a && b);//0
  5. console.log(b && a);//0
  7. console.log(a || b);//1
  8. console.log(b || a);//1 */
  10. var a = 3;
  11. var b = 1;
  12. console.log(a && b);//1
  13. console.log(b && a);//3
  15. console.log(a || b);//3
  16. console.log(b || a);//1

或运算的注意点

  • || 有一边为true,结果就为 true，遇到true就会返回

    1.               var b = 0 || "abc"
    2.       var c = "abc" || 1;
    3.       var d = 0 || NaN
    4.       console.log(b) // abc
    5.       console.log(c) // abc
    6.       console.log(d) // NaN

    与运算的注意点

  • **两边都为true，结果才为true 遇到false的情况，直接返回**

    1. console.log("abc" && 10)  // 10
    2. console.log(0 && "abc")   // 0

    三元运算符

    1. // true 输出问号后面的第一段语句
    2. // false 输出问号后面的第二段语句
    3. var a = (4>5)?"4大于5":"4小于5";
    4. console.log(a)

    赋值运算(+=，-=)

    1. // +=,-=
    2. var a = 2;
    3. //a=a+4;
    4. a+=4;
    5. var b = 4;
    6. b-=4; // b=b-4;
    7. console.log(a)   // 6
    8. console.log(b)   // 0

    数组—三种方式

    ①var array=Array();
    ②var array=new Array();
    ③var array=[1,2,3];

    1.    //数组
    2.      var array=Array();
    3.      array[0]=1;
    4.   //    console.log(array);//[1]
    5.       array[1]=618;
    6.       console.log(array);//[1,618]
    8.       var array=new Array();
    9.       array[0]=618;
    10.       console.log(array);//[618]
    12.       var array=[1,2,3];
    13.       console.log(array);//[1,2,3]
    15.       array[8]=8;
    16.       console.log(array);//[1, 2, 3, empty × 5, 8]
    18.       for(var i=0;i<array.length;i++){
    19.           console.log(array[i])
    20.       }

    方法—直接用function+方法名（）{方法体}

    注意：
    如果方法有返回值，直接在方法体中加入return；如果没有则不需要在意。
    参数不需要写类型

    1.       //方法1
    2.       function plus(a,b){
    3.           console.log(a+'+'+b+'='+(a+b))//1+4=5
    4.           return a+b;//有返回值
    5.       }
    7.       var c=plus(1,4)
    8.       console.log(c)//5
    10.       //方法2
    11.       var minus=function(a,b){
    12.           console.log(a+'-'+b+'='+(a-b))//1-4=-3
    13.           return a-b;//有返回值
    14.       }
    16.       minus(8,4);
    17.       var sc=minus(1,4)
    18.       console.log(sc)//-3
    20.       //方法3
    21.       ;(function(a,b){
    22.           console.log(a+'-'+b+'='+(a-b))//8-8=0
    23.           return a-b;
    24.       })(8,8)

    对象（Object）

    注意：
    js中{ }表示对象；[ ]表示数组。

    1. //对象
    2.       var dog=new Object();
    3.       //属性
    4.       dog.color='red';
    5.       // console.log(dog)//color: "red"
    6.       //方法
    7.       dog.eat=function(){
    8.           console.log('我要吃骨头')
    9.       }
    10.       dog.eat();
    11.       console.log(dog)

    构造方法

    1. //构造方法
    2.       function User(name,age){
    3.           //this相当于创建的对象user
    4.           this.name=name;
    5.           this.age=age;
    6.       }
    7.       var user=new User('嘎嘎',27);
    8.       // console.log(user)//User {name: "嘎嘎", age: 27}
    10.       //添加方法
    11.       user.eat=function(){
    12.           console.log('干饭啦')
    13.       }
    14.       //调用方法
    15.       user.eat();
    16.       console.log(user)

    json

    1.       //构造方法
    2.       //一个人养了一条狗
    3.       function User(name,age,dog){
    4.           //this相当于创建的对象user
    5.           this.name=name;
    6.           this.age=age;
    7.           this.dog=dog;
    8.       }
    10.       function Dog(name,color){
    11.           //this相当于创建的对象user
    12.           this.name=name;
    13.           this.color=color;
    15.       }
    16.       var dog1=new Dog('teddy','green');
    17.       var user=new User('嘎嘎',27,dog1);
    18.       // console.log(user)//User {name: "嘎嘎", age: 27}
    20.       //添加方法
    21.       user.eat=function(){
    22.           console.log('干饭啦')
    23.       }
    24.       //调用方法
    25.       user.eat();
    26.       console.log(user)

    数组中可以定义多个对象 ```java //构造方法

    1.   //一个人养了一条狗
    2.   function User(name,age,dog){
    3.       //this相当于创建的对象user
    4.       this.name=name;
    5.       this.age=age;
    6.       this.dog=dog;
    7.   }
    9.   function Dog(name,color){
    10.       //this相当于创建的对象user
    11.       this.name=name;
    12.       this.color=color;
    14.   }
  1.     //定义多条狗
  2.     var dogs=[
  3.         {
  4.             name:'teddy',
  5.             color:'red'
  6.         },
  7.         {
  8.             name:'teddy2',
  9.             color:'red'
  10.         }
  11.     ]
  12.     console.log(dogs)
  14.     //定义多个人
  15.     var users=[
  16.         {
  17.             name:'王嘉尔',
  18.             age:27,
  19.             hobbies:['唱歌','跳舞'],
  20.             dog:{name:'teddy',color:'gray'},
  21.             eat:function(food){
  22.                 console.log('多吃点'+food)
  23.             }
  24.         },
  25.         {
  26.             name:'白敬亭',
  27.             age:27
  28.         }
  29.     ]
  30.     // console.log(users[0])
  31.     console.log(users[0].hobbies[1])//跳舞
  32.     users[0].eat('肉');//多吃点肉
  34.     //添加一个游泳的方法
  35.     /* person.swmming=function(){
  36.         console.log('我会游泳')
  37.     } */
  39.     //遍历hobbies
  40.     for(var i=0;i<users[0].hobbies.length;i++){
  41.         console.log(users[0].hobbies[i])
  42.     }
  1. **方法中可以传入方法**
  2. ```java
  4.         var f1=function(){
  5.             console.log(111)
  6.         }
  7.         var f2=function(f){
  8.             f();
  9.         }
  10.         f2(f1);//111

判断与循环—与java一样

注意：undefined——false；
0———————false；
null——————false；
false—————-false；
‘ ‘(空字符串)—-false
除此以外都是真——[]（空数组）—true；{}（空对象）—true

if语句（略）

switch语句（略）

循环数组（略）

遍历对象属性

注意：
获取对象属性的方法：对象名.属性名；对象名[‘属性名’]；对象名[key]

  1.         //获取pig的值的方式
  2.         var pig={name:'teddy',color:'red'}
  3.         //第一种
  4.         console.log(pig.name);//teddy
  5.         //第二种
  6.         console.log(pig['name']);//teddy
  7.         console.log(pig.color);//red
  8.         //遍历
  9.         for(var key in pig){
  10.             //拿到pig对象的属性
  11.             console.log(key);//name，color
  12.             //获取值--第三种
  13.             console.log(pig[key])//name  teddy  color  red
  14.         }

遍历类数组

  1.         // 类数组
  2.         var obj={
  3.             0:123,
  4.             1:234,
  5.             2:456,
  6.             length:3
  7.         }
  8.         console.log(obj[0])
  10.         //遍历
  11.         for(var i=0;i<obj.length;i++){
  12.             console.log(obj[i])//123,234,456
  13.         }

内置参数—arguments

arguments表示传入的参数（可变参数）—本质上是一个数组

  1.         //内置参数
  2.         function name(){
  3.             //arguments-代表传入的参数（可变参数）--
  4.             //本质是一个数组
  5.             // console.log()
  6.             var sum=0;
  7.             for(var i=0;i<arguments.length;i++){
  8.                 // console.log(arguments[i])
  9.                 sum+=arguments[i];
  10.             }
  11.             return sum;
  12.         }
  13.         var i=name(1,2,3,4)
  14.         console.log(i)//10

内置对象

数组对象

数组的常用方法

  1. //数组对象
  2. let arr = [1, 2, 34, 56];
  4. //数组中有没有6
  5. console.log(arr.includes(6)); //false
  7. //连接
  8. console.log(arr.concat([2, 3, 4])); //[1, 2, 34, 56, 2, 3, 4]
  10. //获取数字对应的下标
  11. console.log(arr.indexOf(2)); //1
  13. //用-连接，返回的是一个字符串,jion方法不传参数默认的是，
  14. console.log(arr.join("-")); //1-2-34-56
  16. //从尾部添加4，返回的是新数组的长度
  17. console.log(arr.push(4)); //5
  18. console.log(arr); //[1, 2, 34, 56,4]
  20. //pop方法是从尾部删除元素
  21. console.log(arr.pop(4)); //弹出4
  22. console.log(arr); //[1, 2, 34, 56]
  24. //shift方法是从首位删除元素
  25. console.log(arr.shift()); //删除1
  26. console.log(arr); //[2, 34, 56]
  28. console.log(arr.shift(5)); //删除2
  29. console.log(arr); //[34, 56]
  31. //unshift方法从首位开始添加元素
  32. console.log(arr.unshift(618)); //添加618
  33. console.log(arr); //[618,34, 56]

数组的排序

  1. //数组的排序
  2. function sort(array, fn) {
  3.     for (var i = 0; i < array.length - 1; i++) {
  4.         for (var j = 0; j < array.length - 1 - i; j++) {
  5.             if (fn(array[j],array[j+1])>0) {
  6.                 var temp = array[j];
  7.                 array[j] = array[j + 1];
  8.                 array[j + 1] = temp;
  9.             }
  10.         }
  11.     }
  12. }
  13. var array=[1,2,8,4,3,2];
  14. console.log(array);//[1, 2, 8, 4, 3, 2]
  15. /*console.log(array);//[1, 2, 8, 4, 3, 2]
  16. sort(array);
  17. console.log(array)//[1, 2, 2, 3, 4, 8]*/
  18. sort(array,function(num1,num2){
  19.     //num1>num2,前面的比后面的大，就交换位置--正序
  20.     // return num1-num2;//[1, 2, 2, 3, 4, 8]正序
  21.     //num2>num1,后面的比前面的大，就交换位置--倒序
  22.     return num2-num1;//[8, 4, 3, 2, 2, 1]
  23. })
  24. console.log(array)

filter()方法和map方法

  1. //filter()--过滤--将数组中元素>10的过滤出来
  2. var myArr = [1, 2, 4, 5, 12, 2, 14, 5];
  3. console.log(myArr.filter(function (a) {
  4.     return a > 10;
  5. })) //12,14
  7. function filter(array, fn) {
  8.     var temp=[];
  9.     for (var i = 0; i < array.length; i++) {
  10.        if(fn(array[i])) {
  11.            temp.push(array[i])
  12.        }
  13.     }
  14.     return temp;
  15. }
  16. var array = [1, 2, 8, 4, 3, 2];
  17. console.log(array); //[1, 2, 8, 4, 3, 2]
  19. var f = filter(array, function (num) {
  21.     return num <= 5; //[1, 2, 4, 3, 2]
  22. })
  23. console.log(f)
  1. //map()方法--映射，将一个数组中的元素映射成一个新的元素
  2. function map(array, fn) {
  3.     var temp=[];
  4.     for (var i = 0; i < array.length; i++) {
  5.        temp.push(fn(array[i]))
  6.     }
  7.     return temp;
  8. }
  9. var array = [1, 2, 8, 4, 3, 2];
  10. console.log(array); //[1, 2, 8, 4, 3, 2]
  12. var f = map(array, function (num) {
  14.     return num +5; //[6, 7, 13, 9, 8, 7]
  15. })
  16. console.log(f)

字符串对象

数值对象

数学对象

日期对象

DOM编程—document—文档对象模型

元素节点

image.png
image.png
image.png
image.png
image.png
image.png

属性节点

image.png
image.png

BOM编程—browser—浏览器对象模型

常用方法

回调函数—之前的filter和map里面使用了

setTimeout—延时定时器&&setInterval—周期性定时器

  1. //一次性定时器--延时
  2. setTimeout(function(){
  3.     //延时一秒钟产生一个20-30之间的随机数
  4.     console.log(Math.random()*10+20)
  5. },2000)
  7. //周期性定时器
  8. setInterval(function(){
  9.     console.log(Math.random()*10+20)
  10. },1000)
  13. console.log('before');
  14. setTimeout(function(){
  15.     //延时一秒钟产生一个20-30之间的随机数
  16.     console.log('middle');
  17. },2000)
  18. console.log('after');
  19. 结果：before-->after-->middle（js是单线程，控制台会依次输出，
  20. 当执行到定时器，先执行后面的after，当时间到了就输出middle）
  23. var num=10;
  24. setTimeout(function(){
  25.     //延时一秒钟产生一个20-30之间的随机数
  26.     console.log(num);
  27. },2000)
  28. num=15;
  29. 结果：15

浏览器自带小型数据库—常用

image.png

history

image.png

事件

定义事件的三种方式—第一种最常用—单击事件—click

  1. //事件方式（1）--常用
  2. //拿到div--添加点击事件
  3. var btn=document.querySelector('.item');
  4. btn.addEventListener('click',function(){
  5.     //弹窗
  6.     // alert(1);
  8.     //重置
  9.     btn.setAttribute('class','newitem')
  10. })
  12. //第二种方式
  13. btn.onclick=function(){
  14.     alert(1);
  15. }
  17. //第三种方式--在div中添加onclick=""
  18. function fn(num){
  19.     alert(num);
  20. }

双击事件—dblclick

消除事件

image.png

事件分类

鼠标事件

image.png

键盘事件

image.png

表单事件

image.png

（文档、浏览器）对象事件

image.png

小案例

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <title>标签的主题</title>
  7.     <style>
  8.         *{
  9.             margin: 0;
  10.             padding: 0;
  11.         }
  12.         .nav{
  13.             list-style-type: none;
  14.             width: 1005px;
  15.             height: 50px;
  16.             text-align: center;
  17.             border-bottom: 1px solid black;
  18.             margin: auto auto;
  20.         }
  21.         .item{
  22.             width: 200px;
  23.             height: 50px;
  24.             list-style: none;
  25.             float: left;
  26.             background-color: green;
  27.             line-height: 50px;
  28.             border-right: 1px solid black;
  29.         }
  30.         .item:hover{
  31.             cursor: pointer;
  32.             background-color: mediumturquoise;
  33.         }
  34.         .active{
  35.             background-color: pink !important;
  36.         }
  37.     </style>
  38. </head>
  39. <body>
  40.     <ul class="nav">
  41.         <li class="item" data-index="1">服装</li>
  42.         <li class="item" data-index="2">鞋子</li>
  43.         <li class="item" data-index="3">电子产品</li>
  44.         <li class="item" data-index="4">裤子</li>
  45.         <li class="item" data-index="5">视频</li>
  46.     </ul>
  48. </body>
  49. <script src="./js/event.js"></script>
  50. </html>
  1. //添加事件--index2中的li
  2. var lis=document.querySelectorAll('.item');
  3. for(let i=0;i<lis.length;i++){
  4.     lis[i].addEventListener('click',function(){
  5.         for(let i=0;i<lis.length;i++){
  6.             lis[i].className="item";
  7.         }
  8.         this.className='item active';
  9.     })
  10. }
  12. //给ul添加事件
  13. var ul=document.querySelector('.nav');
  14. ul.addEventListener('click',function(event){
  15.     event.target.className='item active'
  16. })

事件冒泡与事件捕获—-先捕获再冒泡

this关键字

this的使用

注意：任何的方法里面的this都指向调用的这个方法的实例对象

  1. //this
  2. /* let dog={
  3.     name:'teddy',
  4.     say:function(){
  5.         //this指的是dog对象
  6.         console.log('my name is:'+this.name);//my name is:teddy
  7.     }
  8. }
  9. dog.say(); */
  11. /* function fn(){
  12.     setTimeout(function(){
  13.         //this指的是window
  14.         //注意：在window中不要使用name，因为window自带有name属性，是空串
  15.         console.log(this.name);
  16.     },1000)
  17. }
  18. fn(); */
  21. let dog={
  22.     name:'teddy',
  23.     //say是dog调用的
  24.     say:function(){
  25.         /* setTimeout(function(){
  26.             //funcion是window调用的，this指的是window
  27.             console.log('my name is:'+this.name);//my name is:
  28.         },1000) */
  30.         //使this.name=teddy，在function里面定义
  31.         //that指的是dog
  32.         var that=this;
  33.         setTimeout(function(){
  34.             console.log('my name is:'+that.name);//my name is:teddy
  35.         },1000)
  36.     }
  37. }
  38. dog.say();

改变this指向call，apply，bind

  1. /* let dog={
  2.     name:'teddy',
  3.     //say是dog调用的
  4.     say:function(){
  5.         //让this指向别的--call中的对象，打印结果是call对象中的属性值
  6.         var that=this;
  7.         setTimeout(function(){
  8.             console.log('my name is:'+that.name);//my name is:erha
  9.         },1000)
  10.     }
  11. }
  12. // dog.say.call({name:'erha'});
  13. // dog.say.apply({name:'erha'});//打印结果--my name is:erha
  15. //bind有返回值
  16. var fn=dog.say.bind({name:'erha'});//打印结果--my name is:erha
  17. fn(); */
  19. let dog={
  20.     name:'teddy',
  21.     //say是dog调用的
  22.     say:function(a,b){
  23.         //让this指向别的--call中的对象，打印结果是call对象中的属性值
  24.         var that=this;
  25.         console.log(a,b);
  26.         setTimeout(function(){
  27.             console.log('my name is:'+that.name);//my name is:erha
  28.         },1000)
  29.     }
  30. }
  31. dog.say.call({name:'erha'},12,23);//12 23  my name is:erha
  32. //apply要传数组
  33. dog.say.apply({name:'erha'},[45,67]);//45 67  my name is:erha
  35. var fn=dog.say.bind({name:'erha'},89,34);//89 34  my name is:erha
  36. fn();

作用域

  1. //函数作用域
  2. /* function fn(){
  3.     var num=3;
  4. }
  5. //外面的作用域不能访问里面的作用域
  6. console.log(num);//Uncaught ReferenceError: num is not defined */
  9. /* //块作用域
  10. //用var定义变量不会形成块作用域
  11. {
  12.     var num=3;
  13. }
  15. {
  16.     var num=4;
  17. }
  18. console.log(num);//4 */
  20. /* //用let定义变量会形成块作用域
  21. {
  22.     let num=3;
  23. }
  25. {
  26.     let num=4;
  27. }
  28. console.log(num);//Uncaught ReferenceError: num is not defined */
  31. /* for(var i=0;i<10;i++){
  33. }
  34. // console.log(i);//10
  36. for(;i<20;i++){
  37.     console.log(i);//10 11 ... 19
  38. } */
  40. /* //let不能重复定义；let定义的变量能形成独立的作用域
  41. for(let i=0;i<10;i++){
  43. }
  44. // console.log(i);//event.js:180 Uncaught ReferenceError: i is not defined */
  47. var num1=10;
  48. function f1(){
  49.     var num2=11;
  50.     function f2(){
  51.         var num2=12;
  52.         console.log('f2-->'+num2);//12
  53.     }
  54.     f2();
  55.     console.log('f1-->'+num2);//11
  56. }
  57. f1();
  58. // console.log('out'+num2);//event.js:195 Uncaught ReferenceError: num2 is not defined
  59. console.log('out'+num1);//10

变量和函数声明提升

  1. /* console.log(a);//undefined--a声明了没有被定义
  2. var a=10; */
  4. // console.log(a);//event.js:199 Uncaught ReferenceError: a is not defined
  6. //变量的声明提升--在执行过程中，会先声明var a;var b;
  7. /* console.log(b);//undefined--
  8. var a=10;
  9. var b=12; */
  12. //函数提升，变量提升
  13. //执行顺序：声明var a;声明函数ƒ a(){console.log(a);}-->调用a()-->console.log(a);-->a=10;
  14. a();
  15. console.log(a);////ƒ a(){console.log(a);}
  16. var a=10;
  17. function a(){
  18.     console.log(a);//ƒ a(){console.log(a);}
  19. }

闭包以及实现累机器和缓存

闭包使用

image.png

  1. //闭包累加器
  2. /* function count(){
  3.     var num=0;
  4.     return function(){
  5.         return num++;
  6.     }
  7. }
  8. var adder=count();
  9. console.log(adder());//0
  10. console.log(adder());//1
  11. console.log(adder());//2
  12. //释放内存空间，用完了就释放
  13. adder=null; */

原型

  1. //原型
  2. function User(name,age){
  3.     this.name=name;
  4.     this.age=age;
  5. }
  6. console.log(User.prototype);
  8. User.prototype.eat=function(){
  9.     console.log(this.name+'在吃饭');
  10. }
  12. User.prototype.gander='男';
  14. console.log(User.prototype);
  16. let user1=new User("嘎嘎",27);
  17. console.log(user1);
  19. let user2=new User("嘉尔",27);
  20. console.log(user2);

原型检测—instanceof

image.png

  1. //原型检测
  2. //判断user1是否是User
  3. console.log(user1 instanceof User);//true

类型检测—typeof

  1. //类型检测
  2. console.log(typeof('abc'));//string
  3. console.log(typeof(123));//number
  4. console.log(typeof(user1));//object
  5. console.log(typeof({}));//object
  6. console.log(typeof(true));//boolean
  8. let a=123;
  9. console.log(typeof(a)=='string');//false
  10. console.log(typeof([]));//object
  11. console.log(typeof(null));//object
  12. console.log(typeof(undefined));//undefined
  14. let b=[];
  15. console.log(b instanceof Array);//true

正则表达式

image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png