ES5及ES6的新增特性

介紹

es5的新特性

嚴格模式（對應的相反的稱為怪異模式）

'use strict' //一般用于相關的設計 上面書寫一個嚴格模式底下的代碼就需要按照嚴格模式執行

嚴格模式的特性

變數必須要帶修飾符

"use strict";
a = 10
console.log(a); //a is not defined

 函式里面this不能指向window

function sayHello(){
console.log(this); //undefined
}
sayHello()

• 不允許在非函式的代碼塊內宣告函式
• 禁止八進制方法
• 函式的arguments陣列形參和實參不同步

對于陣列和字串都進行了加強

陣列的高階函式（以函式做的引數的函式 稱為高階函式）

forEach 遍歷的

var arr = [1,2,3,4,5]
//forEach 遍歷的 value表示里面的值 index表示里面的下標 array表示當前遍歷的陣列
var forEachObj = arr.forEach(function(value,index,array){
console.log(value); //列印里面的值 1,2,3,4,5
console.log(index) // 列印下標 0,1,2,3,4
console.log(array) //當前遍歷的陣列 [1,2,3,4,5]
})

map 遍歷

//map 遍歷的 value表示里面的值 index表示下標 array表示當前的遍歷的陣列
var mapObj = arr.map(function(value,index,array){
console.log(value); //列印里面的值 1,2,3,4,5
console.log(index) // 列印下標 0,1,2,3,4
console.log(array) //當前遍歷的陣列 [1,2,3,4,5]
return value+1
})

forEach和map的區別

• forEach沒有回傳值 里面沒有return
• map有回傳值 所以里面可以使用return關鍵詞他的回傳值是一個陣列

forEach和map的底層實作

//forEach方法實作
function forEach(fn){
//遍歷這個arr
for(var i=0;i<arr.length;i++){
fn(arr[i],i,arr)
}
}
// map方法實作
function map(fn){
var res = []
//遍歷這個arr
for(var i=0;i<arr.length;i++){
res.push(fn(arr[i],i,arr))
}
return res
}

reduce 從左到右計算的 reduceRight（從右到左計算）

//pre 前一個值 current 當前值 index 下標 array 陣列
//reduce函式 利用前一個和后面值進行運算的操作 得出對應的值
var sum = arr.reduce(function(pre,current,index,arr){
return pre+current
})
console.log(sum);

reduce底層實作

// 底層實作reduce
function reduce(fn){
//如果只有一個直接回傳
if(arr.length==1) return arr[0]
var res = arr[0]
//如果有多個的情況
for(var i=1;i<arr.length;i++){
res = fn(res,arr[i],i,arr)
}
return res
}

filter 過濾的

//filter回傳的是一個陣列 value index arr
var filterArr = arr.filter(function(value,index,arr){
return value>3
})
console.log(filterArr);

filter的底層實作

//實作filter函式
function filter(fn){
var res = []
//遍歷陣列
for(var i=0;i<arr.length;i++){
if(fn(arr[i],i,arr)){
res.push(arr[i])
}
}
return res
}

some 有一些滿足就回傳true 否則回傳false

//some 一些 every 每一個
var value = https://www.cnblogs.com/toweiwei/p/arr.some(function(value,index,arr){
return value>4
})
console.log(value);//true

every 每一個滿足就回傳true 否則回傳false

var value = https://www.cnblogs.com/toweiwei/p/arr.every(function(value,index,arr){
return value>4
})
console.log(value);//false

底層實作

