特点：区分大小写

text和Text不是一个变量

标识符命名规范

• 第一个字符必须是 字母、$、_

• 其他字符可以是字母、_、$、数字

• Camel-Case书写格式（ECMA）

• 不得使用保留字作为标识符

变量

• ECMA的变量是松散类型，即可保存任意类型数据。每个变量只是保存值得占位符。定义变量用var操作符（var是一个关键字），后跟变量名（即一个标识符）。
• var message
• 没有赋值的变量回保存一个特殊值(undefined)，没定义的直接报错。
• 变量值类型可以修改，但不推荐修改。
• var操作符定义的变量将成为定义该变量作用域中的局部变量。也就是如果在函数中使用var定义一个变量，那么这个函数退出后就会被销毁。
• 省略var可以定义全局变量，但不推荐。
• 严格模式不能定义eval合arguments的变量，否则会语法错误。

数据类型

Undefined、Null、Boolean、Number、String、Object

const num = 1;
const name = 'xiaoming';
const obj = {};
const empty = null;
const booleanZ = false;
function foo () {}

console.log(num, typeof num);
console.log(name, typeof name);
console.log(obj, typeof obj);
console.log(empty, typeof empty);
console.log(booleanZ, typeof booleanZ);
console.log(foo, typeof foo);

Mac

Typeof 返回值类型的字符串 ，function不是数据类型。函数是一种对象。

console.log(undefined == null) //true

但是不全等，类型不一样。

Boolean

任何非空字符串、非0数值、任何对象都可以转为true；

空字符串、0、NAN、null、undefined 转换为false；

console.log(Boolean('lin'));        //true
console.log(Boolean(''));           //false
console.log(Boolean(0));            //false
console.log(Boolean(null));         //false
console.log(Boolean(undefined));    //false

Number

整数类型，浮点数类型。

• 二进制：

  console.log(10);    //10    十进制
  

• 八进制：

  以8为基数，以0开头

  console.log(010);   //8     八进制
  console.log(079);   //79    无效八进制，自动解析为十进制
  console.log(08);    //8     无效八进制，自动解析为十进制
  

• 十六进制

  以0x开头，后面是（0-9及A-F）

  console.log(0xA)    //10    十六进制
  

• 浮点数

  console.log(0.8);       //0.8
  console.log(03.8);    //Uncaught SyntaxError: missing ) after argument list
  console.log(0.80);      //0.8
  console.log(.8);        //0.8   不推荐
  

  Number.MIN_VALUE 最小值

  Number.MAX_VALUE 最大值

  超过范围变成infinity 或 -infinity（Numbaer.POSITIVE_INFINITY、Numbaer.NEGATIVE_INFINITY）;

  确定一个数值是否超过规定范围：isFinite(num) //true || false

• NaN

  not a number

  console.log(NaN == NaN);    //false
  console.log(NaN === NaN);   //false
  console.log(isNan('NaN'));  //true
  

  isNaN()函数也适用于对象，在调用isNaN()函数过程中，首先会调用valueOf()方法，然后确定返回值是否能转换成数值，如果不能，则基于这个返回值再调用toString()方法，再测试返回值；

  let obj = {};
  console.log(isNaN(obj));    //true
  obj.toString = function() {
      return 123;
  }
  console.log(isNaN(obj));    //false
  obj.toString = function() {
      return '123';
  }
  console.log(isNaN(obj));    //false
  obj.toString = function() {
      return 'lin';
  }
  console.log(isNaN(obj));    //true
  

  • 数值转换

    Number()函数用于任何数据类型，是转型函数。

    parseInt和parseFloat专门用于字符串。

String

由单个或多个16位unicode字符组成。由''或者""包裹，引号需成对出现。

ECMA规定字符串不可以改变，也就是说更改字符串实际上是在更改指针指向。

• 转义字符

• toString

  var num = 10;
  console.log(typeof num);                //number
  console.log(typeof num.toString());     //string
  //传参可转换进制
  console.log(typeof num.toString(2));    //'1010'
  console.log(typeof num.toString(8));    //'12'
  console.log(typeof num.toString(10));    //'10'
  console.log(typeof num.toString(16));    //'a'
  

  toString不可以转换null和undefined

  var a = null;
  var b = undefined;
  
  console.log(a.toString());  //demo.js:4 Uncaught TypeError: Cannot read property 'toString' of null
  console.log(b.toString());  //demo.js:5 Uncaught TypeError: Cannot read property 'toString' of undefined
  

• String

  console.log(String(a));  //'null'
  console.log(String(b));  //'undefined'
  

  值如果没有null或者undefined调用String方法实际自动执行的是toString方法，否则返回null或者undefined。

Object

• 创建对象的方法：

  let obj = {}

  let obj = new Object()

  let obj1 = new Object();
  console.log(obj1);            //{}
  let obj2 = new Object();
  console.log(obj2);            //{}
  let obj3 = new Object(2);
  console.log(obj3);            //Number {2}
  console.log(obj3.valueOf());  //2
  console.log(obj3 + 2);        //Number {4}    隐式转换
  let obj4 = new Object(2,3);
  console.log(obj4);            //Number {2}
  let obj5 = new Object({a: 1, b: 2});
  console.log(obj5);            //{a: 1, b: 2}
  console.log(obj5.valueOf());  //{a: 1, b: 2}
  console.log(obj5 + 2);            //[object Object]2
  

  new Number(num) //创建数值

  new String('str') //创建字符串

  new Boolean(true) //创建布尔值

变量初始化

