1.引用数据类型之数组Array类

  • 1、每一个数组的外层由中括号进行包裹
  • 2、数组和对象一样都是由键值对组成，键值对的属性名是由浏览器自动生成的，从0开始依次递增，属性值就是你在数组里写的每一项(所以数组就是特殊的对象)
  • 3、数组的属性名可以代表每一个键值对的位置，所以说数组的属性名也叫作索引
  • 4、每一个数组天生自带一个属性length，他代表当前数组的长度，(个数)
  • 5、给数组末尾增加一项 ary[ary.length] = xxx
  • 6、获取数组第一项 ary[0]
  • 7、获取数组最后一项 ary[ary.length-1]
  • 8、删除数组最后一项 ary.length = ary.length-1

  • 9、清空数组 ary.length = 0 ```javascript // let ary = [12,false,true,2,null]

    1.   //  console.log(ary[2]);
    2.   //  ary[2] = 33
    3.   //  console.log(ary);
    4.   // console.log(ary.length); // 3
  1.     // 给数组末尾新增一项
  2.     //  ary[3] = 1
  3.     //  ary[ary.length] = 1 // 可以给任意一个数组增加最后一项
  4.     // 获取数组第一项和最后一项
  5.     // ary[0]
  6.     // ary[ary.length-1]
  8.     // let ss = [true,]
  10.     // let ss = [true,false,null];
  11.     // ss[3] = 1;
  12.     // ss[ss.length] = 1;
  15.     let ary = [true,false,null];
  16.     // ary[0] // 获取数组开头一项
  17.     // ary[ary.length-1] //获取数组最后一项
  18.     // ary[3] = xxx;
  19.     // ary[ary.length] = xxx;
  21.     // let w = [300,500,600];
  22.     ary.length = 2;
  23.     ary.length = ary.length-1
  24.     console.log(ary);
  1. <a name="hgoiG"></a>
  2. ## 2.基本数据类型Null和undefined
  4. -   null和undefined都代表没有
  6.         null：空指针对象，一般情况下都是代表意料之中的事(咱们一开始不知道他的值是多少，可以该他赋值为null，经过一系列操作之后，知道了他的值，在给他重新赋值)
  7. ```javascript
  8.  let total = null;
  10.         let a = 10;
  11.         let b = 12;
  12.         total = a + b;
  14.         // 买了一辆汽车，新车时没有汽油的,单只咱们知道，买完车之后你回去加油的，当你加完油之后再给油箱重新赋值
  15.         let carBox = null;
  17.         carBox = full;

3.基本数据类型和引用数据类型的区别

QQ图片20200624151757.png

4.数据类型之间的数据比较

数据类型的比较
= 赋值：把等号右边的值赋值 给左边的变量
== 比较，左边和右边的比较，最后的返回值是一个布尔值(如果左右两边的值不是同一类型的，会进行数据类型的转换)

  1. / let a = 12;
  2.             // let b = '12';
  3.             // console.log(a == b); // true
  4.             // 不同的数据类型进行比较，浏览器会进行隐式数据类型的转换
  6.             // 数字 == 字符串：把等号左右两边全部转换成数字在比较
  7.             // 数字 == 布尔：把等号左右两边全部转换成数字在比较
  8.             // 字符串 == 布尔：把等号左右两边全部转换成数字在比较
  11.             null == null // true
  12.             undefined == undefined // true
  13.             null == undefined // true
  14.             // 除了以上三种情况null和undefined和谁都不相等
  15.             NaN == NaN // false   NaN和谁都不相等，包括自己
  19.             console.log('1' == 1); // true
  20.             console.log('1px' == 1);// false
  22.             console.log(1 == true); // true
  23.             console.log(0 == false); // true
  25.             console.log('' == false); // true
  26.             console.log('1' == true); // true
  28.             console.log(null == 0); // false
  29.             console.log(undefined == 1); // false
  31. /* 
  32.         数据类型的比较
  33.         =  赋值：把等号右边的值赋值 给左边的变量
  34.         == 比较，左边和右边的比较，最后的返回值是一个布尔值(如果左右两边的值不是同一类型的，会进行数据类型的转换)
  35.         !=:不等,会进行数据类型的转换
  37.         ===:绝对比较，不会进行数据类型的转换
  38.         !==:绝对不等,不会进行数据类型的转换
  41.          */
  43.             // let a = 12;
  44.             // let b = '12';
  45.             // console.log(a == b); // true
  46.             // 不同的数据类型进行比较，浏览器会进行隐式数据类型的转换
  48.             // 数字 == 字符串：把等号左右两边全部转换成数字在比较
  49.             // 数字 == 布尔：把等号左右两边全部转换成数字在比较
  50.             // 字符串 == 布尔：把等号左右两边全部转换成数字在比较
  51.             // 对象 == 数字：把等号左右两边全部转换成数字在比较
  52.             // 对象 == 布尔：把等号左右两边全部转换成数字在比较
  54.             null == null // true
  55.             undefined == undefined // true
  56.             null == undefined // true
  57.             // 除了以上三种情况null和undefined和谁都不相等
  58.             NaN == NaN // false   NaN和谁都不相等，包括自己
  61.             // 对象 == 对象：比较的是空间地址
  62.             // 对象 == 字符串：把等号左右两边全部转成字符串在比较
  65.             // 基本值存储的是值
  66.             // 引用值存储的是空间地址
  68.             // let ary = [1,2,3]; // aaafff000
  69.             // let ary1 = [1,2,3]; // aaafff111
  70.             // console.log(ary == ary1); // false
  72.             // let obj = {} // af0
  73.             // let s = obj; // af0
  75.             // console.log(obj == s); // true
  81.             console.log('1' == 1); // true
  82.             console.log('1px' == 1);// false
  84.             console.log(1 == true); // true
  85.             console.log(0 == false); // true
  87.             console.log('' == false); // true
  88.             console.log('1' == true); // true
  90.             console.log(null == 0); // false
  91.             console.log(undefined == 1); // false
  93.             console.log([] == 1); // false
  94.             console.log({} == NaN); // false
  96.             console.log({name:1} == true); // false
  97.             console.log([] == false); // true
  98.             console.log(5>3); // true
  99.             console.log(true>3); // false
  100.             console.log(true>=1);// true
  106.             // 对象 == 字符串：把等号左右两边全部转成字符串在比较
  107.             console.log({name:1} == '[object Object]'); // true
  109.             //-------------------------------------------------------------
  110.             console.log('1' === 1); // false
  112.             // !=:不等,会进行数据类型的转换
  113.             // !==:绝对不等,不会进行数据类型的转换
  115.             console.log('1' != 3); // true
  116.             console.log('1' !== 3);// true