//底層實作 some
function some(fn){
var isTrue = false
for(var i=0;i<arr.length;i++){
if(fn(arr[i],i,arr)){
isTrue = true
break
}
}
return isTrue
}
//底層實作 some
function every(fn){
var isTrue = true
for(var i=0;i<arr.length;i++){
if(!fn(arr[i],i,arr)){
isTrue = false
break
}

indexOf 回傳對應的下標

lastIndexOf 回傳對應的下標

console.log(arr.indexOf(1,2));//從下標開始找 找這個1這個數字第一次出現的位置(左到右)
console.log(arr.lastIndexOf(1,5));//從下標5開始找 找1第一個次出現的位置(右到左)

字串加強 （模板字串 ）

var a ='hello'
console.log(`${a} world`) //hello world

es5新增的改變this指向的方法

bind （不會自動執行）

function say(){
console.log(this) //指向window
}
say() //列印window
//通過函式呼叫
var obj = { username:"jack" }
say.bind(obj)()//列印的this指向obj

call （自動呼叫函式）

// call 將this指向和某個內容聯系在一塊 自動呼叫 傳參一個個用,隔開
say.call(obj,'tom','456')

apply （自動呼叫函式）

//apply 將this指向重新指向給對應的某個內容 自動呼叫 陣列傳遞
say.apply(obj,['劉德華','123'])

call和apply的區別

• call傳遞的引數是一個個的內容，使用,隔開
• apply傳遞的引數是一個整個陣列

es6的新特性

概述：es6對應陣列 字串 物件及函式以及回圈,值型別，修飾符等都有加強（es6以后的內容都稱為es6的內容）

陣列的增強

find 查找

findIndex 查找下標

var li = Array.from(lis).find(function(li){
return li.innerText == '5'
}) //找到對應匹配的元素
console.log(li);
//findIndex 查找對應的元素的下標 回傳第一個找到的元素下標
var index = Array.from(lis).findIndex(function(li,index,arr){
return li.innerText == '5'
})
console.log(index);

靜態方法（使用類名.）

Array.of() 將一組資料轉為陣列

Array.from() 將偽陣列轉為陣列

var array = Array.of(1,2,3,4,5)
console.log(array);
//具備某些陣列的特性的物件稱為偽陣列 arguments NodeList HTMLCollection等
var lis = document.querySelectorAll('li')
// 偽陣列是不具備陣列的函式的
Array.from(lis).forEach(function(li){
console.log(li.innerText);
})

字符的增強

includes 是否包含 （包含回傳true 不包含回傳false）

startsWith 是否以這個字串開頭 （是回傳true 不是回傳false）

endsWith 是否以這個字串結尾 （是回傳true 不是回傳false）

repeat 重復多次的去平鋪對應的字串

// indexOf的基礎上增強
//是否包含 includes
console.log('abc'.includes('a')); //true
//endsWith 是否以這個字串結尾
console.log('abc'.endsWith('abc'));//true
console.log('abc'.endsWith('c'));//true
//startsWith 是否以這個字串開頭
console.log('abc'.startsWith('a'));//true
console.log('abc'.startsWith('abc'));//true
//平鋪 repeat 平鋪的次數 重復多次的寫個字串
console.log('abc'.repeat(3));//將abc寫3次

變數修飾符（增強）

var 關鍵詞修飾的變數是偽全域變數（進行變數提升）

let 關鍵詞 塊狀作用域 （變數名不能重復宣告 避免變數名污染）

const 關鍵詞 常量（常量不可變 也不能重復宣告 宣告一定要賦值（不能二次賦值））

var btns = document.querySelectorAll('button')
// var 關鍵詞宣告的偽全域作用域
for(var i=0;i<btns.length;i++){
btns[i].onclick = function(){ //當前的事件是異步操作
console.log(i); //3 異步比同步晚執行 var關鍵詞修飾的變數是偽全域變數
}
}
// let 塊級作用域 只在當前的代碼塊內有用
for(let i=0;i<btns.length;i++){
btns[i].onclick = function(){ //當前的事件是異步操作
console.log(i); //3 異步比同步晚執行 var關鍵詞修飾的變數是偽全域變數
}
}
// let 在同一作用域優點不能重復命名
let a = 10
// let a = 20 報錯 不能重復宣告
// 當你省略了對應的修飾符 默認就是以var關鍵詞修飾
// const關鍵詞 宣告常量 他同樣具備塊級作用域 const定義的變數的不能重新賦值
// 宣告的時候 必須要賦值
const a = 10
// a = 20 錯誤的 因為const修飾的變數不允許更改
// const b 錯誤的 必須要賦值
// es6 不是所有瀏覽器都可以直接決議的 不建議寫原始碼的時候用let const (babel.js 決議es高版本
的內容 把變成低版本的)

新增的值型別

舊有值型別

number , String , boolean , null , undefined

新增的型別

symbol 獨一無二的值 bigInt 大的整型

//如果去宣告一個Symbol
var v = Symbol() //獨一無二的值
var s = Symbol('這個值很重要') //里面的引數是一個說明
var s1 = Symbol('這個值很重要') //里面的引數是一個說明
console.log(v);
console.log(s == s1);
console.log(s.description);//獲取里面的詳情資訊 也可以設定 當前這個詳情是一個只讀屬性
description
v.description = 'hello' //沒用 他是個只讀屬性
//key是獨一無二 當作物件的key值
var obj = {v:'hello'}
console.log(obj.v);
//bigInt 大的整型(存盤number存不了的資料) 實作的方式 字串傳入實作
// 傳入字串
var str = '123456789123456789'
console.log( Number(str));
var bigNumber = BigInt(str)
console.log(bigNumber);

物件的增強

靜態方法

is方法 Object.is() 判斷倆個物件是否是一個（true或者false）

// NaN
console.log(NaN == NaN);//false
//Object.is 主要解決NaN和NaN的問題
console.log(Object.is(NaN,NaN));//true NaN是值型別(常量)
console.log(Object.is({},{}));//false {}物件

Object.assign 將后面物件合并當前前面 回傳的是合并的物件

var obj = {sex:'男'}
//assign 目標物件 來源物件 將后面的合并到前面 回傳一個物件 會影響之前的物件
var res = Object.assign(obj,{name:'張三',age:18})
console.log(obj);
console.log(res);
console.log(Object.is(obj,res));//true 淺拷貝( Object.assign)

函式增強

箭頭函式

// //箭頭函式一般都是匿名函式
// var hello = function(){ //之前的寫法
// }
//箭頭函式的寫法 ()形參 {}代碼塊 把function省略了 加了個=>
var hello = ()=>{
console.log('hello')
}
//呼叫
hello()

箭頭函式的簡化

• 如果只有一個引數 可以省略()

// 簡化 如果只有一個引數可以省略()
var say = username => {
console.log(username);
}
say('jack')

• 如果只有一句代碼的話 可以省略{}

//當你只有一句代碼的時候 {} 可以省略
var world = username => console.log(username)
world('hello')

• 如果只有一句代碼 且你需要回傳資料情況下 可以省略對應的 retrun

//當你只有一句代碼的時候 且你需要回傳值 那么return可以被省略
var getUserName = username => username+'hello'
var value = https://www.cnblogs.com/toweiwei/p/getUserName('張三')
console.log(value); //張三hello
//陣列的forEach方法
[1,2,3].forEach(value=https://www.cnblogs.com/toweiwei/p/>console.log(value))
// 陣列的reduce方法
var sum = [1,2,3].reduce((pre,current)=>pre+current)
console.log(sum);

箭頭函式的特性

• 箭頭函式里面沒有this（根據作用域鏈向上查找對應的this）

// this誰呼叫 this指向誰 是在對應的普通函式的情況下
// document.querySelector('button').onclick = function(){
// console.log(this);//指向當前按鈕
// }
//箭頭函式
document.querySelector('button').onclick = ()=>{
console.log(this); //箭頭函式里面沒有this 根據作用域鏈的情況 向上找 window
}
var hello = ()=>{
console.log(this);
}
hello.call({age:18}) // window

默認引數

function fn(agr1=value,arg2=value2){
}
// 初始化一個物件 默認值
function initObj(name,age=18,sex='男'){
return {
name,age,sex
}
}
console.log(initObj('jack'));//沒有傳參會使用默認值
console.log(initObj('jack',19,'女'));//傳了參會覆寫默認值

物件里面內容的簡化

屬性的簡化

當你的屬性值是一個變數的情況下，以及你向使用你的變數作為key的名，這個時候可以省略key

var age = 18
var username =
'
jack'
//簡化 使用變數做鍵的名 {age:age,username:username}
var obj = {age,username}

函式的簡寫

var obj = {
say:function(){
console.log('hello')
}
}
obj.say()
//簡寫 省略:和function
var obj = {
say(){
console.log('hello')
}
}
obj.say()

回圈的加強

• for in 是用于遍歷物件的 遍歷的是物件的里面key 他也可以遍歷陣列（陣列也是物件）
• for of 是用于遍歷陣列的 遍歷的是陣列里面的value 他不可以遍歷物件（只有實作了迭代器的物件才可以被遍歷 必須具備length或者size屬性）

如果要使用對應的for of來遍歷物件的話 怎么辦！！

Object的幾個方法（靜態方法） 可以用來實作對應的遍歷

keys 拿到所有的key

values 拿到所有的值

entries 拿到所有的鍵值對

var obj = {age:18,name:'jack',sex:'男'}
//keys 獲取所有的key 作為一個迭代物件
var k = Object.keys(obj)
console.log(k);
//values 獲取所有的value
var v = Object.values(obj)
//entries 獲取所有的key-value對
var e = Object.entries(obj)

新增的對應的迭代器型別（實作了迭代器）

set 元素不重復的一個集合（去重）

set宣告

無參

var set = new Set() //空的集合

將陣列作為引數傳遞

var arr = [1,1,2,2,3,3]
var set = new Set(arr) //傳入陣列
console.log(set) //1 2 3

相關的方法（增刪改查）

• add 添加
• delete 洗掉
• clear 清空
• keys 獲取key
• values 獲取值
• entries 獲取鍵值物件
• forEach 遍歷（三個引數分別是value,key,set）
• has 判斷是否存在 （回傳的是boolean型別）

屬性

size 獲取對應的長度

//無參的形式
var set = new Set()
//添加 add append push...
set.add(1)
set.add(2)
set.add(1)
//獲取對應的set的長度 size
console.log(set.size);//2
//洗掉方法 delete remove
set.delete(1) //洗掉1這個value值
//洗掉所有 清空
// set.clear()
//獲取元素
var key = set.keys() //獲取所有key 值既是key 又是值
var value = https://www.cnblogs.com/toweiwei/p/set.values() //獲取所有的值
var kv = set.entries() //獲取所有的鍵值對
console.log(kv);
console.log(key);
console.log(value);
//set里面有一個forEach方法
// 第一個是值 第二個key 第三個是遍歷的set
set.forEach((v,k,set)=>{
console.log(v);
})
//has 判斷是否存在 回傳true和false
console.log(set.has(2));//true

WeakSet 內容存盤對應的set（只能存盤物件 但并不能完成去重）

var weakset = new WeakSet()
weakset.add({username:"張三"})
weakset.add({username:"張三"})
weakset.add({username:"張三"})
console.log(weakset);//里面還是存在3個

map 基于set和array之上構建的一個集合

標籤：JavaScript

上一篇：前端常用布局方式大全——細致講解

下一篇：ES5及ES6的新增特性