1. 字符串、布尔值、数值之间的转换
  2. 运算符
  3. 运算有关的一些条件判断。

字符串转换数值：

  1. 强制转换数值：通过Number();构造函数。

    • 如果字符串是由数字构成，强制转换后将变为数值，否则变成NaN。
      NaN：是非数值，类型属于数值类型

  2. parseInt();

    • 转换数值时，如果字符串是纯数字构成，或者第一个字符是数字，则转换时从头开始转换到字母之前。
    • 取整，小数点后省略。
    • 第二个参数（可选）：进制，根据字符串的进制转换成十进制数值，当有进制参数时，特点1遇到字母不同。

  3. parseFloat();

    • 保留小数点
    • Number强制转换会将布尔值转换为数值，true==>1,false==>0
    • parseInt 的第一个参数要求是字符串，但是true和false都不是字符串，所以parseInt 首先会自动隐式转换为字符串。

布尔值转换为字符串：

  1. 都是直接变成字符串 String();

字符，数值变成布尔值：

  1. 强制转换布尔值

    • 以下几种强转布尔值时会变为false,其他的都是true。
      0 ；"" ；false ；NaN ；undefined ；null。
    • Boolean(0);Boolean("");Boolean(NaN);

将undefined转换为数值==> NaN;

  • console.log(Number(undefined);

将null转换为数值==> 0;

  • console.log(Number(null);

将对象转换为数值==> NaN;

  • console.log(Number({a:1}));

将对象转换为字符串==> [object Object]

  • console.log(String({a:1}));

  • 所有的任何对象转换为字符串都这样

string，number，boolean，undefined，null 都是存在内存的栈中。

  • 栈中数据读取速度快，但是可以存储的数据较小。

object是存放在内存的堆中。

  • 堆中可以存储大量的数据，但是读取速度慢。

所有的基础类型都是基于Object构建而成。

  • 1
2

    var a=5;
a.toString();

  • 1
2
3

    var a=5;//数据 number	存储在栈中	typeof==>number
var b=new Number(5);//数值对象 Number	存储在堆中	typeof==>object
//number可以理解为Number类型在栈中的映射。

运算符：

  1. 算数运算符：

    1. + - * /；
    2. %取模==取余；
    3. 字符相加：首尾相连
      • 隐式转换 自动默认使用目标类型的构造函数强制转换 String()
      • 1
2
3
4
5
6

        console.log("cde"+true);
console.log("cde"+null);
var a;
console.log("cde"+a);
console.log("cde"+{a:1});
console.log({a:1}+"");
    4. 数值+布尔值会隐式转为数值相加
    5. 数值+undefined会隐式转为数值相加 NaN。
    6. null隐式转换为0。
      • 数值与除了字符串外的非数值相加都会隐式转换为数值类型相加
      • 布尔值、undefined。null相加都会转换为数值
    7. 除了+以外，-，*，/，% 都会依照数值运算先将所有其他类型转换为数值后运算。

  2. 赋值运算符和一元运算符：

    1. +=，-=，*=,/=
      1. var b=a=2;
        • 先将a=2的结果赋值给b
        • 再将2赋值给a
      2. var a=5;a=a=a+2;===> a=7;
      • 同时进行，后面的a=a+2不会用前边的a=7。
      1. a+=2; 步长，累加
      2. var a="10";a-=0;隐式转换为数值
        • console.log(a);==>10
      3. 1
2

        var a=1,b=2,c=3;
a+=1,b+=2,c+=3;
        有赋值，中间就可以逗号连接。
    2. ++
      1. 1
2
3
4

        var a="3";
a++;//会隐式转换为数值在进行运算
a+=1;//参照算数运算符
console.log(a);

      2. 1
2

        var a=2;
console.1og(++a+a+++a+a+++a+a,a);==>(24,5)

      3. 1
2

        var b=a++;//b:1 a:2
var b=++a;//b:2 a:2
  3. 关系运算符和逻辑运算符：
    1. < <= > >= 返回布尔值
      • 1
2
3

        var a=4;
a=a-a>3;
console.log(a);
    2. == === != !==返回布尔值

      • == !=会自动隐式转换为两端相同后比较

      • === !==不转换类型，除了比较值以外还会比较类型

      •  1
 2
 3
 4
 5
 6
 7
 8
 9
10

        console.log(1=="1");
console.log(1==true);
console.log(1===true);
相等类型：
console.log(0==false);
console.log(false=="");
console.log(0=="");
相等：
console.log(0==null);
console.log(undefined==null);

      • 0 false ""==>相等

      • null undefined==>相等 表示空或者未赋值

      • console.log(NaN==NaN);==>不等

      • 1
2
3
4

        var a="4a";
// console. log(Number(a)==NaN)//不能用==NaN判断非数值
// console. log(isNaN(Number(a)));
console.1og(Number.isNaN(Number(a)));

        • 1
2
3
4

          //都是判断数值类型，非数值类型，不隐式转换返回false
console.log(Number.isNaN(a));
//会先隐式转换为数值，然后在判断是否是非数值
// console.log(isNaN(a));

      • 取反，取布尔值的反

        • 如果是布尔值就会变成相反的结果true==>false,false==>true;
        • 如果不是布尔值就会隐式转换为布尔值，然后再取反。
    3. && || 返回的值根据内容确定，不一定是布尔值。
      • 1
2
3
4
5

        var a=3;
console.log(a>2 && a<5);
console.log(a>5 || a<4);
a=a-3 || 1；
console.log(a);
      • 熔断
        • true

          true || true ==> 返回前面的值

          true || false ==> 返回隐式转换布尔值为true的值

          false || true ==> 返回隐式转换布尔值为true的值

          false || false ==> 返回最后一个false的值

        • false

          true && true ==> 返回第二个true的结果

          true && false ==> 返回false的结果

          false && true ==> 返回false的结果

          false && false ==> 返回第一个false的结果

      • 在if语句判断赋值时也会出现

        1
2
3
4
5
6

        var o;
o=0 || {a:1};或者
if(!o){
    //if判断变量o是否已经赋值，只有o等于 6 种值时（变量o未赋值），会进入if语句块，对o重新赋值
    o={a:1};
}
  4. 位运算符：
    1. ~位非：加一取负；
      ~~：双非，还原取整，任何内容转换为数值；
      • 非数值变为0；
      • 其他变为数值；
      • 1
2

        var a=-1;
位非变为0；

      • 1
2
3
4
5
6
7
8

        var str="abcd";
//str.indexof("f")==>当找不到会返回 -1；
if(~str.indexof("d")){
	//表示能找到的话进入if语句
}
if(!~str.indexof("d")){
    //表示找不到进入if语句
}
    2. &与运算
      • 任何数 &2的结果：2/0
      • 任何数 &3的结果：3/2/1/0\
    3. |或运算
    4. ^异或：相同为0，不同为1；
      • 对称加密；
      • 非对称加密；
    5. 左移 << 32个字节 4位 到头变成1
    6. 右移 >>
  5. 三目运算符：/条件运算符
    1. 1
2
3

      var a=5;
var b=a>3 ? 1 : 0;
//如果a>3，返回1 否则0；
    2. Tips
      • 1

        var b=a>1 ? 10 : a<0 ? 5 : 0;//b=?

      • 1
2
3
4

        var a=1;
a -=1 ? 0 : 1;
//a -=0 ? 0 : 1;
console.log(a);

运算有关的条件判断：

  • 1
2
3
4
5

    if(a==undefined){
    //var a;
    //var a=undefined;
    //var a=null;当a等于这些值的时候，才被允许进入if语句；
}

  • 1
2
3
4
5
6
7

    if(a==0){
    //var a=false;
    //var a="";
    //var a="     ";
    //var a=0;
    console.log("aaa");
}

  • 1
2
3
4
5

    var a;
// var a=undefined
if(a===undefined){
    //只有a未定义的时候才符合条件;
}

  •  1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

    if(条件){
    //if条件返回值为true/false；
    //当返回值为true时，进入条件语句块，返回的值不是布尔值时，会自动隐式转换为布尔值
}
if(a==true){
    //只有当a的值为 ： 0	undefined	null	""	false	NaN;
}
if(a===true){
    //true;
}
if(a){
    //只有当a的值为 ： 0	undefined	null	""	false	NaN;
}
if(a===false){
    //只有当a的值为 ： false;
}
if(a==false){
    //只有当a的值为 ： 0	""	false;
}
if(!a){
    //只有当a的值为 ： 0	""	false	undefined	null	NaN;
}

数组：

console.log([]==[]);==>false

  • 数组是对象类型，也就是引用类型

console.log([]==![]);==>true

  • 因为 ""==false
  • 1
2
3

    //[1,2,3]==>"1,2,3";
//[1]==>"1";
//[]==>""

  • 1
2
3

    //console.log([1]==1);
//console.log([]==0);
//console.log([]==null);

进制：

  1. 进制之间的转换

  2. ASCII GB2312 GB5

  3. Unicode 万国码 （UTF-8使用八进制的万国码）

图像：像素点

  • 每英寸96个像素点 ==>字

  • 每英寸72个像素点 ==>图

  • 一个颜色占4个字节 一英寸图片（72*4=288B）