任何語言的核心所描述的都是這門語言在最基本的層面上如何工作沮协，涉及語法龄捡、操作符、數(shù)據(jù)類型以及內(nèi)置功能慷暂，在此基礎之上才可以構(gòu)建復雜的解決方案聘殖。

語法

• 區(qū)分大小寫
  例如

let Main="這是一個主體"
let main=""

• 標識符
  什么是標識符：
  變量、函數(shù)行瑞、屬性或函數(shù)參數(shù)的名稱奸腺，
  規(guī)則：
  第一個字符必須是一個字母、下劃線（_）或美元符號（$）血久，剩下的其他字符可以是字母突照、下劃線、美元符號或數(shù)字氧吐。
  推薦使用方式
  采用駝峰式命名即第一單詞首字母小寫其他單詞首字母大小
  例如：

let userName="admin" 

• 注釋
  單行和多行

//這是單行注釋
/*
多行注釋
1.xxxx
2.xxxxx
*/

• 嚴格模式

"use strict"
//如果放在腳本開頭整個腳本采用嚴格模式
//如果放在函數(shù)體內(nèi)則該函數(shù)采用嚴格模式

• 語句
  1.ECMAScript 中的語句以分號結(jié)尾
  2.多條語句可以合并到一個 C 語言風格的代碼塊中（一條語句也推薦放在代碼塊中）讹蘑。

關鍵字和保留字

關鍵字和保留字沒什么好說的，以下這些詞匯不能用作標識符來使用副砍。

//ECMA-262 第 6 版規(guī)定的所有關鍵字
break do in typeof 
case else instanceof var 
catch export new void 
class extends return while 
const finally super with 
continue for switch yield 
debugger function this 
default if throw 
delete import try
//未來保留的關鍵字
//始終保留
enum
//嚴格模式下
implements package public 
interface protected static 
let private
//模塊代碼中
await

變量

• 什么是變量
  用于保存任何類型的數(shù)據(jù)衔肢，聲明變量的的方式有var、let豁翎、const三種
  var聲明特征
• 函數(shù)作用域

function fn(){
console.log(a)//undefined
var a=123
console.log(a)//123
}
 fn()
console.log(a)//報錯 Uncaught ReferenceError: a is not defined
//對比
if(true){
var a=123
}
console.log(a)//123

• 變量提升

console.log(a)//undefined
var a=123
console.log(a)//123

let聲明

• 塊級作用域

function fn(){
console.log(a)//undefined
let a=123
console.log(a)//123
}
fn()
console.log(a)//報錯 Uncaught ReferenceError: a is not defined
//對比
if(true){
let a=123
}
console.log(a)//報錯 Uncaught ReferenceError: a is not defined

• 暫時性死區(qū)

console.log(a)//Uncaught ReferenceError: Cannot access 'a' before initialization   
let a=12

• 同一作用域下不能聲明冗余

let a=12
let a=123//Uncaught SyntaxError: Identifier 'a' has already been declared
或
var a=121//Uncaught SyntaxError: Identifier 'a' has already been declared
或
const a//Uncaught SyntaxError: Identifier 'a' has already been declared

const聲明
const 的行為與 let 基本相同角骤，唯一一個重要的區(qū)別是用它聲明變量時必須同時初始化變量，且嘗試修改 const 聲明的變量會導致運行時錯誤

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

原始類型:Undefined、Null邦尊、String背桐、Boolean、Number蝉揍、 Symbol和链峭、Bigint
引用類型：Object
檢測數(shù)據(jù)類型的方法

• typeof

console.log(typeof "str")//string
console.log(typeof 12)//number
console.log(typeof true)//boolean
console.log(typeof undefined)//undefined
console.log(typeof Symbol("id"))//symbol
console.log(typeof 10n)//bigint
console.log(typeof null)//object
console.log(typeof {})//object
console.log(typeof function(){})//function
console.log(typeof [])//object