5.JS中的逻辑判断语句

  1.   if/else  else if  else
  2.          */
  4.         // let num = 1;
  5.         //  if(num == 9){
  6.         //      // 如果小括号里的东西转布尔是true，那就是是成立，然后就走大括号里的代码
  7.         //      // 
  8.         //      console.log('条件成立了');
  10.         //  }
  11.         //  else if(num == 1){
  12.         //     console.log(6666);
  14.         //  }
  15.         //  else {
  16.         //     //  如果上边的条件不成立，那就走else的代码
  17.         //             console.log('条件不成立');
  19.         //  }
  20.         // 上边的条件只会走一个
  22.         // else if可以不写，也可以写多个
  23.         //  else也可以不写，但是if必须写
  24.         // let num = 1;
  25.         // if(num<3){
  26.         //     console.log(1);
  28.         //     // 小括号里会转布尔
  30.         // }
  31.         // else {
  32.         //     console.log(3);
  34.         // }
  36.         // if可以嵌套
  37.         // let num = 9
  38.         // if(num == 9){
  39.         //     if(num<1){
  40.         //         console.log('haha');
  42.         //     }
  43.         // }
  44.         // else {
  45.         //     console.log(333);
  47.         // }
  49.         // let num = 10;
  50.         // if(num>5){
  51.         //     if(num ==='10'){
  52.         //         console.log('恭喜');
  53.         //     }
  54.         //     else {
  56.         //     }
  59.         // }
  60.         // else {
  61.         //     console.log('卡瓦迪卡');  
  62.         // }
  64.         //-----------------------------
  66.         // js中的循环：不断重复的做某件事
  67.         // let ary = [100,200,300];
  68.         // console.log(ary[0]);
  69.         // console.log(ary[1]);
  70.         // console.log(ary[2]);
  72.         // for循环：
  73.         // 1、创建循环的初始值
  74.         // 2、创建/判断循环的条件是否成立
  75.         // 3、条件如果成立，就执行循环体的代码
  76.         // 4、进行步长累计
  78.         // 2-->3-->4-->2-->3-->4-->2-->3-->4-->2
  79.         // for(var i =0;i<3;i++){ // 在之前的基础上加1
  80.         //     // 大括号就是循环体
  81.         //     // console.log(1); // 第一次 第二次 第三次
  82.         //     console.log(i); //0 1 2
  84.         //     // for循环执行不完，代码是不会往下走的 
  85.         // }
  87.         // console.log(i); // 3
  90.         // let a = 1;
  91.         // a++; // a = a+1 累加1
  92.         // a++
  93.         // console.log(a); // 2
  95.         let ary = [100, 200, 300];
  96.         // 我想输出数组的每一项
  97.         // console.log(ary[0]);
  98.         // console.log(ary[1]);
  99.         // console.log(ary[2]);
  101.         for (var i = 0; i < ary.length; i++) {
  102.             // console.log(i); // 0 1 2
  103.             console.log(ary[i]);//  100 200 300 // 输出数组的每一项
  105.         }
  107.         // continue break
  108.         // continue：结束当前轮循环，进行下一轮循环
  109.         // break:结束整个for循环
  110.         //  for(var i = 0;i<3;i++){
  112.         //     if(i === 1){
  113.         //         continue;
  114.         //     }
  115.         //     console.log(i);  // 0 2
  116.         // }
  120.         // for (var i = 0; i < 3; i++) {
  122.         //     if (i === 1) {
  123.         //         break;
  124.         //     }
  125.         //     console.log(i);  // 0
  126.         // }
  127.         // console.log(i); // 1
  129.         // var a = 12;
  130.         // // a+=3; // 在原来基础之上累加3  a = a+3
  131.         // console.log(a); // 15 
  133.         for (var i = 0; i < 7; i++) {// 1 2 3 4 5 6 7 8
  134.             if (i >= 2) {
  135.                 i += 1
  136.                 continue;
  137.             }
  138.             if (i > 6) {
  139.                 break;
  140.             }
  141.             console.log(i); // 0  1
  142.         }
  143.         console.log(i); // 8