1. 数据类型

① 数值（number）

var a = 10;
var b = 3.14;

② 字符串（string）

var a = 'hello world';    // 字符串为hello world
var b = "hello";          // 字符串为hello world
var c = "hello 'world'";  // 字符串为hello 'world'
var d = '"hello" world';  // 字符串为"hello" world

双引号和单引号均可以，但需要注意配对，单引号只能和单引号配对，双引号同理。

关于双引号和单引号的嵌套问题，可以是双引号嵌套单引号，也可以是单引号嵌套双引号，通常情况下采用双引号嵌套单引号。

③ 布尔值（boolean）

var flag = true;
var tag = false;

④ undefined：表示未定义或不存在

var a;    //a的数据类型为undefined

⑤ null：表示空值

var a = null;

⑥ 对象（object）

对象可以分为三个子类型：狭义的对象（object）、数组（array）和函数（function）。

var a = {
    name: "blank",
    age: 21
};

2. typeof运算符

typeof运算符用来确定一个值为何种数据类型。

var num = 10;
var str = "Hello World";
var flag = true;
function getName(){}
var age = undefined;
var obj = {};
var timer = null;
var arr = [1,2,3];

console.log(typeof num);     // number
console.log(typeof str);     // string
console.log(typeof flag);     // boolean
console.log(typeof getName);     // function
console.log(typeof undefined);     // undefined
console.log(typeof age);     // undefined
console.log(typeof names);     // undefined
console.log(typeof obj);     // object
console.log(typeof timer);     // object
console.log(typeof arr);    // object

3. 算术运算符

3.1 加法运算符

① 普通的数值相加

var a = 10;
var b = 10;
console.log(a + b);    //20

② 布尔值与布尔值相加 / 布尔值与数值相加

var flag = true;
var tag = false;
var num = 10;
console.log(flag + tag);    //1
console.log(flag + num);    //11

③ 字符串相加 / 字符串与变量名相加

var a = "hello";
var b = "world";
var c = 99;
console.log(a + b);    // helloworld
console.log(a + c + b);    // hello99world

④ 字符串与其他数据类型相加，任何数据类型都会被转换成字符串

var a = "string";
var b = 123;
var c;
var d = null;
var e = true;
console.log(a + b);    //string123
console.log(a + c);    //stringundefined
console.log(a + d);    //stringnull
console.log(a + e);    //stringtrue

可以通过加一个空串将一个非字符串类型的值转换为字符串类型

var a = 10;
console.log(typeof a);    //number
console.log(typeof (a + ""));    //string

⑤ 复合加法

console.log(1+2+"3");    // 33
console.log("1"+2+3);    // 123
console.log(1+"2"+3);    // 123

加法运算符是在运行时决定，到底是执行相加，还是执行连接。也就是说，运算子的不同，导致了不同的语法行为，这种现象称为“重载”（overload）。由于加法运算符存在重载，可能执行两种运算，使用的时候必须很小心。

除了加法运算符，其他算术运算符都不会发生重载，规则是，运算时将运算算子统一转换为数值类型，再进行运算。

console.log(1 - '2') // -1
console.log(1 * '2') // 2
console.log(1 / '2') // 0.5

3.2 减法运算符

console.log(2 - 1);    // 1
console.log(1 - '2');    // -1

3.3 乘法运算符

console.log(2 * 1);    // 2
console.log(1 * '2');    // 2

3.4 除法运算符

console.log(2 / 1);    // 2
console.log(1 / '-2');    // -0.5

3.5 取余运算符

需要注意的是，取余运算符结果的正负由第一个运算算子的正负决定。

console.log(1 % 2);    // 1
console.log(-1 % 2);    // -1
console.log(1 % -2);    // 1

3.6 自增运算符和自减运算符

自增运算符和自减运算符在前时，先++/--再运算；在后时，先运算后++/--。

var a = 10;
var b = 10;
console.log(++a);    // 11
console.log(b++);    // 10
console.log(b);    // 11

3.7 指数运算符

console.log(2 ** 4);    // 16
console.log((-2) ** 3);    // -8

4. 赋值运算符

var x = 1;
var y = x;

5. 比较运算符 

比较运算符用于比较两个值的大小，返回值为布尔值。

console.log(2 > 1);    // 大于运算符，true
console.log(2 < 1);    // 小于运算符，false
console.log(2 >= 1);    // 大于或等于运算符，true
console.log(2 <= 2);    // 小于或等于运算符，true
console.log(2 == "2");    // 相等运算符，true
console.log(2 === "2");    // 严格相等运算符，false
console.log(2 != "2");    // 不等于运算符，false
console.log(2 !== "2");    // 非严格等于运算符，true

