ES6 快速入門與使用

一鼓寺、簡介

ES6 -> ECMA 標(biāo)準(zhǔn)，又叫 ES2015。ES6 -> 2015年6月 ES6.0勾缭；
每年6月份，發(fā)布一個版本

發(fā)布時間	版本	別名
2016年6月	ES6.1	ES7目养、ES2016
2017年6月	ES6.2(async await)	ES8俩由、ES2017

babel-loader 解析 ES6。
所有 ES6 內(nèi)容見：官方資料
chrome, 對新的語法支持癌蚁，速度挺猛幻梯，一般在新語法發(fā)布的下一個版本中就會支持。

ES6環(huán)境：
- webpack3.x --> babel-loader努释；
- Traceur碘梢。

二、 let 和 const

關(guān)于定義(聲明)變量:
- 之前：var a=12;
- 現(xiàn)在：let a=12洽洁。
之前作用域：
- 全局痘系；
- 函數(shù)作用域。
現(xiàn)在作用域：
- 塊級作用域饿自。
塊級作用域：
- ES5只有全局作用域和函數(shù)作用域汰翠，沒有塊級作用域。
  - 問題一：內(nèi)層變量可能會覆蓋外層變量昭雌；
  - 問題二：用來計數(shù)的循環(huán)變量泄露為全局變量复唤。

1.let

let:用來聲明變量。它的用法類似于var烛卧，但是所聲明的變量佛纫，只在let命令所在的代碼塊內(nèi)有效；
不存在變量提升总放，所以變量一定要先聲明后使用呈宇；
暫時性死區(qū)（TDZ，temporal dead zone）：ES6明確規(guī)定局雄，如果區(qū)塊中存在let和const命令甥啄，這個區(qū)塊對這些命令聲明的變量，從一開始就形成了封閉的作用域炬搭，凡是在聲明之前就使用這些變量蜈漓，就會報錯穆桂，并且不受外部的影響（即和外部有同樣變量名的變量沒有關(guān)系）；
- typeof不再安全融虽，如果在聲明之前調(diào)用typeof享完，會報錯referenceError；而如果一個變量根本沒有被聲明有额，使用typeof反而不會報錯般又。
不允許重復(fù)聲明：在同一作用域內(nèi)，不允許重復(fù)聲明同一個變量谆吴，即使使用var聲明也不可以倒源；for循環(huán)中苛预，for 判斷條件中的是父級作用域句狼，循環(huán)體里面的是子作用域。

function func(arg){
    let arg;    //報錯
}
function func2(arg){
    {
        let arg:    //不報錯
    }
}

var arr = [];
for (var i=0;i<3;i++){
    var fun = function () {
        console.log(i);
    };
    arr.push(fun);
}

arr[1]();   //3

var arr = [];
for (let i=0;i<3;i++){
    var fun = function () {
        console.log(i);
    };
    arr.push(fun);
}

arr[1]();   //1

2.const

聲明一個只讀的常量热某，一旦聲明腻菇，常量的值就不可以更改；
所以在聲明變量的時候昔馋，就必須立即初始化筹吐，不得留著以后賦值；
const作用域和let一樣秘遏，只在聲明所在的塊級作用域內(nèi)有效丘薛；
存在暫時性死區(qū)，只能在聲明的位置后面使用邦危；
不可重復(fù)聲明洋侨；
對于復(fù)合類型的變量，變量名不指向數(shù)據(jù)倦蚪，而是指向數(shù)據(jù)所在的地址希坚。const命令只是保證變量名指向的地址不變，并不保證該地址的數(shù)據(jù)不變陵且，所有將一個對象聲明為常量時必須非常小心裁僧。如果想讓一個對象凍結(jié)，可以使用Object.freeze()方法：Object.freeze(對象)
立即執(zhí)行函數(shù)： IIFE

    (function(){
        //TODO
    })()

建議:
- 以后就用 let 不要在使用var
- 不讓后期修改的變量使用 const慕购，如：const http = require('http');

三聊疲、解構(gòu)賦值:

非常有用，特別在做數(shù)據(jù)交互 ajax沪悲；
let [a,b,c] =[12,5,6];获洲；
注意: 左右兩邊，結(jié)構(gòu)格式要保持一致可训。
數(shù)組的解構(gòu)賦值和位置有關(guān)昌妹；而對象的解構(gòu)賦值和位置沒有關(guān)系捶枢，而是取決于它的變量名和屬性名對應(yīng)關(guān)系。

//解構(gòu)json:
let json = {
    name:'YJW',
    age:18,
    job:'coding'
};
let {name,age,job} = json;  //其中 {} 中的名字要和 JSON 中的 key 必須對應(yīng)飞崖，否則會找不到烂叔，結(jié)果為 undefined
console.log (name,age,job);  //YJW 18 coding
let {name:n,age:g, job:a} = json;

let json = {
    name:'YJW',
    age:18,
    job:'coding'
};
let {name:n,age:a, job:j} = json;  //給變量起別名，此時只能用別名固歪，不能再使用 name蒜鸡、age、job牢裳，只能用別名
console.log (n,a,j);  //YJW 18 coding

解構(gòu)時候可以給默認(rèn)值：

let [e,f,g] = [12,23];
console.log(e,f,g);  //12 23 undefined

let [e,f,g=34] = [12,23];
console.log(e,f,g);  //12 23 34

null 和 undefined 的區(qū)別：

let [e,f,g=34] = [12,23,undefined];
console.log(e,f,g);  //12 23 34

let [e,f,g=34] = [12,23,null];
console.log(e,f,g);  //12 23 null
 //說明如果值為 null 時逢防，默認(rèn)值不能生效

交換兩個數(shù)的位置：

let h = 12;
let i = 5;
[h,i] = [i,h];
console.log(h,i);   //5 12

用小括號 () 的情況：

let j;
({j} = {j:111});  //此處的 {j} 限定了作用域，如果不加小括號會報錯
console.log(j);

四蒲讯、字符串模板:

字符串模板語法：兩個反單引號 ``
優(yōu)點(diǎn): 可以隨意換行
使用變量：${變量名字}

let name ='Strive';
let age = 18;
let str = `這個人叫${name}, 年齡是 ${age}歲`;