typeof對于基本數(shù)據(jù)類型除去null判斷為object其他都能準確判斷出，對于引用類型數(shù)據(jù)能夠判斷出對象和函數(shù)

• instanceof檢測引用類型

console.log({} instanceof Object)//ture
console.log([] instanceof Array)//ture
console.log(function(){} instanceof Function)//ture
console.log(new Date() instanceof Date)//ture

• toString比較全面的檢測類型的方法

let toString=Object.prototype.toString
        console.log(toString.call(null))//[object Null]
        console.log(toString.call(undefined))//[object Undefined]
        console.log(toString.call('1212'))//[object String]
        console.log(toString.call(1212))//[object Number]
        console.log(toString.call(true))//[object Boolean]
        console.log(toString.call(Symbol('ID')))//[object Symbol]
        console.log(toString.call(10n))//[object BigInt]
        console.log(toString.call({}))//[object Object]
        console.log(toString.call([]))//[object Array]
        console.log(toString.call(new Date()))//[object Date]
        console.log(toString.call(function (){}))//[object Function]
        console.log(toString.call(NaN))//[object Number]
        console.log(toString.call(Infinity))//[object Number]

Undefined
用于未定義的值 —— 只有一個 undefined 值的獨立類型
Null
用于未知的值 —— 只有一個 null 值的獨立類型
Boolean
用于 true 和 false又沾。
類型轉(zhuǎn)換

Number
用于任何類型的數(shù)字：整數(shù)或浮點數(shù)称诗，在 ±(2⁵³-1) 范圍內(nèi)的整數(shù),特殊的值Infinity、-Infinity 和 NaN。
數(shù)值轉(zhuǎn)換方法：

• Number()//轉(zhuǎn)型函數(shù)壁熄，可用于任何數(shù)據(jù)類型
  轉(zhuǎn)換規(guī)則：
  1.布爾值跃闹，true 轉(zhuǎn)換為 1次乓，false 轉(zhuǎn)換為 0疆液。
  2.數(shù)值，直接返回
  3.null表窘，返回 0
  4.undefined典予，返回 NaN。
  5.字符串：
  01.字符串包含數(shù)值字符乐严，包括數(shù)值字符前面帶加瘤袖、減號的情況，則轉(zhuǎn)換為一個十進制數(shù)值（忽略前面的0）
  02.字符串包含有效的浮點值格式麦备，則會轉(zhuǎn)換為相應的浮點值（忽略前面的0）
  03.有效的十六進制格式孽椰，則會轉(zhuǎn)換為與該十六進制值對應的十進制整
  數(shù)值
  04.空字符串（不包含字符），則返回 0
  05.包含除上述情況之外的其他字符凛篙，則返回 NaN
  6.對象:
  調(diào)用 valueOf()方法黍匾，并按照上述規(guī)則轉(zhuǎn)換返回的值。如果轉(zhuǎn)換結(jié)果是 NaN呛梆，則調(diào)用toString()方法锐涯，再按照轉(zhuǎn)換字符串的規(guī)則轉(zhuǎn)換

• parseInt()//需要得到整數(shù)時可以優(yōu)先使用可以指定進制數(shù)。字符串最前面的空格會被忽略填物，遇到小數(shù)點不在解析纹腌，建議使用此方法時指定進制數(shù)

• parseFloat()//與parseInt()類似，不能指定進制數(shù)滞磺，遇到第二個小數(shù)點不在解析升薯，始終忽略字符串開頭的零，只解析十進制值
  String
  用于字符串：一個字符串可以包含 0 個或多個字符击困，所以沒有單獨的單字符類型涎劈。
  字符串標示：''广凸、""、``

• 字符字面量

• 轉(zhuǎn)換為字符串方法

xxx.toString(number)//2、8徒河、10系馆、16表示進制書或者不加參數(shù)轉(zhuǎn)字符串

• 模板字面量(``)

//1.可以換行例子：
let str=`我是一個，
            字符串顽照。`
//字符串插值例子：
let age=20
let man=`我是一個男人，年齡${age}歲`

