ES6(2)_es6 tostring(2)-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43398720/article/details/103027213

ES6

字符串扩展：

includes(str)，判断是否包含指定的字符串，返回的是布尔值,包含返回true，不包含返回false
- include(“文件路径”):加载文件，不是字符串扩展
- require(“文件路径”):加载文件，不是字符串扩展
```
var str='qwerty';
console.log(str.includes('t'));//true
console.log(str.includes('we'));//true
console.log(str.includes('a'));//false
```

startsWith(str)，判断是否以指定的字符串开头，返回的是布尔值

var str='qwerty';
console.log(str.startsWith('q'));//true
console.log(str.startsWith('qw'));//true
console.log(str.startsWith('ty'));//false

endWith(str)，判断是否以指定的字符串结尾，返回的是布尔值

var str='qwerty';
console.log(str.endWith('y'));//true
console.log(str.endWith('ty'));//true
console.log(str.endWith('ert'));//false

repeat(count)，重复指定次数

var str='qwe';
console.log(str.repeat(3));//qweqweqwe

数值扩展

Number.isFinite(i)，判断是否是有限大的数，返回布尔值

console.log(1/0);//Infinity,无限大
console.log(Number.MAX_VALUE);//1.7976931348623157e+308
console.log(Number.isFinite(Infinity));//false
console.log(Number.isFinite(3));//true

Number.isNaN(i)，判断是否是NaN，返回布尔值

一个数和NaN做计算，绝对返回的是NaN（not a Number）

console.log(Number.isNaN(4+'12'));//false
console.log(Number.isNaN('22'-'20'));//false
console.log(Number.isNaN(NaN));//true

Number.isInterger(i)，判断是否是整数，返回是布尔值

后台语言中，小数就是小数，整数就是整数，不一样

console.log(Number.isInterger(13.3));//false
console.log(Number.isInterger(13));//true
console.log(Number.isInterger(13.0));//true
console.log(Number.isInterger(13));//true

Number.parseInt(i)，将字符串转换为对应的数值

碰到非数字就停止

console.log(Number.parseInt(13abc));//13
console.log(Number.parseInt(13abc45));//13
console.log(Number.parseInt(abc45));//NaN

Math.trunc(i)，直接去除小数部分
```
console.log(Math.trunc(12.34));//12
```

数组扩展

Array.from(arr)，将伪数组对象或可遍历对象转换为真数组

forEach：循环数组

<div>1</div>
<div>2</div>
<div>3</div>
<div>4</div>
<div>5</div>
。。。。。。
Array.from(div).forEach(function(value,index){
	console.log(value);
})

Array.of(arr1,arr2,arr3)，将一系列的值转换成数组

let arr=Array.of(1,2,3,4,5);
console.log(arr);//[1,2,3,4,5]
arr.forEach(function(value,index){
	console.log(value);
})

find(function(value,index,arr){return true})，找出第一个满足条件返回true的元素，若是没有满足条件的元素就返回-1
```
let arr=[1,2,3,4,5,6];
let aaa=arr.find((value,index)=>value>4);
console.log(aaa);//5
```
findIndex(function(value,index,arr){return true})，找出第一个满足条件返回true的元素的下标，若是没有满足条件的元素就返回-1
```
let arr=[1,2,3,4,5,6];
let a=arr.findIndex((value,index)=>value>4);
console.log(a);//4
let b=arr.findIndex((value,index)=>value>9);
console.log(b);//-1
```

对象扩展

Object.is(obj1,obj2)，判断两个数据的值是否完全相等

console.log(Object.is('abc','abc'));//true
console.log(Object.is(window,window));//true
let a={
	name:"张三",
	age:10
}
let b={
	name:"张三",
	age:10
}
b=a;
console.log(Object.is(b,a));//true

Object.assign(target,source1,source2…)，将源对象的属性复制到目标对象上来

assign：分配，分派
(target（目标对象）,source1（源对象）,source2…)

let obj1={
	name:"张三",
	age:10,
	a:{
		c:40
	}
}
let obj2={
	name:"张三",
	age:33,
	a:{
		c:30
	}
}
let qq = Object.assign(obj2(目标对象),obj1(源对象));
console.log(qq);//

直接操作__ proto __属性，

let obj2={
	name:"张三",
	age:33,
	a:{
		c:30
	}
}

let obj1={}
boj1.__proto__=obj2;
//将obj2的属性复制到obj1上来
console.log(obj2.name,obj2.age);

深度克隆

JS堆栈和拷贝

基本类型：存放在栈内存中的简单数据段，数据大小确定，内存空间大小可分配，string，布尔，number
- 特点：存储的是该对象的真实数据，存储在栈里面

var num1=2;
var num2=num1;
console.log(num1,num2);//2,2
num2=3;
console.log(num1,num2);//2,3
//谁也不影响谁

