特點：區(qū)分大小寫

text和Text不是一個變量

標(biāo)識符命名規(guī)范

• 第一個字符必須是 字母、$、_

• 其他字符可以是字母、_、$、數(shù)字

• Camel-Case書寫格式（ECMA）

• 不得使用保留字作為標(biāo)識符

變量

• ECMA的變量是松散類型，即可保存任意類型數(shù)據(jù)。每個變量只是保存值得占位符。定義變量用var操作符（var是一個關(guān)鍵字），后跟變量名（即一個標(biāo)識符）。
• var message
• 沒有賦值的變量回保存一個特殊值(undefined)，沒定義的直接報錯。
• 變量值類型可以修改，但不推薦修改。
• var操作符定義的變量將成為定義該變量作用域中的局部變量。也就是如果在函數(shù)中使用var定義一個變量，那么這個函數(shù)退出后就會被銷毀。
• 省略var可以定義全局變量，但不推薦。
• 嚴(yán)格模式不能定義eval合arguments的變量，否則會語法錯誤。

數(shù)據(jù)類型

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不是數(shù)據(jù)類型。函數(shù)是一種對象。

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

但是不全等，類型不一樣。

Boolean

任何非空字符串、非0數(shù)值、任何對象都可以轉(zhuǎn)為true；

空字符串、0、NAN、null、undefined 轉(zhuǎn)換為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

整數(shù)類型，浮點數(shù)類型。

• 二進(jìn)制：

  console.log(10);    //10    十進(jìn)制
  

• 八進(jìn)制：

  以8為基數(shù)，以0開頭

  console.log(010);   //8     八進(jìn)制
  console.log(079);   //79    無效八進(jìn)制，自動解析為十進(jìn)制
  console.log(08);    //8     無效八進(jìn)制，自動解析為十進(jìn)制
  

• 十六進(jìn)制

  以0x開頭，后面是（0-9及A-F）

  console.log(0xA)    //10    十六進(jìn)制
  

• 浮點數(shù)

  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）;

  確定一個數(shù)值是否超過規(guī)定范圍：isFinite(num) //true || false

• NaN

  not a number

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

  isNaN()函數(shù)也適用于對象，在調(diào)用isNaN()函數(shù)過程中，首先會調(diào)用valueOf()方法，然后確定返回值是否能轉(zhuǎn)換成數(shù)值，如果不能，則基于這個返回值再調(diào)用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
  

  • 數(shù)值轉(zhuǎn)換

    Number()函數(shù)用于任何數(shù)據(jù)類型，是轉(zhuǎn)型函數(shù)。

    parseInt和parseFloat專門用于字符串。

String

由單個或多個16位unicode字符組成。由''或者""包裹，引號需成對出現(xiàn)。

ECMA規(guī)定字符串不可以改變，也就是說更改字符串實際上是在更改指針指向。

• 轉(zhuǎn)義字符

• toString

  var num = 10;
  console.log(typeof num);                //number
  console.log(typeof num.toString());     //string
  //傳參可轉(zhuǎn)換進(jìn)制
  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不可以轉(zhuǎn)換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調(diào)用String方法實際自動執(zhí)行的是toString方法，否則返回null或者undefined。

Object

• 創(chuàng)建對象的方法：

  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}    隱式轉(zhuǎn)換
  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) //創(chuàng)建數(shù)值

  new String('str') //創(chuàng)建字符串

  new Boolean(true) //創(chuàng)建布爾值

變量初始化

• 對象初始化一般用var ovj = null;
• 字符串let str = '';
• 數(shù)字 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
//--同上

其他類型應(yīng)用一元運算符規(guī)則

let str = '123';
str++;
console.log(typeof str);   //number  數(shù)值字符串會轉(zhuǎn)換為number

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

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

let obj = {
    toString: function(){
        return 1;
    }
}
obj++;
console.log(obj);   //2 設(shè)置valueOf()和toString()為數(shù)值的可以參與運算。如果非數(shù)值為NaN

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

算術(shù)運算符

給定 x=10 和 y=5，下面的表格解釋了賦值運算符：

+也是連字符

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

let num1 = 10;
let num2 = 10;
let str = 'hello';
//優(yōu)先級問題 數(shù)學(xué)的那種方式
console.log(str + num1 +num2); //hello1010
console.log(num1 +num2 + str); //20hello
...

關(guān)系運算符

• 關(guān)系運算符操作非數(shù)值時堯遵循以下原則

  1. 兩個操作數(shù)都是數(shù)值，進(jìn)行數(shù)值比較
  2. 兩個操作數(shù)都是字符串，比較兩個字符串的編碼值
  3. 兩個操作數(shù)有一個是數(shù)值，將另外一個轉(zhuǎn)換為數(shù)值再比較
  4. 兩個操作數(shù)有一個是對象，先調(diào)用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
  

• 在相等和不相等的比較上，如果操作數(shù)是非數(shù)值，則遵循以下規(guī)則：

  1. 一個操作數(shù)是布爾值，會先轉(zhuǎn)換成數(shù)值。true = 1, false = 0;
  2. 一個操作數(shù)是字符串，先轉(zhuǎn)換數(shù)值再比較
  3. 一個操作數(shù)是對象，先調(diào)用valueOf()方法或toString()方法，再比較
  4. 不需要任何轉(zhuǎn)換的情況下，null == undefined null == null undefined == undefined
  5. 一個操作數(shù)是NaN，==為false !=true NaN != NaN
  6. {} == {} 不等于，指向不同。var obj = {};var obj2 = obj; obj == obj2; //true
  7. 全等和不全等，值和類型都相等才可以返回true，否則返回false。

邏輯運算符

與 &&

如果兩邊的操作數(shù)有一個不是布爾值的情況下，與運算就不一定返回布爾值，此時遵循以下規(guī)則。

• 第一個操作數(shù)是對象，返回第二個操作數(shù)；

• 第二個操作數(shù)是對象，則第一個操作數(shù)返回true，才返回第二個操作數(shù)，否則返回false；

• 有一個操作數(shù)是null，返回null；

• 有一個操作數(shù)是NaN，返回NaN；

• 有一個操作數(shù)是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
  //如果第一個操作數(shù)式false 就不會執(zhí)行第二個操作數(shù)
  console.log(1 && undefined);        //undefined
  

或 ||

一邊是true，整體就是true。如果兩邊操作數(shù)有一個操作數(shù)不是布爾值的情況下，此時遵循以下規(guī)則。

• 第一個操作數(shù)是對象，則返回第一個操作數(shù)
• 第一個操作數(shù)的求值結(jié)果為false，則返回第二個操作數(shù)
• 兩個操作數(shù)都是對象，則返回第一個操作數(shù)
• 兩個操作數(shù)都是null，返回null
• 兩個操作數(shù)都是NaN，返回NaN
• 兩個操作數(shù)都是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

非 ！

非布爾值先轉(zhuǎn)換類型再取反。

*位運算符（了解）

ps.一般應(yīng)用中不會使用，基本上也用不到。它基于底層，速度和性能好，但是基于底層難度也很大。

賦值運算符

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

運算符計算優(yōu)先級

如果沒有圓括號，遵循以下優(yōu)先級