Symbol
用于唯一的標識符
1.基本使用方法

let  name=Symbol("ID");
console.log(name.description)//ID
//Symbol()函數(shù)不能與 new 關鍵字一起作為構(gòu)造函數(shù)使用 闽寡，可以通過Object實現(xiàn)
{
let sym=new Symbol("ID");// TypeError: Symbol is not a constructor
}
{
let sym =Symbol()
let mySymbol =Object(sym)
console.log(typeof myWrappedSymbol); // "object"
}
//警示代兵！Symbol 不會被自動轉(zhuǎn)換為字符串

2.使用全局符號注冊表

// 創(chuàng)建全局符號
let s = Symbol.for('foo'); 
let s4=Symbol.for('foo'); 
console.log(s === s4)//true
console.log(Symbol.keyFor(s)); // foo 
// 創(chuàng)建普通符號
let s2 = Symbol('bar'); 
let s3=Symbol('bar');
console.log(s2===s3)//false
console.log(Symbol.keyFor(s2)); // undefined

3.使用符號作為屬性

let s1=Symbol('id');
let obj={
      name:"lly",
      [s1]:'01',
      [Symbol('value')]:'我是一名程序員'
    }
//Symbol 在 for…in 中會被跳過
for(let key in obj){
    console.log(key)//name
}

4.常用內(nèi)置符號

//全局函數(shù) Symbol 的普通字符串屬性，指向一個符號的實例爷狈。所有內(nèi)置符號屬性都是不可寫植影、不可枚舉、不可配置的涎永。
@@iterator=>Symbol.iterator

5.Symbol.asyncIterator
指定了一個對象的默認異步迭代器

const myAsyncIterable = new Object();
myAsyncIterable[Symbol.asyncIterator] = async function*() {
    yield "hello";
    yield "async";
    yield "iteration!";
};

(async () => {
    for await (const x of myAsyncIterable) {
        console.log(x);
        // expected output:
        //    "hello"
        //    "async"
        //    "iteration!"
    }
})();

6.Symbol.hasInstance

//用于判斷某對象是否為某構(gòu)造器的實例
//實現(xiàn)一個自定義的instanceof 行為
class MyArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MyArray); // true

7.Symbol.isConcatSpreadable

//控制數(shù)組或類似數(shù)組（array-like）的對象的行為:
//1.對于數(shù)組對象思币，用于concat時，可以改變其默認情況下羡微。
let alpha = ['a', 'b', 'c'], numeric = [1, 2, 3];
let alphaNumeric = alpha.concat(numeric);
console.log(alphaNumeric); // 結(jié)果: ['a', 'b', 'c', 1, 2, 3]
numeric[Symbol.isConcatSpreadable] = false;
console.log(alphaNumeric); // 結(jié)果: ['a', 'b', 'c',[ 1, 2, 3]]
//2.對于類似數(shù)組的對象谷饿，用于concat時，該對象整體作為新數(shù)組的元素,改變默認行為
var x = [1, 2, 3];
var fakeArray = {
  [Symbol.isConcatSpreadable]: true,//如果false
  length: 2,
  0: "hello",
  1: "world"
}
//[Symbol.isConcatSpreadable]: true
x.concat(fakeArray); // [1, 2, 3, "hello", "world"] 
//[Symbol.isConcatSpreadable]: false
x.concat(fakeArray);// [1, 2, 3, {…}]

8.Symbol.iterator

//Symbol.iterator 為每一個對象定義了默認的迭代器妈倔。該迭代器可以被 for...of循環(huán)使用博投。
let myIterable = {}
myIterable[Symbol.iterator] = function* () {
    yield 1;
    yield 2;
    yield 3;
};
[...myIterable] // [1, 2, 3]

9.Symbol.match

//指定了匹配的是正則表達式而不是字符串
//禁止表達式檢測
let re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re);   // false

10.Symbol.replace