練習(xí)：新聞列表

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>string</title>
</head>
<body>
    <ul id="news"></ul>
    <script>
        let newsArr = [
            {title:"2018博鰲亞洲論壇年會",read:12},
            {title:"中朝啟動志愿軍烈士陵園修繕工程 ",read:33},
            {title:"捍衛(wèi)國家利益忘朝，我們有底氣!",read:44},
            {title:"中國是亞洲經(jīng)濟(jì)增長的重要后盾",read:55},
            {title:"美國的任性行為破壞國際貿(mào)易秩序 損人不利己",read:66}
        ];

        window.onload = function () {
            //var newUl = document.getElementById("news");
            var newUl = document.querySelector("#news");

            for(var i=0; i<newsArr.length; i++){
                var li = document.createElement("li");
                li.innerHTML = `新聞標(biāo)題：${newsArr[i].title}，
                                閱讀人數(shù)：${newsArr[i].read}`;
                newUl.appendChild(li);
            }
        };
    </script>
</body>
</html>

ES2016 新增的內(nèi)容

字符串查找:
- str.indexOf(要找的東西)：返回索引(位置) 判帮，沒找到返回-1局嘁。
- str.includes(要找的東西)：返回值 true/false。
  - 判斷瀏覽器的包含信息：includes

navigator.userAgent.includes("Chrome");

字符串是否以誰開頭:
- str.startsWith(檢測東西);晦墙；
字符串是否以誰結(jié)尾：
- str.endsWith(檢測東西);悦昵；例如檢測文件后綴名.png等。
重復(fù)字符串:
- str.repeat(次數(shù));晌畅；

"yjw".repeat(3);  //yjwyjwyjw

字符串填充：
- str.padStart(整個字符串長度, 填充東西)：往前填充但指；
- str.padEnd(整個字符串長度, 填充東西)：往后填充；
- 如果設(shè)定的整個字符串長度小于原來字符串長度抗楔，則不進(jìn)行填充棋凳，得到的還是原字符串。

let str = "aaa";
let padStr = "bbb";
console.log(str.padStart(str.length+padStr.length,padStr));  //bbbaaa
console.log("321".padStart(6,'a'));    //"aaa321"
console.log('321'.padStart(6,"abcdefg"));    //"abc321"
console.log("321".padStart(2,"aaaaaaa"));    //"321"

五谓谦、函數(shù)變化:

1. 函數(shù)默認(rèn)參數(shù)

之前：

function show(a,b) {
    a = a || "Wel ";
    console.log(a + b);
}
show("Welcome ","YJW");  //Welcome YJW
show("Welcome ","");  //Welcome
show("","YJW");  //Wel YJW

現(xiàn)在：

function show({x=0,y=0}={}){
    console.log(x,y);
}
show();

函數(shù)參數(shù)默認(rèn)已經(jīng)定義了贫橙，函數(shù)的參數(shù)作用范圍在函數(shù)體內(nèi)，不能再使用let反粥，const聲明
function show(a=18){
    let a = 101;  //錯誤
    console.log(a);
}
show()

2. rest運(yùn)算符（擴(kuò)展運(yùn)算符）：`...`

展開數(shù)組：

var arr = [1,2,3,4,5];
console.log(...arr);  //1 2 3 4 5

合并為一個數(shù)組：...

function arrSort(...a) {
    console.log(a.sort());    //[1, 2, 3, 8, 9]
}
arrSort(2,1,3,9,8);

剩余參數(shù)：作為參數(shù)必須放到最后卢肃，如 show(a,b,...c);。

3. 箭頭函數(shù)：`=>`

箭頭函數(shù)之前：

function show1() {
    return 1;
}
console.log(show1());  //1

箭頭函數(shù)

let show2 = ()=>1;
console.log(show2());  //1

格式：(參數(shù)) => return東西

(參數(shù)) =>{
    語句
    return
}

注意:
1. this 問題：this 指定義函數(shù)所在的對象才顿，不在是運(yùn)行時所在的對象莫湘；
2. 箭頭函數(shù)里面沒有arguments，用 ‘...arg’
3. 箭頭函數(shù)不能當(dāng)構(gòu)造函數(shù)郑气。

function Person() {
    this.name = "yjw";
}
let pers = new Person();
console.log(pers.name);

let Person2 = ()=>{
    this.name = "yjw";
};
let person = new Person2();
console.log(person.name);   //報錯 Person2 is not a constructor

六幅垮、數(shù)組

1. ES5里面新增一些東西

循環(huán):

之前：
1. for：for(let i=0; i<arr.length; i++){}
2. while
arr.forEach(回調(diào)函數(shù))：// 代替普通for

var arr = ["apple","banana","pear"];
arr.forEach(function (value,index) {
    console.log(value,index);
});

結(jié)果：
  apple 0
  banana 1
  pear 2

其實(shí)它可以接受兩個參數(shù)，arr.forEach/map/...(callback,this指向的值);尾组。

arr.map()：// 非常有用忙芒，做數(shù)據(jù)交互 "映射"
- 正常情況下示弓，需要配合 return，返回是一個新的數(shù)組呵萨；
- 若是沒有 return碟联，相當(dāng)于 forEach
- 注意：平時只要用map明吩，一定是要有return
- 練習(xí)：重新整理數(shù)據(jù)結(jié)構(gòu)：[{title:'aaa'}] -> [{t:'aaaa'}]

let newsArr = [
    {title:"2018博鰲亞洲論壇年會",read:12},
    {title:"中朝啟動志愿軍烈士陵園修繕工程 ",read:33},
    {title:"捍衛(wèi)國家利益锐朴，我們有底氣!",read:44},
    {title:"中國是亞洲經(jīng)濟(jì)增長的重要后盾",read:55},
    {title:"美國的任性行為破壞國際貿(mào)易秩序 損人不利己",read:66}
];
let newArr = newsArr.map(function (value,index) {
    let json = {};
    json.t = `hei${value.title}`;
    json.r = value.read+100;
    return json;
});
console.log(newArr);

結(jié)果：
  [{t: "hei2018博鰲亞洲論壇年會", r: 112},
   {t: "hei中朝啟動志愿軍烈士陵園修繕工程 ", r: 133},
   {t: "hei捍衛(wèi)國家利益哗魂，我們有底氣!", r: 144},
   {t: "hei中國是亞洲經(jīng)濟(jì)增長的重要后盾", r: 155},
   {t: "hei美國的任性行為破壞國際貿(mào)易秩序 損人不利己", r: 166}]

arr.filter()：過濾，過濾一些不合格“元素”忱嘹，如果回調(diào)函數(shù)返回 true嘱腥，數(shù)組中的這條數(shù)據(jù)就會留下來。