引用类型：存放在堆内存中的对象，变量实际保存的是一个指针（地址），这个指针指向另一个位置，每个空间大小不一样，要根据情况进行特定分配，object，array，function
- 栈里存储的是地址，所以复制的是地址，也就是指针地址，而真实的数据是存储在堆内存中，两个指向的都是同一个堆内存，所以改变的是同一个堆内存

var obj={name:'111'};
var obj1=obj;
console.log(obj,obj1);//{name:'111'}{name:'111'}
obj1.name='222';//改变的是堆内存的值
console.log(obj,obj1);//{name:'222'}{name:'222'}

传值与传址

传值会影响原来的值
传址会影响原来的值

深拷贝

不希望父子对象之间产生关联
拷贝出来的内容，更改的时候，不回去影响原来的内容

object的容器是{}、array的容器是 []

第一步：首先是分析，获取数据类型，是基本数据类型还是引用数据类型

//获取数据类型的方法
<script>
    var arr=[1,2,3,4];
    var a=132;
    var null=null;
    var un=undefined;
	function getTypeof(obj){
        let result=Object.prototype.toString.call(obj).slice(8,-1);//截取，只要后面的部分
        /*if(result == 'null'){
            return null;
        }else if(result == 'undefined'){
            return undefined;
        }*/
        return result;
    }
    console.log(getTypeof(arr))//[Object Array]
    console.log(getTypeof(a))//[Object Number]
    console.log(getTypeof(null))//[Object Null]
    console.log(getTypeof(nu))//[Object Undefined]
</script>

第二步：引用数据类型中，分析是数组还是对象，
- 数组的话定义一个 [] 的容器
- 对象的话定义一个 {} 的容器

第三步：深度拷贝 clone

<script>
    //-----------一维数组
    function getTypeof(obj) {
    let result = Object.prototype.toString.call(obj).slice(8, -1);
    //截取，只要后面的部分
    return result;
}
function copyclone(obj) {
    //box 设置一个保存容器
    let box;
    //获取数据类型
    let classes = getTypeof(obj);//Array
    //分析传过来的数据类型是什么
    if (classes == 'Object') {
        box = {};
    } else if (classes == 'Array') {
        box = [];
    } else {
        return classes;
        //如果是基本数据类型，直接就传出去
    }
    //循环遍历
    for (key in obj) {
        //获取每一个值
        var value = obj[key];
        box[key] = value;
    	}
    return box;
	}
	var arr = [1, 2, 3, 4, 5, 6];
	var x = copyclone(arr);
	console.log(x);//(6) [1, 2, 3, 4, 5, 6]
	x[3]=13333;
	console.log(x);//(6) [1, 2, 3, 13333, 5, 6]
	console.log(arr);//(6) [1, 2, 3, 4, 5, 6]
}
//-------------------二维数组
var arr = [1, 2, [3, 4, 5], 6];
    //需要递归
    for (key in obj) {
        //获取每一个值
        var value = obj[key];
        if(getTypeof(value)=='Object'||getTypeof(value)=='Array'){
            box[key]=copyclone(value);
            //递归返回的是函数调用处，从哪里递归就返回哪里
        }else{
         box[key] = value;   
        }
   }
</script>

set和map

set容器：无序的，不可重复的多个value的集合，类似数组，但是成员都是唯一的，没有重复

一般数组有序且可重复

Set本身是一个构造函数，需要new实例化

Set()
Set(array)定义
add()添加，不可以添加里面已有的值，添加不上
size长度，并不是数组长度，就是个数
delete()删除
has()是否有空，返回布尔值
clear()清空

let set=new Ser([1,2,3,4,5,2,1,2,1])
console.log(set);//Set[1,2,3,4,5];
set.add(11);
console.log(set);//Set[1,2,3,4,5,11];
set.add(11);//再添加一次里面已经有的，是添加不上的
console.log(set);//Set[1,2,3,4,5,11];
console.log(set.size);//6//并不是长度
set.delete(1);
console.log(set);//Set[2,3,4,5,11];
console.log(set.has(2));//true
set.clear()
console.log(set);//Set[];

map() Map容器，无序的，key不可以重复的多个key-value的集合

Map(array)
set(key,valve) 添加
get(key) 获取
delete(key) 删除
has(key) 是否存在，返回的是布尔值
clear() 清空
size() 获取长度，大小

let map=new Map([
	['name','张三'],
	['age','20']
	['name','李四']
])
console.log(map);//Map(2){name 箭头 "李四",age 箭头 "20"}
//key一致时，他的的value，后面的会覆盖前面的
map.set(20,20);//添加
console.log(map);//Map(3){name 箭头 "李四",age 箭头 "20",20 箭头 20}
map.get('age');//20//获取
map/delete(20,20);//删除
map.has('sex');//false//是否存在
map.size();//key的个数
map.clear();//Map(0)

for…of 循环

遍历数组
遍历set
遍历map
遍历字符串
遍历伪数组
有[Symbol.iterator]这个机制的就可以用for…of

<script>
	let set=new Set([1,2,3,4]);
    for(x of set){
        console.log(x);
   }
</script>