//當一個字符串替換所匹配字符串時所調(diào)用的方法
class Replace1 {
  constructor(value) {
    this.value = value;
  }
  [Symbol.replace](string) {
    return `s/${string}/${this.value}/g`;
  }
}

console.log('foo'.replace(new Replace1('bar')));
// expected output: "s/foo/bar/g"

11.Symbol.search

//指定了一個搜索方法，這個方法接受用戶輸入的正則表達式盯蝴，返回該正則表達式在字符串中匹配到的下標
class caseInsensitiveSearch {
  constructor(value) {
    this.value = value.toLowerCase();
  }
  [Symbol.search](string) {
    return string.toLowerCase().indexOf(this.value);
  }
}

console.log('foobar'.search(new caseInsensitiveSearch('BaR')));
// expected output: 3

12.Symbol.species

//被構(gòu)造函數(shù)用以創(chuàng)建派生對象
class MyArray extends Array {
  // 覆蓋 species 到父級的 Array 構(gòu)造函數(shù)上
  static get [Symbol.species]() { return Array; }
}
var a = new MyArray(1,2,3);
var mapped = a.map(x => x * x);

console.log(mapped instanceof MyArray); // false
console.log(mapped instanceof Array);   // true

13.Symbol.split

//正則表達式的索引處分割字符串的方法
let exp =  {
        pat:'in',
        [Symbol.split](str) {
          return str.split(this.pat);
          }
    }
   console.log( "dayinlove".split(exp));//["day", "love"]

14.Symbol.toPrimitive

//干擾一個對象轉(zhuǎn)換為原始值時輸出的結(jié)果的
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == "number") {
      return 10;
    }
    if (hint == "string") {
      return "hello";
    }
    return true;
  }
};
console.log(+obj2);     // 10      -- hint 參數(shù)值是 "number"
console.log(`${obj2}`); // "hello" -- hint 參數(shù)值是 "string"
console.log(obj2 + ""); // "true"  -- hint 參數(shù)值是 "default"

15.Symbol.toStringTag

//自定義類型標簽
class ValidatorClass {
  get [Symbol.toStringTag]() {
    return "Validator";
  }
}

console.log(Object.prototype.toString.call(new ValidatorClass())); // "[object Validator]"

Symbol的使用場景

• '隱藏' 對象屬性
• JavaScript 使用了許多系統(tǒng) Symbol毅哗，這些 Symbol 可以作為 Symbol.* 訪問

Bigint
用于任意長度的整數(shù)。

//用法
let bg=1n
或
let big=BigInt(1)

Object
用于更復雜的數(shù)據(jù)結(jié)構(gòu)（一組數(shù)據(jù)和功能的集合）
Object 類型的所有方法和屬性：
1.constructor//用于創(chuàng)建當前對象的函數(shù)捧挺。
2.hasOwnProperty(propertyName)//判斷當前對象實例（不是原型）上是否存在給定的屬性
3.isPrototypeOf(object)//判斷當前對象是否為另一個對象的原型
4.propertyIsEnumerable(propertyName)//用于判斷給定的屬性是否可以使用
5.toLocaleString()//對象的字符串表示虑绵，該字符串反映對象所在的本地化執(zhí)行環(huán)境
6.toString()//對象的字符串
7.valueOf()//對象對應的字符串、數(shù)值或布爾值表示

操作符

一元操作符

• 遞增|遞減（++ | --）