let newsArr = [
    {title:"2018博鰲亞洲論壇年會",read:12,top:true},
    {title:"中朝啟動志愿軍烈士陵園修繕工程 ",read:33,top:true},
    {title:"捍衛(wèi)國家利益拘悦，我們有底氣!",read:44,top:false},
    {title:"中國是亞洲經(jīng)濟(jì)增長的重要后盾",read:55,top:true},
    {title:"美國的任性行為破壞國際貿(mào)易秩序 損人不利己",read:66,top:false}
];
let newArr = newsArr.filter(function (value,index) {
    return value.top;
});
console.log(newArr);

結(jié)果：
  [{title: "2018博鰲亞洲論壇年會", read: 12, top: true},    
   {title: "中朝啟動志愿軍烈士陵園修繕工程 ", read: 33, top: true},
   {title: "中國是亞洲經(jīng)濟(jì)增長的重要后盾", read: 55, top: true}]

arr.some()：類似查找, 查找數(shù)組里面某一個元素是否符合條件齿兔，如果符合就返回true。

let newsArr = [
    {title:"2018博鰲亞洲論壇年會",read:12,top:true},
    {title:"中朝啟動志愿軍烈士陵園修繕工程 ",read:33,top:true},
    {title:"捍衛(wèi)國家利益窄做，我們有底氣!",read:44,top:false},
    {title:"中國是亞洲經(jīng)濟(jì)增長的重要后盾",read:55,top:true},
    {title:"美國的任性行為破壞國際貿(mào)易秩序 損人不利己",read:66,top:false}
];
let newArr = newsArr.some(function (value,index) {
    return value.top;
});
console.log(newArr);

結(jié)果：true愧驱。

arr.every()：數(shù)組里面所有的元素都符合條件慰技，才返回 true椭盏，否則返回 false。

let newsArr = [
    {title:"2018博鰲亞洲論壇年會",read:12,top:true},
    {title:"中朝啟動志愿軍烈士陵園修繕工程 ",read:33,top:true},
    {title:"捍衛(wèi)國家利益吻商，我們有底氣!",read:44,top:false},
    {title:"中國是亞洲經(jīng)濟(jì)增長的重要后盾",read:55,top:true},
    {title:"美國的任性行為破壞國際貿(mào)易秩序 損人不利己",read:66,top:false}
];
let newArr = newsArr.every(function (value,index) {
    return value.top;
});
console.log(newArr);

結(jié)果：false掏颊。

以上所有函數(shù)都可以接收兩個參數(shù)：arr.forEach/map...(循環(huán)回調(diào)函數(shù), this指向誰);。

arr.reduce()：//從左往右
- 使用：求數(shù)組的和艾帐、階乘乌叶、乘方等

let arrNum = [2,3,4,5];
let result = arrNum.reduce(function (accumulator, cur, curIndex, arr) {
    //accumulator 為上一次 return 的值，第一次循環(huán)時返回的為數(shù)值中第一個值
    //cur 為當(dāng)前數(shù)組的值
    //curIndex 為當(dāng)前的索引
    //arr 為調(diào)用這個方法的數(shù)組
    console.log("pre:  "+accumulator);
    console.log("cur:  "+cur);
    console.log("val:  "+curIndex);
    console.log("index:"+arr);
    return (accumulator+cur)
});
console.log(result);

pre:  2
cur:  3
val:  1
index:2,3,4,5
pre:  5
cur:  4
val:  2
index:2,3,4,5
pre:  9
cur:  5
val:  3
index:2,3,4,5
14

arr.reduceRight()： //從右往左

let arrNum = [1,3,5,7];
let result = arrNum.reduceRight(function (accumulator, cur, curIndex, arr) {
    //accumulator 為上一次 return 的值柒爸，第一次循環(huán)時返回的為數(shù)值中最后一個值
    //cur 為當(dāng)前數(shù)組的值
    //curIndex 為當(dāng)前的索引
    //arr 為調(diào)用這個方法的數(shù)組
    console.log("pre:  "+accumulator);
    console.log("cur:  "+cur);
    console.log("val:  "+curIndex);
    console.log("arr:  "+arr);
    return (accumulator+cur)
});
console.log(result);

pre:  7
cur:  5
val:  2
arr:  1,3,5,7
pre:  12
cur:  3
val:  1
arr:  1,3,5,7
pre:  15
cur:  1
val:  0
arr:  1,3,5,7
16

ES2017新增一個運(yùn)算符：冪（**）
- Math.pow(2,3) = 2 ** 3

2. ES6：

for....of....：
- arr.keys()：數(shù)組下標(biāo)准浴；
- arr.entries()：數(shù)組中的每一項（包含下標(biāo)和值）；

let arrNum = ["apple","banana","pear"];
for (let value of arrNum){
    console.log(value);
}
//apple
//banana
//pear

let arrNum = ["apple","banana","pear"];
for (let key of arrNum.keys()){
    console.log(key);
}
//0
//1
//2

let arrNum = ["apple","banana","pear"];
for (let entry of arrNum.entries()){
    console.log(entry);
}
//[0, "apple"]
//[1, "banana"]
//[2, "pear"]

let arrNum = ["apple","banana","pear"];
for (let [key,val] of arrNum.entries()){
    console.log(key,val);
}
//0 "apple"
//1 "banana"
//2 "pear"

擴(kuò)展運(yùn)算符：...

let arr =[1,2,3];
let arr2 = [...arr];
let arr3 = Array.from(arr);
//arr2 和 arr3 結(jié)果一樣捎稚。

Array.from:
  作用: 把類數(shù)組(一組元素乐横、arguments...) 對象`轉(zhuǎn)成數(shù)組`
  暫時發(fā)現(xiàn)：具備 length這個東西，就靠譜今野。比如 JSON 沒有 length葡公，但是在 JSON 中添加 `length:2` 就可以解決問題。

Array.of()：把一組值条霜，轉(zhuǎn)成數(shù)組

let arr = Array.of("aaa","bbb","ccc");
console.log(arr);    //["aaa", "bbb", "ccc"]

arr.find(): 查找催什，找出第一個符合條件的數(shù)組成員，如果沒有找到宰睡，返回undefined

let arr = [12,120,13,101];
let num = arr.find(function (val,index) {
    return val>100;
});
console.log(num);    //120

arr.findIndex()：找的是位置蒲凶，沒找到返回-1

let arr = [12,120,13,101];
let num = arr.findIndex(function (val,index) {
    return val>100;
});
console.log(num);  //1

arr.fill()：填充
- 用法：arr.fill(填充的東西, 開始位置, 結(jié)束位置);气筋。

