ES5及ES6
作者：互联网
ES5的严格模式
所谓严格模式，从字面上就很好理解，即更严格的模式，在这种模式下执行，浏览器会对JS的要求更苛刻，语法格式要求更细致，更符合逻辑。
怪异模式：就是我们之前一直使用的开发模式，就叫怪异模式。因为很多时候出来的结果是非常怪异的，所以才称之为怪异模式。
'use strict' //一般用于相关的设计 上面书写一个严格模式底下的代码就需要按照严格模式执行
严格模式的特性
- 不可以省略var声明变量
- 禁止函数使用this关键字指向全局变量
- 禁止使用八进制方法
- 不允许在非函数的代码块内声明函数
- 严格模式下,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()
reduce()用法： 接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终为一个值，是ES5中新增的一个数组逐项处理方法。
//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 = arr.some(function(value,index,arr){
return value>4
})
console.log(value);//true
every 每一个满足就返回true 否则返回false
var value = arr.every(function(value,index,arr){
return value>4
})
console.log(value);//false
some和every的底层实现
//底层实现 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
}
}
return isTrue
}
indexOf() : 判断数组中是否包含某个元素， 和字符串的indexOf用法类似
//返回数组元素索引号方法 indexOf(数组元素) 返回数组的索引号
//只返回第一个满足条件的索引号
//如果在该数组里面找不到元素，则返回的时 -1
var arr = ['a', 's', 'd', 's', 'a']
console.log(arr.indexOf('s')); //1
console.log(arr.indexOf('h')); //-1
//封装一个 去重的函数
function unique(arr) {
var newArr = [];
for (i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i]) === -1) {
newArr.push(arr[i]);
}
}
return newArr;
}
var arr = ['a', 's', 'd', 's', 'a'];
console.log(unique(arr)); //['a', 's', 'd']
forEach() : 用来遍历数组中的每一项；这个方法执行是没有返回值的，对原来数组也没有影响
字符串加强
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查找
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);
对象的增强
Object.is( , )用来比较两个值是否严格相等。它与严格比较运算符（===）的行为基本一致， 不同之处只有两个：一是+0不等于-0，二是NaN等于自身
// 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() 方法用来将源对象（source）的所有可枚举属性，复制到目标对象（target）。它至少需要两个对象作为参数，第一个参数是目标对象，后面的参数都是源对象。只要有一个参数不是对象，就会抛出TypeError错误。
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()
(1)如果只有一个参数 可以省略（）
// 简化 如果只有一个参数可以省略()
var say = username => {
console.log(username);
}
say('jack')
(2)如果只有一句代码的话 可以省略{}
//当你只有一句代码的时候 {} 可以省略
var world = username => console.log(username)
world('hello')
(3)如果只有一句代码 且你需要返回数据情况下 可以省略对应的retur
//当你只有一句代码的时候 且你需要返回值 那么return可以被省略
var getUserName = username => username+'hello'
var value = getUserName('张三')
console.log(value); //张三hello
//数组的forEach方法
[1,2,3].forEach(value=>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 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属性）
//1、for循环遍历
var arr = ['red', 'green', 'blue'];
for (var i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
//2、for in遍历(可遍历对象 也可遍历数组)
var arr = [1, 2, 3, 4];
for (var index in arr) { //index表示下标
console.log(arr[index]);
}
//3、for of遍历（只能遍历数组）
var arr = [1, 2, 3, 4];
for (var value of arr) { //value表示里面的值
console.log(value);
}
新增的对应的迭代器类型
//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 = 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个
标签：ES6,ES5,console,log,arr,value,数组,var 来源： https://www.cnblogs.com/-lsg10026244/p/16581034.html