//前綴和后綴區(qū)別
//后綴版遞增和遞減在語句被求值后才發(fā)生
let num=10
console.log(num--)//10
或
console.log(--num)//9
//遞增和遞減操作符遵循如下規(guī)則
/*1.對于字符串闽烙，如果是有效的數(shù)值形式翅睛，則轉(zhuǎn)換為數(shù)值再應用改變。變量類型從字符串變成數(shù)值。
2.對于字符串宏所，如果不是有效的數(shù)值形式酥艳，則將變量的值設置為 NaN 。變量類型從字符串變成
數(shù)值爬骤。
3.對于布爾值充石，如果是 false，則轉(zhuǎn)換為 0 再應用改變霞玄。變量類型從布爾值變成數(shù)值骤铃。
4.對于布爾值，如果是 true坷剧，則轉(zhuǎn)換為 1 再應用改變惰爬。變量類型從布爾值變成數(shù)值。
5.對于浮點值惫企，加 1 或減 1撕瞧。
6.如果是對象，則調(diào)用其（第 5 章會詳細介紹的）valueOf()方法取得可以操作的值狞尔。對得到的
值應用上述規(guī)則丛版。如果是 NaN，則調(diào)用 toString()并再次應用其他規(guī)則偏序。變量類型從對象變成數(shù)值页畦。
*/

• 一元加|減（+|-）

//一元加和減操作符主要用于基本的算術(shù)，但也可以像上面的例子那樣研儒，用于數(shù)據(jù)類型轉(zhuǎn)換豫缨。

位操作符

• 按位非（~）

//對數(shù)值取反并減 1
let num=10
console.log(~num)//-11

• 按位與（&）

• 按位或（|）

• 按位異或（^）

• 左移（<<）
  按照指定的位數(shù)將數(shù)值的所有位向左移動用0補全

let oldValue = 2; 
console.log(oldValue.toString(2))// 等于二進制 10 
let newValue = oldValue << 5;
console.log(newValue.toString(2))// 等于二進制 1000000

• 有符號右移（>>）

let oldValue = 64; 
console.log(oldValue.toString(2))// 等于二進制 1000000 
let newValue = oldValue >> 5;
console.log(newValue.toString(2))//等于二進制10

• 無符號右移（>>>）

//對于正數(shù)，無符號右移與有符號右移結(jié)果相同端朵。
let oldValue = 64; 
console.log(oldValue.toString(2))// 等于二進制 1000000 
let newValue = oldValue >>> 5;
console.log(newValue.toString(2))//等于二進制10
//無符號右移操作符將負數(shù)的二進制表示當成正數(shù)的二進制表示來處理好芭。因為負數(shù)是其絕對值的二補數(shù)，所以右移之后結(jié)果變得非常之大
let oldValue = -64; 
console.log(oldValue.toString(2))// 等于二進制  -1000000 
let newValue = oldValue >>> 5;
console.log(newValue.toString(2))//等于二進制111111111111111111111111110
console.log(newValue.toString(10))//等于十進制134217726

布爾操作符

• 邏輯非（!）
  1.如果操作數(shù)是對象逸月，則返回 false栓撞。
  2.如果操作數(shù)是空字符串，則返回 true碗硬。
  3.如果操作數(shù)是非空字符串瓤湘，則返回 false。
  4.如果操作數(shù)是數(shù)值 0恩尾，則返回 true弛说。
  5.如果操作數(shù)是非 0 數(shù)值（包括 Infinity），則返回 false翰意。
  6.如果操作數(shù)是 null木人，則返回 true信柿。
  7.如果操作數(shù)是 NaN，則返回 true醒第。
  8.如果操作數(shù)是 undefined渔嚷，則返回 true。
  !!=>Boolean()
• 邏輯與（&&）

• 邏輯或（||）

乘性操作符

• 乘法（*）
• 除法（/）
• 取余（%）

指數(shù)操作符

• 指數(shù) (2**3=>2³)

加性操作符

• 加法（+）
• 減法（-）

關系操作符

• 小于（<）
• 大于（>）
• 小于等于（<=）
• 大于等于（>=）

相等操作符

• ==//等于
  任一操作數(shù)是布爾轉(zhuǎn)成數(shù)值再比較
  一個操作數(shù)是字符串一個是數(shù)值轉(zhuǎn)成數(shù)字在比較
  一個對象另一個不是調(diào)用valueOf()取得原生值在比較
  null 和 undefined 相等稠曼。
  null 和 undefined 不能轉(zhuǎn)換為其他類型的值再進行比較
  任一操作數(shù)是 NaN形病，則相等操作符返回 false，NaN和NaN不相等
  兩個操作數(shù)都是對象霞幅，則比較它們是不是同一個對象漠吻，是true否false