let arr = new Array(5);
arr.fill("aa",1,3);
console.log(arr);  //[empty × 1, "aa", "aa", empty × 2]

在ES2016里面新增：
- arr.indexOf()；
- arr.includes()旋圆；
- str.includes()裆悄；

let str = "abcdefg";
console.log(str.includes("cd"));  //true
let arr = ["a","b","c","d"];
console.log(arr.indexOf("c"));  //2
console.log(arr.includes("c")); //true

七、對象:

對象簡潔語法(相當(dāng)有用)：

//之前用法
let a = 1;
let b = 2;
let json ={
    a:a,
    b:b,
    showA:function(){
        return this.a;
    }
    showB:function(){
        return this.b;
    }
}

//現(xiàn)在用法
let json ={
    a,
    b,
    showA(){  //個人建議: 一定注意臂聋，不要用箭頭函數(shù)
    },
    showB(){
    }
}

new Vuex.Store({
    state,
    mutation,
    types,
    actions
});

new Vue({
    router,
    App,
    vuex
});

Object.is()：用來比較兩個值是否相等
- 語法：Object.is('a','a');

console.log(NaN == NaN);  //false
console.log(Number.isNaN(NaN));  //true
console.log(Object.is(NaN,NaN));  //true

console.log(+0 == -0);  //true
console.log(Object.is(+0,-0));  //false
console.log(Object.is("aaa","aaa"));  //true

Object.assign()：用來合并對象光稼、復(fù)制對象
- 語法：let 新的對象 = Object.assign(目標(biāo)對象, source1, srouce2....);

let a = {a:1};
let b = {b:2,a:2};  // 有重復(fù)變量時，后面的會覆蓋前面的
let c = {c:3};
let json = Object.assign({},a,b,c);
console.log(json);    // {a: 2, b: 2, c: 3}

使用：

function ajax(options){  // options 為用戶傳的參數(shù)
    let defaults={
        type:'get',
        header:
        data:{}
        ....
    };

    let json = Object.assign({}, defaults, options);
    .....
}

let arr = ["a","b","c"];
let newArr = Object.assign([],arr);
newArr.push("dd");
console.log(arr);    //["a", "b", "c"]
console.log(newArr);    //["a", "b", "c", "dd"]

用途:
1. 復(fù)制一個對象孩等；
2. 合并參數(shù)艾君。

ES2017引入:

Object.keys(obj);
Object.entries(obj);
Object.values(obj);

let json = {
    a:111,
    b:222,
    c:333
};
console.log(Object.keys(json));  // ["a", "b", "c"]
console.log(Object.values(json));  // [111, 222, 333]
console.log(Object.entries(json));  // [["a", 111],["b", 222],["c", 333]]