• 对象初始化一般用var ovj = null;
• 字符串let str = '';
• 数字 let num = 0;
• 布尔值 let isBoolean = false; 或者true;

运算符

一元运算符

只能操作一个值的运算符叫做一元运算符

++ --

let num = 100;
//let num2 = num++;   // 加加在后面 先赋值 后运算
let num2 = --num;     // 加加在后面 先运算 后赋值
console.log(num);     //101 99
console.log(num2);    //100 99
//--同上

其他类型应用一元运算符规则

let str = '123';
str++;
console.log(typeof str);   //number  数值字符串会转换为number

let str = 'abc';
str++;
console.log(str);   //NaN   字符串不是数值

let boolean = false;
str++;
console.log(boolean);   // true = 1 , false = 0

let obj = {
    toString: function(){
        return 1;
    }
}
obj++;
console.log(obj);   //2 设置valueOf()和toString()为数值的可以参与运算。如果非数值为NaN

let str = '93';
console.log(typeof str);     //string
console.log(typeof +str);    //number
//+取正  -取负
let str1 = 'abc'; console.log(+str1)    //NaN
let boolean = false; console.log(+boolean)  //0
...

算术运算符

给定 x=10 和 y=5，下面的表格解释了赋值运算符：

+也是连字符

let num = 100;
let str = '100';
console.log(str + num); //100100

let num1 = 10;
let num2 = 10;
let str = 'hello';
//优先级问题 数学的那种方式
console.log(str + num1 +num2); //hello1010
console.log(num1 +num2 + str); //20hello
...

关系运算符

• 关系运算符操作非数值时尧遵循以下原则

  1. 两个操作数都是数值，进行数值比较
  2. 两个操作数都是字符串，比较两个字符串的编码值
  3. 两个操作数有一个是数值，将另外一个转换为数值再比较
  4. 两个操作数有一个是对象，先调用valueOf()方法或toString()方法，再比较

  console.log(3 > 2);         // true
  console.log(false > 1);     // false
  console.log(3 > '2');       // true
  console.log(3 > {toString: () => 10});         //false
  console.log(3 > {valueOf: () => 1});    //true
  console.log('a' > 'b');    //false. 97 > 98
  

• 在相等和不相等的比较上，如果操作数是非数值，则遵循以下规则：

  1. 一个操作数是布尔值，会先转换成数值。true = 1, false = 0;
  2. 一个操作数是字符串，先转换数值再比较
  3. 一个操作数是对象，先调用valueOf()方法或toString()方法，再比较
  4. 不需要任何转换的情况下，null == undefined null == null undefined == undefined
  5. 一个操作数是NaN，==为false !=true NaN != NaN
  6. {} == {} 不等于，指向不同。var obj = {};var obj2 = obj; obj == obj2; //true
  7. 全等和不全等，值和类型都相等才可以返回true，否则返回false。

逻辑运算符

与 &&

如果两边的操作数有一个不是布尔值的情况下，与运算就不一定返回布尔值，此时遵循以下规则。

• 第一个操作数是对象，返回第二个操作数；

• 第二个操作数是对象，则第一个操作数返回true，才返回第二个操作数，否则返回false；

• 有一个操作数是null，返回null；

• 有一个操作数是NaN，返回NaN；

• 有一个操作数是undefined，返回undefined；

  console.log((3 > 2) && (5 > 4));    //true
  console.log((1 > 2) && (5 > 4));    //false
  console.log((3 > 2) && (2 > 4));    //false
  console.log({} && 5);               //5
  console.log(true && {});            //true
  console.log(false && {});           //false
  console.log(null && 6);             //false
  console.log(null && undefined);     //null
  console.log(undefined && null);     //undefined
  //如果第一个操作数式false 就不会执行第二个操作数
  console.log(1 && undefined);        //undefined
  

或 ||

一边是true，整体就是true。如果两边操作数有一个操作数不是布尔值的情况下，此时遵循以下规则。

• 第一个操作数是对象，则返回第一个操作数
• 第一个操作数的求值结果为false，则返回第二个操作数
• 两个操作数都是对象，则返回第一个操作数
• 两个操作数都是null，返回null
• 两个操作数都是NaN，返回NaN
• 两个操作数都是undefined,返回undefined

console.log((3 > 2) || (1 > 4));    //true
console.log((1 > 2) || (1 > 4));    //false
console.log({} || 5);               //{}
console.log({a: 1} || {b: 2});      //{a: 1}
console.log(true || {});            //true
console.log(false || {});           //{}
console.log(null || 6);             //6
console.log(null || null);          //null
console.log(null || undefined);     //undefined
console.log(undefined || null);     //null
console.log(1 || undefined);        //1
console.log(NaN || 1);              //1

非 ！

非布尔值先转换类型再取反。

*位运算符（了解）

ps.一般应用中不会使用，基本上也用不到。它基于底层，速度和性能好，但是基于底层难度也很大。

赋值运算符

let num = 100;      //将100赋值给box变量
num = num + 100;     //box + 100赋值给box
num += 100;

其他运算符

1. 字符串运算符

   let str = 'haha';let str2 = 'nihao'; //str + str2 = 'hahanihao';

2. 逗号运算符

   let a = 1, b = 2, c = 3;

   let a = (1,2,3,4,5);//a = 5; 不常用

   let a = [1,2,3,4,5]; //a = [1,2,3,4,5]

   let a = {a: 1, b: 2}; //a.a = 1;

3.三元运算符

let num = 3 > 4 ? 3 : 4;    //4

运算符计算优先级

如果没有圆括号，遵循以下优先级