• ===//全等
  不進行類型轉(zhuǎn)換 ，未轉(zhuǎn)換前相等是true否則false
  條件操作符

//三目運算符
條件?執(zhí)行體1:執(zhí)行體2
等價于
if(){}else{}

賦值操作符

• 乘后賦值（*=）
• 除后賦值（/=）
• 取模后賦值（%=）
• 加后賦值（+=）
• 減后賦值（-=）
• 左移后賦值（<<=）
• 右移后賦值（>>=）
• 無符號右移后賦值（>>>=）

逗號操作符

//一條語句中執(zhí)行多個操作
let a=1,b=2,c=3;
或
let A=(1,2,3,0)//0

語句

if語句

//流程控制
if(//條件1){
//執(zhí)行體1
}else if(//條件2){
//執(zhí)行體2
}else{
//執(zhí)行體3
}

do-while語句

//后測試循環(huán)語句
let i = 0; //循環(huán)初始值
do { 
 i += 2; //循環(huán)規(guī)則
console.log(i)//2 執(zhí)行此語句
} while (i < 0);//循環(huán)閥值

while語句

//先測試循環(huán)語句
let i = 0; //循環(huán)初始值
while(i < 0) { //循環(huán)閥值
 i += 2;//循環(huán)規(guī)則
console.log(i)//不執(zhí)行此語句
}

for語句

//先測試循環(huán)語句,把初始值和執(zhí)行的表達式加進來
for(let i=0;i<10;i++){//初始值司恳，閾值途乃，循環(huán)表達式
//執(zhí)行語句
}

for-in語句

//一種嚴格的迭代語句，用于枚舉對象中的非符號鍵屬性扔傅，null 和undefined耍共，則不執(zhí)行循環(huán)體。
for(let  key in enumObject){//enumObject可枚舉對象
console.log(key)
}

for-of語句

//一種嚴格的迭代語句猎塞，用于遍歷可迭代對象的元素
for(let key of enumObject){//enumObject遍歷可迭代對象
  console.log(key)
  }

標簽語句

//用于循環(huán)嵌套
start:for(let i=0;i<10;i++){
if(i%5==0){
break start//1,2,3,4,5
}
}

break和continue語句

//break立即退出循環(huán)划提，強制執(zhí)行循環(huán)后的下一條語句
//例：
let num=0;
for(let i=1;i<10;i++){
  if(i%3==0){
  break;
  }
num++
}
console.log(num)//2
//continue立即退出循環(huán)，但會再次從循環(huán)頂部開始執(zhí)行
//例：
let num=0;
for(let i=1;i<10;i++){
  if(i%3==0){
 continue;
  }
num++
}
console.log(num)//6

with語句

//嚴格模式不允許使用 with 語句邢享，否則會拋出錯誤(不推薦使用)
//將代碼作用域設置為特定的對象
//使用場景針對一個對象反復操作，這時候?qū)⒋a作用域設置為該對象能提供便利
//例子
let qs = location.search.substring(1); 
let hostName = location.hostname; 
let url = location.href; 
//上面代碼中的每一行都用到了 location 對象淡诗。如果使用 with 語句骇塘，就可以少寫一些代碼：
with(location) { 
 let qs = search.substring(1); 
 let hostName = hostname; 
 let url = href; 
}

switch語句

//控制語句
switch(expression){//參數(shù)
 case value1: //條件1
 statement //執(zhí)行語句
 break;
case value2: //條件1
 statement //執(zhí)行語句
 break;
.....
default: 
 statement//執(zhí)行語句
  }

函數(shù)

嚴格模式對函數(shù)的一些限制：

• 函數(shù)不能以 eval 或 arguments 作為名稱；
• 函數(shù)的參數(shù)不能叫 eval 或 arguments韩容；
• 兩個命名參數(shù)不能擁有同一個名稱款违。