let {keys, values, entries} = Object;
for (let key of keys(obj){
    ....
}

擴(kuò)展運(yùn)算符：...，計劃在ES2018引入

let json = {
    a:111,
    b:222,
    c:333,
    d:444
};

let {a,b,...c} = json;
console.log(a,b,c);  //111 222 {c: 333, d: 444}

let json = {
    a:111,
    b:222,
    c:333,
    d:444
};
let newJson = {...json};
delete newJson.a;
console.log(newJson);  //{b: 222, c: 333, d: 444}
console.log(json);  //{a: 111, b: 222, c: 333, d: 444}

八肄方、Promise

作用: 解決異步回調(diào)問題
傳統(tǒng)方式冰垄，大部分用回調(diào)函數(shù)，事件：

ajax(url,{  //獲取token
    ajax(url,()=>{  //獲取用戶信息
        ajax(url, ()=>{
            //獲取用戶相關(guān)新聞
        })
    })
})

Promise 基本語法：

let promise = new Promise(function(resolve, reject){
    //resolve,   成功調(diào)用
    //reject     失敗調(diào)用
});

promise.then(res=>{
    //成功時候執(zhí)行這里
    ....  
}, err=>{
    //失敗時候執(zhí)行這里
    ....
});

promise.catch(err=>{
    //失敗時候會執(zhí)行這里
    ....
})

let a = 1;
let promise = new Promise(function (resolve, reject) {
    if (a == 10){
        resolve("成功啦权她。虹茶。。");
    }else {
        reject("失敗了隅要。蝴罪。。");
    }
});

promise.then(res=>{
    console.log(res);
},err=>{
    console.log(err);
});
promise.catch(err=>{
    console.log(err);
});
// 失敗了步清。要门。。
// 失敗了廓啊。欢搜。。
// 如果 let = 10谴轮；會打印 “成功啦炒瘟。。第步〈埃”

因為 promise.then 中失敗的回調(diào)方法和 promise.catch 中失敗的回調(diào)方法一樣，此處只需調(diào)用一個即可：

new Promise().then(res=>{
    ....
}).catch(err=>{
    ....
})

let a = 10;
let promise = new Promise(function (resolve, reject) {
    if (a == 10){
        resolve("成功啦雌续。斩个。。");
    }else {
        reject("失敗了驯杜。受啥。。");
    }
}).then(res=>{
    console.log(res);
}).catch(err=>{
    console.log(err);
});
// 成功啦。滚局。居暖。

Promise.resolve('aa')：將現(xiàn)有的東西，轉(zhuǎn)成一個promise對象藤肢， resolve 狀態(tài)太闺，成功狀態(tài)。等價于:

new Promise(resolve =>{
    resolve('aaa')
});

Promise.reject('aaa')：將現(xiàn)有的東西嘁圈，轉(zhuǎn)成一個promise 對象省骂，reject 狀態(tài)，失敗狀態(tài)最住。等價于：

new Promise((resolve, reject) =>{
    reject('aaa')
});

let p1 = Promise.resolve("succ--哈哈哈");
let p2 = Promise.reject("fail--嘿嘿嘿");
p1.then(res=>{
    console.log(res);    // succ--哈哈哈
});
p2.then(res=>{
    console.log(res);
},err=>{
    console.log(err);   // fail--嘿嘿嘿
});

批量處理函數(shù)：Promise.all([p1, p2, p3])：把 promise 打包钞澳，扔到一個數(shù)組里面，打包完還是一個promise對象涨缚。

let p1 = Promise.resolve("aaa");
let p2 = Promise.resolve("bbb");
let p3 = Promise.resolve("ccc");

Promise.all([p1,p2,p3]).then(res=>{
    console.log(res);
}).catch(err => {
    console.log(err);
})
// ["aaa", "bbb", "ccc"]

必須確保轧粟，所有的promise對象，都是resolve狀態(tài)脓魏，都是成功狀態(tài)兰吟，否則只會返回失敗的那個信息

let p1 = Promise.resolve("aaa");
let p2 = Promise.resolve("bbb");
let p3 = Promise.reject("ccc");

Promise.all([p1,p2,p3]).then(res=>{
    console.log(res);
}).catch(err => {
    console.log(err);
});
// ccc

Promise.race([p1, p2, p3])：只會返回第一個

let p1 = Promise.reject("aaa");
let p2 = Promise.resolve("bbb");
let p3 = Promise.resolve("ccc");

Promise.race([p1,p2,p3]).then(res => {
    console.log(res);
}).catch(err => {
    console.log(err);
});
//aaa

執(zhí)行順序比較：

new Promise(function (resolve, reject) {
    console.log("1111");

    resolve("22222");

    new Promise(function (resolve, reject) {
        resolve("333333")
    }).then(function (res) {
        console.log(res);
    });

    setTimeout(function () {
        console.log("44444");
    },0);

    console.log("66666");
    
}).then(res => {
    console.log(res)
});

console.log("55555");

結(jié)果：
    1111
    66666
    55555
    333333
    22222
    44444
    // 發(fā)現(xiàn)定時器是最后執(zhí)行的

使用實(shí)例：用戶登錄 -> 用戶信息。

九茂翔、模塊化

js 不支持模塊化混蔼；
其它語言中：
- ruby --> require
- python --> import
在ES6之前，社區(qū)制定一套模塊規(guī)范:
- Commonjs：主要服務(wù)端 nodeJs檩电，如：require('http')拄丰；
- AMD：requireJs, curlJs
- CMD：seaJs
ES6出來，統(tǒng)一服務(wù)端和客戶端模塊規(guī)范：import {xx} ddd

模塊化：

注意：需要放到服務(wù)器環(huán)境
如何定義模塊俐末？

① export  東西
② export const a =12;
③ export{
      a as aaa,    // 以后導(dǎo)入的時候只能導(dǎo)入 aaa  ：import {aaa} from "./a.js";
      b as banana    // 以后導(dǎo)入的時候只能導(dǎo)入 banana
   }
④ export default aaa;  // 導(dǎo)入的方式不需要 {}：import aaa from "./a.js";

如何使用?

<script type="module">
    ① import
    ② import './modules/1.js';
    ③ import {aaa as a, banana as b, cup as c} from './modules/2.js';  // 使用時候只能用 a、b奄侠、c
    ④ import * as modTwo from './modules/2.js';
</script>

import：特點(diǎn)
a. import 可以是相對路徑卓箫，也可以是絕對路徑：import “https://code.jquery.com/jquery-3.3.1.js”;；
b. import 模塊實(shí)際上只會導(dǎo)入一次垄潮，無論你引入多少次烹卒；
c. import './modules/1.js'; 如果這么用，相當(dāng)于引入文件弯洗，要的不是這個效果旅急，而是：import {a} form './modules/1.js';；
d. 有提升效果牡整，import 會自動提升到頂部藐吮，首先執(zhí)行；
e. 導(dǎo)出去模塊內(nèi)容，如果里面有定時器更改谣辞，外面也會改動迫摔，不像 Common 規(guī)范緩存。
默認(rèn) import 語法不能寫到 if 之類里面泥从，即不能根據(jù)條件去有選擇性的導(dǎo)入某個文件句占。

import()：類似 node 里面 require，可以動態(tài)引入躯嫉，返回值纱烘，是個 promise 對象，可以采用 promise 規(guī)范：

//這樣就可以根據(jù)條件加載了
function result(a){
    switch(a){
      case 1:
          return "./1.js";
          break;
      case ...
    }
}
import(result(1)).then(res=>{
  console.log(res.a+res.b);
});

優(yōu)點(diǎn):
  1. 按需加載
  2. 可以寫if中
  3. 路徑也可以動態(tài)

Promise.all([import("./1.js"),import("./2.js")]).then(([mod1,mod2]) => {
    console.log(mod1);
    console.log(mod2);
});

ES2017 加 async await祈餐，import 可以配合這兩個使用凹炸。
use strict：以后默認(rèn)就是嚴(yán)格模式。

十昼弟、類和繼承

ES6 之前：函數(shù)模擬啤它。

人:  Person
    屬性: name
    展示名字: showName

    Person.prototype.showName

function Person(name,age){
  this.name='aaa';
  this.age = age;
}
Person.prototype.showName=function(){
  return `名字是：${this.name}`;
}
let p1 = new Person("yjw",18);

程序中類

面向?qū)ο?，類
    屬性
    方法

ES6中變形:

    class Person{
        constructor(name,age){  //構(gòu)造方法（函數(shù)）舱痘，調(diào)用 new 時变骡，自動執(zhí)行
            this.name = name;
            this.age = age
        } 
        showName(){
            return `名字是：${this.name}`;
        }
    }
    let p = new Person("yjw",18);

其它定義格式：const Person = class{}。

let name = "yjw";
class Person{
    [name](){
        console.log("haha "+name);
    }
}
let p = new Person();
p[name]();  //haha yjw
// [] 中放變量名芭逝，這樣通過 [] 就可以變成一個屬性塌碌，屬性名可以是表達(dá)式

注意：
1. ES6 里面 class 沒有提升功能，在 ES5旬盯，用函數(shù)模擬可以台妆，默認(rèn)函數(shù)提升；
2. ES6 里面 this 比之前輕松多了胖翰。

矯正this:
1. fn.call(this指向誰, args1, args2....) // 函數(shù)執(zhí)行時才會綁定接剩；
2. fn.apply(this指向誰, [args1, args2....]) // 函數(shù)執(zhí)行時才會綁定；
3. fn.bind()萨咳。
class里面取值函數(shù)(getter), 存值函數(shù)(setter)

class Person{
    set name(val){
        console.log(`設(shè)置了 name 的值懊缺，值為：${val}`);
    }

    get name(){
        return `獲得了 name 屬性的值`;
    }
}

let p = new Person();
p.name = "yjw";    //設(shè)置了 name 的值，值為：yjw
console.log(p.name);    //獲得了 name 屬性的值

靜態(tài)方法：就是類身上方法培他，在方法名前加 static 即可：

class Person{
    showName(){
        return "展示 name";
    }
    static showLog(){
        return "展示 靜態(tài)方法";
    }
}