相等运算符只比较数值，严格相等运算符既比较数值又比较数据类型。

6. 布尔运算符

布尔运算符用于将表达式转化为布尔值。

console.log(!true);    // 取反运算符，false
console.log(true && false);    // 与运算符，false
console.log(true || false);    // 或运算符，true
console.log(2>1 ? 'yes' : 'no');    // 三元运算符，yes

只有以下六个值取反后为true，其他取反结果都为false

console.log(!false);
console.log(!"");
console.log(!null);
console.log(!undefined);
console.log(!NaN);    // NaN表示运算错误
console.log(!0);

7. 位运算符

位运算是非常底层的运算，优点是速度极快，缺点是不直观。

console.log(5 & 1);    // AND运算符，0101 & 0001 = 0001，1
console.log(5 | 1);    // OR运算符，0101 | 0001 = 0101，5
console.log(5 ^ 1);    // XOR运算符，0101 ^ 0001 = 0100，4
console.log(~5);    // NOT运算符，~0101 = 1010，10
console.log(5 << 1);    // 零填充左移运算符，0101 << 1 = 1010，10
// 通过从右推入零向左位移，并使最左边的位脱落
console.log(5 >> 1);    // 有符号右移运算符，0101 >> 1 = 0010，2
// 通过从左推入最左位的拷贝来向右位移，并使最右边的位脱落
console.log(5 >>> 1);    // 零填充右移运算符，0101 >>> 1 = 0010，2
// 通过从左推入零来向右位移，并使最右边的位脱落

8. 运算符优先级

运算符

描述

. [] ()

字段访问、数组下标、函数调用以及表达式分组

++ -- - ~ ! delete new typeof void

一元运算符、返回数据类型、对象创建、未定义值

/ * %

乘法、除法、取模

+ - +

加法、减法、字符串连接

<< >> >>>

移位

< <= > >= instanceof

小于、小于等于、大于、大于等于、instanceof

== != === !==

等于、不等于、严格相等、非严格相等

&&

逻辑与

||

逻辑或

?:

三元运算符

通常利用小括号提升运算的优先级。 

9. 数据类型转换

9.1 强制类型转换

9.1.1 Number()函数

// 数值：转换后还是原来的值
Number(324) // 324

// 字符串：如果可以被解析为数值，则转换为相应的数值
Number('324') // 324

// 字符串：如果不可以被解析为数值，返回 NaN
Number('324abc') // NaN

// 空字符串转为0
Number('') // 0

// 布尔值：true 转成 1，false 转成 0
Number(true) // 1
Number(false) // 0

// undefined：转成 NaN
Number(undefined) // NaN

// null：转成0
Number(null) // 0

9.1.2 String()函数

String(123) // "123"
String('abc') // "abc"
String(true) // "true"
String(undefined) // "undefined"
String(null) // "null"
String({a: 1}) // "[object Object]"
String([1, 2, 3]) // "1,2,3"

9.1.3 Boolean()函数 

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean(NaN) // false
Boolean('') // false

9.2 自动类型转换

9.2.1 不同类型的数据相互运算

123 + 'abc' // "123abc"
"123" - 1    // 122

9.2.2 对非布尔值类型的数据求布尔值

if ('abc') {    // true
  console.log('hello')
}

10. 条件语句

10.1 if...else...

if(/*条件*/) {
    // 语句
} else {
    // 语句
}

10.2 switch

switch(/*变量*/) {
    case /*条件*/:    /*语句*/
                    break;
    case /*条件*/:    /*语句*/
                    break;
    //...
    default:    break;
}

switch语句后面的表达式，与case语句后面的表示式比较运行结果时，采用的是严格相等运算符，而不是相等运算符，这意味着比较时不会发生类型转换。

11. 循环语句

11.1 for

for (/*初始化表达式*/; /*条件*/; /*递增表达式*/) {
  // 语句
}

 三个部分均可不写，但分号不可以不写。

11.2 while

while (/*条件*/) {
  // 语句
}

11.3 do...while

do {
  // 语句
} while (/*条件*/);

do...while与while的区别是：do...while循环体中的内容至少执行一次。

注意do...while最后的分号不可以省略。

12. break和continue

for (var i = 0; i < 5; i++) {
    if (i === 3){
        break;
    }
    console.log(i);
}

执行到第三次就终止整个循环，输出0，1，2。

for (var i = 0; i < 5; i++) {
    if (i === 3){
        continue;
    }
    console.log(i);
}

执行到第三次循环时终止当次循环，开始下次循环，输出0，1，2，4。