let p = new Person();
console.log(p.showName());    //展示 name
console.log(Person.showLog());    //展示 靜態(tài)方法

繼承:

// 之前:
function Person(name) {
    this.name = name;
}
Person.prototype.showName = function () {
    return `名字是：${this.name}`;
};

function Student(name, skill) {
    Person.call(this,name);  // 繼承 name 屬性
    this.skill = skill;
}

Student.prototype = new Person();   // 繼承方法

let p = new Person("yjw");
console.log(p.showName());  //名字是：yjw

let s = new Student("wang");
console.log(s.name);  //wang
console.log(s.showName());  //名字是：wang

//現(xiàn)在: extends
class Person{
    constructor(name){
        this.name = name;
    }
    showName(){
        return `名字是：${this.name}`;
    }
}

class Student extends Person{
    constructor(name,skill){
        super(name);
        this.skill = skill;
    }
}

let s = new Student("yjw","study");
console.log(s.name);    //yjw
console.log(s.showName());  //名字是：yjw
console.log(s.skill);   //study

拖拽

十一鹃两、Symbol

ES6 多一個數(shù)據(jù)類型 Symbol（首字母一定要大寫）；
使用頻率不高舀凛，node 底層可能會用到俊扳；
定義：

let sym = Symbol("aaa");
console.log(sym);    //Symbol(aaa)
console.log(typeof sym);    //symbol，用 typeof 檢測出來數(shù)據(jù)類型：symbol

注意：
1. Symbol 不能 new猛遍；
2. Symbol() 返回一個唯一值：做一個 key馋记，定義一些唯一或者私有一些東西号坡；
3. symbol 是一個單獨(dú)數(shù)據(jù)類型，就叫 symbol抗果，是一個基本類型筋帖。所有數(shù)據(jù)類型：number、string冤馏、boolean日麸、symbol、undefined逮光、Object代箭、function。
4. 如果 symbol 作為 key 涕刚，用 for in 循環(huán)嗡综，會出不來。

let sym = Symbol("aaa");
let json = {
    a:"aaa",
    b:"bbb",
    [sym]:"symbol"
};
for (let key in json){
    console.log(key);
}

//結(jié)果
a
b

十二杜漠、generator 函數(shù)

生成器极景；
解決異步深度嵌套的問題，但是現(xiàn)在多用 async 解決異步問題（后面會講）驾茴；
語法:

// 方法一：
function * show(){
    yield
}
//方法二
function* show(){
    yield
}
//方法三
function *show(){
    yield
}

//使用
function * gen() {
    yield 111111;
    yield (function () {return 2222;})();
    return 33333;
}

let g = gen();
console.log(g.next());  //{value: 111111, done: false}
console.log(g.next());  //{value: 2222, done: false}
console.log(g.next());  //{value: 33333, done: true}
console.log(g.next());  //{value: undefined, done: true}

console.log(gen().next());  //{value: 111111, done: false}
console.log(gen().next());  //{value: 111111, done: false}

上述調(diào)用盼樟，手動調(diào)用，麻煩：可以配合 for .. of 自動遍歷 generator：

function * gen() {
    yield 111111;
    yield (function () {return 2222;})();
    yield 333333;
    return 444444;
    yield 555555;
}

for (let val of gen()){
    console.log(val);
}

111111
2222
333333
// return 的東西锈至，不會被遍歷
//并且 return 后面的數(shù)據(jù)也不會被遍歷晨缴，yield 中的 return 不會被影響

generator 不僅可以配合 for ... of ...，還可以與其它配合使用峡捡。
解構(gòu)賦值：

function * gen() {
    yield 111111;
    yield (function () {return 2222;})();
    yield 333333;
    return 444444;
    yield 555555;
}

let [a,b,c,d] = gen();
console.log(a, b, c, d);  //111111 2222 333333 undefined

擴(kuò)展運(yùn)算符：...

function * gen() {
    yield 111111;
    yield (function () {return 2222;})();
    yield 333333;
    return 444444;
    yield 555555;
}

let [a,...b] = gen();
console.log(a, b);
// 111111 [2222, 333333]

Array.from()：

function * gen() {
    yield 111111;
    yield (function () {return 2222;})();
    yield 333333;
    return 444444;
    yield 555555;
}

let arr =Array.from(gen());
console.log(arr);  //[111111, 2222, 333333]

generator結(jié)合 axios數(shù)據(jù)請求：

十三击碗、async

異步：不連續(xù)，上一個操作沒有執(zhí)行完们拙，下一個操作照樣開始稍途；
同步：連續(xù)執(zhí)行，上一個操作沒有執(zhí)行完睛竣，下一個沒法開始晰房。
關(guān)于異步，解決方案：
a). 回調(diào)函數(shù)
b). 事件監(jiān)聽
c). 發(fā)布/訂閱 (emit/on)
d). Promise對象
自動執(zhí)行的庫：co....等等
ES2017射沟，規(guī)定 async。在函數(shù)名前面加 async与境，在函數(shù)里面配合 await 使用验夯，意在說明 await 后面的操作是耗時的，不能立刻返回結(jié)果摔刁。

async function fn(){  //表示異步挥转，這個函數(shù)里面有異步任務(wù)
    let result = await  xxx //表示后面結(jié)果需要等待    
}

nodeJs 中讀取文件 fs.readFile。

首先創(chuàng)建三個文件：aaa.txt（里面存有aaaaaaaaaaaaaaaaaaaaaaaaaaaaa）、bbb.txt（里面存有bbbbbbbbbbbbb）绑谣、ccc.txt（里面存有cccccccccccc）

//1. promise
let fs = require("fs");

let read = function (fileName) {
    return new Promise((resolve,reject) => {
        fs.readFile(fileName,function (err,res) {
            if (err) reject(err);
            resolve(res)
        });
    });
};

read("./aaa.txt").then(res=>{
    console.log(res.toString());
    return read("./bbb.txt");
}).then(res=>{
    console.log(res.toString());
    return read("./ccc.txt");
}).then(res=>{
    console.log(res.toString());
});
//aaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//bbbbbbbbbbbbb
//cccccccccccc

//2. genrator
let fs = require("fs");

let read = function (fileName) {
    return new Promise((resolve,reject) => {
        fs.readFile(fileName,function (err,res) {
            if (err) reject(err);
            resolve(res)
        });
    });
};

function * gen(){
    yield read("./aaa.txt");
    yield read("./bbb.txt");
    yield read("./ccc.txt");
}
let g = gen();
g.next().value.then(res => {
    console.log(res.toString());
    return g.next().value;
}).then(res => {
    console.log(res.toString());
    return g.next().value;
}).then(res => {
    console.log(res.toString());
});
//aaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//bbbbbbbbbbbbb
//cccccccccccc

//3. async
let fs = require("fs");

let read = function (fileName) {
    return new Promise((resolve,reject) => {
        fs.readFile(fileName,function (err,res) {
            if (err) reject(err);
            resolve(res)
        });
    });
};
async function fn() {
    let f1 = await read("./aaa.txt");
    console.log(f1.toString());

    let f2 = await read("./bbb.txt");
    console.log(f2.toString());

    let f3 = await read("./ccc.txt");
    console.log(f3.toString());
}

fn();
//aaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//bbbbbbbbbbbbb
//cccccccccccc

async 特點(diǎn)：
1. await 只能放到 async 函數(shù)中党窜；
2. 相比 genrator 語義化更強(qiáng)；
3. await 后面可以是 promise 對象借宵，也可以數(shù)字幌衣、字符串、布爾壤玫；
4. async 函數(shù)返回是一個 promise 對象豁护；
5. 只要 await 語句后面 Promise 狀態(tài)變成 reject，那么整個 async 函數(shù)會中斷執(zhí)行欲间。

如何解決async函數(shù)中拋出錯誤楚里，影響后續(xù)代碼:
a).
try{

    }catch(e){
        
    }
b). promise本身catch

個人建議大家:
try{
let f1 = await readFile('data/a.txt');
let f3 = await readFile('data/c.txt');
let f2 = await readFile('data/b.txt');
}catch(e){}

async await

數(shù)據(jù)結(jié)構(gòu)
數(shù)組
json，二叉樹....

set數(shù)據(jù)結(jié)構(gòu):
類似數(shù)組猎贴，但是里面不能有重復(fù)值

let arr = ['a','b','a'];

let arr = new Array();

set用法:
let setArr = new Set(['a','b']);

setArr.add('a');   往setArr里面添加一項
setArr.delete('b'); 刪除一項
setArr.has('a') 判斷setArr里面有沒有此值
setArr.size 個數(shù)

setArr.clear(); 清空

for...of...

循環(huán):
    a). for(let item of setArr){  //默認(rèn)是values()
                console.log(item);
            }
    b). for(let item of setArr.keys()){console.log(item);}
    c). for(let item of setArr.values()){}
    d). for(let [k,v] of setArr.entries()){}
    
    e). setArr.forEach((value,index) =>{
                console.log(value, index);
            });

let setArr = new Set().add('a').add('b').add('c');

數(shù)組去重:
let arr = [1,2,3,4,5,6,7,6,5,4,3,2,1,2,3,4,4];
let newArr = [...new Set(arr)];
console.log(newArr);

set數(shù)據(jù)結(jié)構(gòu)變成數(shù)組:
[...set]

想讓set使用數(shù)組的班缎，map循環(huán)和filter:

let arr = [{},{}];

new Set([]); 存儲數(shù)組，這種寫法對

new WeakSet({}) 存儲json她渴，這種寫法不靠譜

WeakSet沒有size达址，也沒有clear()

有， add(), has(), delete()

確認(rèn)惹骂，初始往里面添加?xùn)|西苏携，是不行的。最好用add添加

總結(jié): new Set()

let json ={
p1:1,
b:2
};

map:
類似 json, 但是json的鍵(key)只能是字符串

map的key可以是任意類型

使用:
let map = new Map();

map.set(key,value);    設(shè)置一個值

map.get(key)    獲取一個值

map.delete(key) 刪除一項

map.has(key)    判斷有沒有

map.clear() 清空

循環(huán):
for(let [key,value] of map){}

for(let key of map.keys()){}

for(let value of map.values()){}

for(let [k,v] of map.entries()){}

map.forEach((value, key) =>{
    console.log(value, key);
})

WeakMap(): key只能是對象

總結(jié)：
Set 里面是數(shù)組对粪，不重復(fù)右冻，沒有key，沒有g(shù)et方法
Map 對json功能增強(qiáng)著拭，key可以是任意類型值

十四纱扭、數(shù)字(數(shù)值)變化:

二進(jìn)制和八進(jìn)制表示法：

二進(jìn)制: (Binary)，使用 0b 或 0B 表示儡遮，0b010101;
八進(jìn)制: (Octal)乳蛾，使用 0o 或 0O 表示，0o666;
將二進(jìn)制或者八進(jìn)制的數(shù)轉(zhuǎn)化為十進(jìn)制的數(shù)：Nunber(0o777)鄙币；

Number.isNaN(NaN) -> true

Number.isFinite(a) 判斷是不是數(shù)字 √
Number.isInteger(a) 判斷數(shù)字是不是整數(shù) √

-------------------------------------------
Number.parseInt();
Number.parseFloat();

安全整數(shù):
2**3

安全整數(shù):    -(2^53-1) 到 (2^53-1),   包含-(2^53-1) 和(2^53-1)

Number.isSafeInteger(a);

Number.MAX_SAFE_INTEGER 最大安全整數(shù)
Number.MIN_SAFE_INTEGER 最小安全整數(shù)

Math:
Math.abs()
Math.sqrt()
Math.sin()

Math.trunc()    截取肃叶，只保留整數(shù)部分
    Math.trunc(4.5)  ->  4
    Math.trunc(4.9)  ->  4

Math.sign(-5)   判斷一個數(shù)到底是正數(shù)、負(fù)數(shù)十嘿、0
    Math.sign(-5)  ->  -1
    Math.sign(5)  -> 1
    Math.sign(0)    ->  0
    Math.sign(-0)   ->  -0
    其他值因惭，返回 NaN

Math.cbrt() 計算一個數(shù)立方根

    Math.cbrt(27)  ->  3

.......

ES2018(ES9):
1. 命名捕獲
語法: (?<名字>)

    let str = '2018-03-20';
    let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
    let {year, month ,day} = str.match(reg).groups;
    console.log(year, month, day);
反向引用:
    \1  \2     $1  $2
反向引用命名捕獲:
    語法:  \k<名字>

    let reg = /^(?<Strive>welcome)-\k<Strive>$/;

    匹配: ‘welcome-welcome’

    -------------------------------------------------

    let reg = /^(?<Strive>welcome)-\k<Strive>-\1$/;

    匹配: 'welcome-welcome-welcome'

替換:
    $<名字>

    let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
    str = str.replace(reg,'$<day>/$<month>/$<year>');
    console.log(str);

    ----------------------------------------
    str = str.replace(reg, (...args)=>{
        //console.log(args)
        let {year, month, day} = args[args.length-1];

        return `${day}/${month}/${year}`;
    });

    console.log(str);

2.   dotAll 模式  s

    之前 '.' 在正則里表示匹配任意東西， 但是不包括 \n 

   let reg = /\w+/gims;

3. 標(biāo)簽函數(shù)
    function fn(){

    }

    fn()  //這樣調(diào)用就是普通函數(shù)

    fn`aaa`  //標(biāo)簽函數(shù)使用

    -----------------------------------
    function fn(args){
        return args[0].toUpperCase();
    }

    console.log(fn`welcome`);

ES2018(ES9)

proxy: 代理
擴(kuò)展(增強(qiáng))對象绩衷、方法(函數(shù))一些功能

比如: 
    Vue

    Vue.config.keyCodes.enter=65

Proxy作用: 比如vue中攔截
    預(yù)警蹦魔、上報激率、擴(kuò)展功能、統(tǒng)計勿决、增強(qiáng)對象等等

proxy是設(shè)計模式一種乒躺，  代理模式

let obj ={
name:'Strive'
};
//您訪問了name
obj.name // Strive

語法:
new Proxy(target, handler);
let obj = new Proxy(被代理的對象,對代理的對象做什么操作)

handler:

{
    set(){},  //設(shè)置的時候干的事情
    get(){},  //獲取干的事情
    deleteProperty(){},  //刪除
    has(){}  //問你有沒有這個東西  ‘xxx’ in obj
    apply()  //調(diào)用函數(shù)處理
    .....
}

實(shí)現(xiàn)一個，訪問一個對象身上屬性低缩，默認(rèn)不存在的時候給了undefined嘉冒，希望如果不存在錯誤(警告)信息：

DOM.div()
DOM.a();
DOM.ul()

set(), 設(shè)置，攔截:
設(shè)置一個年齡表制，保證是整數(shù)健爬，且范圍不能超過200

deleteProperty(): 刪除，攔截:

has(): 檢測有沒有

apply() :攔截方法

Reflect.apply(調(diào)用的函數(shù)么介，this指向娜遵，參數(shù)數(shù)組);

fn.call()
fn.apply() 類似

Reflect: 反射
Object.xxx 語言內(nèi)部方法

    Object.defineProperty

放到Reflect對象身上

通過Reflect對象身上直接拿到語言內(nèi)部東西

'assign' in Object    ->   Reflect.has(Object, 'assign')

delete json.a       ->   Reflect.deleteProperty(json, 'a');

最后編輯于：2019.06.19 14:43:14

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市壤短，隨后出現(xiàn)的幾起案子设拟，更是在濱河造成了極大的恐慌，老刑警劉巖久脯，帶你破解...
沈念sama閱讀 206,214評論 6贊 481
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件纳胧，死亡現(xiàn)場離奇詭異，居然都是意外死亡帘撰，警方通過查閱死者的電腦和手機(jī)跑慕，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 88,307評論 2贊 382
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來摧找，“玉大人核行，你說我怎么就攤上這事〉旁牛” “怎么了芝雪？”我有些...
開封第一講書人閱讀 152,543評論 0贊 341
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長综苔。經(jīng)常有香客問我惩系，道長，這世上最難降的妖魔是什么如筛？我笑而不...
開封第一講書人閱讀 55,221評論 1贊 279
?港島之戀（遺憾婚禮）
正文為了忘掉前任堡牡，我火速辦了婚禮，結(jié)果婚禮上杨刨，老公的妹妹穿的比我還像新娘悴侵。我一直安慰自己，他們只是感情好拭嫁，可當(dāng)我...
茶點(diǎn)故事閱讀 64,224評論 5贊 371
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布可免。她就那樣靜靜地躺著，像睡著了一般做粤。火紅的嫁衣襯著肌膚如雪浇借。梳的紋絲不亂的頭發(fā)上，一...
開封第一講書人閱讀 49,007評論 1贊 284
城市分裂傳說
那天怕品，我揣著相機(jī)與錄音妇垢，去河邊找鬼。笑死肉康，一個胖子當(dāng)著我的面吹牛闯估，可吹牛的內(nèi)容都是我干的。我是一名探鬼主播吼和，決...
沈念sama閱讀 38,313評論 3贊 399
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼涨薪，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了炫乓？” 一聲冷哼從身側(cè)響起刚夺，我...
開封第一講書人閱讀 36,956評論 0贊 259
萬榮殺人案實(shí)錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎末捣，沒想到半個月后侠姑，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體，經(jīng)...
沈念sama閱讀 43,441評論 1贊 300
?護(hù)林員之死
正文獨(dú)居荒郊野嶺守林人離奇死亡箩做，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點(diǎn)故事閱讀 35,925評論 2贊 323
?白月光啟示錄
正文我和宋清朗相戀三年莽红，在試婚紗的時候發(fā)現(xiàn)自己被綠了。大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片邦邦。...
茶點(diǎn)故事閱讀 38,018評論 1贊 333
活死人
序言：一個原本活蹦亂跳的男人離奇死亡安吁，死狀恐怖，靈堂內(nèi)的尸體忽然破棺而出圃酵，到底是詐尸還是另有隱情柳畔，我是刑警寧澤，帶...
沈念sama閱讀 33,685評論 4贊 322
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布郭赐，位于F島的核電站薪韩，受9級特大地震影響，放射性物質(zhì)發(fā)生泄漏捌锭。R本人自食惡果不足惜俘陷，卻給世界環(huán)境...
茶點(diǎn)故事閱讀 39,234評論 3贊 307
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望观谦。院中可真熱鬧拉盾，春花似錦、人聲如沸豁状。這莊子的主人今日做“春日...
開封第一講書人閱讀 30,240評論 0贊 19
一樁弒父案倒得，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至夭禽，卻和暖如春霞掺，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背讹躯。一陣腳步聲響...
開封第一講書人閱讀 31,464評論 1贊 261
情欲美人皮
我被黑心中介騙來泰國打工菩彬，沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留，地道東北人潮梯。一個月前我還...
沈念sama閱讀 45,467評論 2贊 352
代替公主和親
正文我出身青樓骗灶，卻偏偏與公主長得像，于是被迫代替她去往敵國和親秉馏。傳聞我的和親對象是個殘疾皇子耙旦，可洞房花燭夜當(dāng)晚...
茶點(diǎn)故事閱讀 42,762評論 2贊 345