字符串，数组，Math,时间，对象等方法整理

JavaScript 字符串的方法主要用于存储和处理文本。

字符串方法

1.charAt（）返回指定下标位置的字符。

如果index不在0-str.length(不包含str.length)之间，返回空字符串。

var str="hello world";
var str1=str.charAt(6);
console.log(str1); //w

str.codePointAt(下标) number取下标对应字符的编码值

charCodeAt()和codePointAt()的区别：
①如果字符在\u0000~\uffff范围内则他俩没有区别
②如果Unicode 码点大于0xFFFF的字符，则利用charCodeAt()方法返回不完整，要用codePointAt()来返回对应的字符编码

2.charCodeAt(): 返回指定下标位置的字符的unicode编码

这个返回值是 0 - 65535 之间的整数。

var str="hello world";
var str1=str.charCodeAt(1);
var str2=str.charCodeAt(-2); //NaN
console.log(str1); //101

注意：如果index不在0-str.length(不包含str.length)之间，返回NaN。

3.fromCharCode将 Unicode 编码转为一个字符:

var n = String.fromCharCode(65);//A

String.fromCodePoint(‘0xFFFF’)返回编码对应的字符，可以识别大于0xFFFF的字符

String.fromCharCode()不可以识别大于0xFFFF的字符，String.fromCodePoint()可以。

4.indexOf(): 返回某个指定的子字符串在字符串中第一次出现的位置

var str="Hello World";
var str1=str.indexOf("o");
var str2=str.indexOf("world");
var str3=str.indexOf("o",str1+1);
console.log(str1); //4 默认只找第一个关键字位置，从下标0开始查找
console.log(str2); //-1 没有找到
console.log(str3); //7

注意：indexOf()方法对大小写敏感，如果子字符串没有找到，返回-1。第二个参数表示从哪个下标开始查找，没有写则默认从下标0开始查找。

5.lastIndexOf(): 返回某个指定的子字符串在字符串中最后出现的位置。

var str="Hello World";
var str1=str.lastIndexOf("o");
var str2=str.lastIndexOf("world");
var str3=str.lastIndexOf("o",str1-1);
console.log(str1); //7
console.log(str2); //-1
console.log(str3); //4

注意：lastIndexOf()方法对大小写敏感，如果子字符串没有找到，返回-1。第二个参数表示从哪个下标开始查找，没有写则默认从最后一个字符处开始查找。

6.toLowerCase(): 把字符串转为小写，返回新的字符串。

var str="Hello World";
var str1=str.toLowerCase();
console.log(str); //Hello World
console.log(str1); //hello world

7.toUpperCase(): 把字符串转为大写，返回新的字符串。

var str="hello world";
var str1=str.toUpperCase();
console.log(str); //hello world
console.log(str1); //HELLO WORLD

8.slice(): 返回字符串中提取的子字符串。

参数一：起始下标 参数二：结束下标（包前不包后）
不改变原字符串

var str="Hello World";
var str1=str.slice(2); //如果只有一个参数，则提取开始下标到结尾处的所有字符串
var str2=str.slice(2,7); //两个参数，提取下标为2，到下标为7但不包含下标为7的字符串
var str3=str.slice(-7,-2); //如果是负数，-1为字符串的最后一个字符。提取从下标-7开始到下标-2但不包含下标-2的字符串。前一个数要小于后一个数，否则返回空字符串

console.log(str1); //llo World
console.log(str2); //llo W
console.log(str3); //o Wor

9.substring(): 提取字符串中介于两个指定下标之间的字符。

不改变原字符串

var str="Hello World";
var str1=str.substring(2)
var str2=str.substring(2,2);
var str3=str.substring(2,7);
console.log(str1); //llo World
console.log(str2); //如果两个参数相等，返回长度为0的空串
console.log(str3); //llo W

注意：substring()用法与slice()一样，但不接受负值的参数。如果有负数就转换成0

10.substr(): 返回从指定下标开始指定长度的的子字符串

参数一：开始下标 参数二：后面几个
不改变原字符串

var str="Hello World";
var str1=str.substr(1)
var str2=str.substr(1,3);
var str3=str.substr(-3,2);
console.log(str1); //ello World 
console.log(str2); //ell
console.log(str3); //rl

注意：如果没有指定length,返回从下标开始处结尾处的所有字符串。

11.split(): 把字符串分割成字符串数组。

生成新数组

var str="AA BB CC DD";
var string1="1:2:3:4:5";
var str1=str.split("");//如果把空字符串 ("")用作分割符，那么字符串的每个字符之间都会被分割
var str2=str.split(" "); //以空格为分隔符
var str3=str.split("",4); //4指定返回数组的最大长度
var str4=string1.split(":");
console.log(str1); // ["A", "A", " ", "B", "B", " ", "C", "C", " ", "D", "D"]
console.log(str2); //["AA" "BB" "CC" "DD"]
console.log(str3); //["A", "A", " ", "B"]
console.log(str4); // ["1", "2", "3", "4", "5"]

12.replace(): 在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

var str="hello WORLD";
var reg=/o/ig; //o为要替换的关键字，不能加引号，否则替换不生效，i忽略大小写，g表示全局查找。
var str1=str.replace(reg,"**")
console.log(str1); //hell** W**RLD

13.match(): 返回所有查找的关键字内容的数组。

var str="To be or not to be";
var reg=/to/ig;         //搭配正则
var str1=str.match(reg);
console.log(str1); //["To", "to"] //length=2
console.log(str.match("Hello")); //null

14.trim() 方法用于删除字符串的头尾空白符，空白符包括：空格、制表符

tab、换行符等其他空白符等。
trim() 方法不会改变原始字符串。
trim() 方法不适用于 null, undefined, Number 类型。

var str = "       Hello World!        ";
console.log(str.trim());

15.concat() 连接两个或多个字符串，concat() 方法可用于代替加运算符。

形成新字符串，不改变原来的

var text1 = "Hello";
var text2 = "World!";
var text3 = text1.concat(" ",text2);

var text = "Hello" + " " + "World!";
var text = "Hello".concat(" ","World!");

16.search() 方法搜索特定值的字符串，并返回匹配的位置

var str = "The full name of China is the People's Republic of China.";
var pos = str.search("z");//-1 如果没有返回-1
var pos = str.search("h");//1 如果有返回下标

17.startsWith()方法用来判断当前字符串是否是以另外一个给定的子字符串“开头”的，根据判断结果返回 true 或 false。

var str = "To be, or not to be, that is the question.";

alert(str.startsWith("To be"));         // true

18.endsWith()方法用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

19.repeat（num）字符串重复

let str="qwe"
let str2=str.repeat(2)
console.log(str2) //qweqwe

20.padStart()用于头部补全，padEnd()用于尾部补全

'x'.padStart(5, 'ab') // 'ababx'
'x'.padStart(4, 'ab') // 'abax'
'x'.padEnd(5, 'ab') // 'xabab'
'x'.padEnd(4, 'ab') // 'xaba'

padStart()和padStart()一共接受两个参数，第一个参数用来指定字符串的最小长度，第二个参数是用来补全的字符串。

'12'.padStart(10, 'YYYY-MM-DD') // "YYYY-MM-12"
'09-12'.padStart(10, 'YYYY-MM-DD') // "YYYY-09-12"

'1'.padStart(10, '0') // "0000000001"
'123456'.padStart(10, '0') // "0000123456"

21.includes（）判断字符串是否包含某个字符

includes()方法，可以判断NaN，而且直接返回true/false，比较直观；
indexOf()方法，不能判断NaN，返回-1，即不包含，非-1即当前包含的位置。

'a nice string'.includes('nice') //true
'a nice string'.includes('nice', 3) //false
'a nice string'.includes('nice', 2) //true

数组方法

字符串方法可以更好的操作数据

1.reverse() 方法用于颠倒数组中元素的顺序。

var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr.reverse())
Thomas,John,George

2，join() 方法用于把数组中的所有元素放入一个字符串。

var arr = new Array(3)
arr[0] = "my"
arr[1] = "name"
arr[2] = "is"

document.write(arr.join("."))//my.name.is
document.write(arr.join(""))//mynameis
document.write(arr.join(" "))//my name is

3.indexOf(): 返回某个指定的元素在数组中第一次出现的位置

var arr=["Hello","World"];
var arr1=str.indexOf("hello");
console.log(arr1); //0

4.lastIndexOf(): 返回某个指定的元素在数组中最后出现的位置。

var arr=["Hello","World"];
var arr1=str.lastIndexOf("hello");

注意：lastIndexOf()方法对大小写敏感，如果数组没有找到，返回-1。第二个参数表示从哪个下标开始查找，没有写则默认从最后一个数组开始查找。

5.concat() 连接两个或多个数组

形成新数组，不改变原来的

6.slice()从已有的数组中返回你选择的某段数组元素

var a=["a","b","c","d","e"];			
console.log(a.slice(1,3));      //结果："b" ，"c"
//表示从1开始，截止到第三个，包含第三个，不包括第一
console.log(a);                 //结果："a","b","c","d","e"
console.log(a.slice(-1));       //结果："e"
//  如果start是负数，则会从数组尾部开始算起。
console.log(a.slice(0，-1));    //结果："a","b","c","d"
//获取除了最后1个元素以外的全部元素

从下标开始，到下标多少，不包含最后一个

7.splice()从数组中添加或删除元素，然后返回被删除的数组元素。

下标开始，后面几个，返回选中的

var a=["a","b","c","d","e"];
console.log(a.splice(0,3));                //结果：‘a”,“b',"c"
//index:开始位置的索引，count:要删除元素的个数
console.log(a);                            //结果："d"，"e"
//改变原来数组
console.log(a.splice(2,0,"hello"));        //结果："a", "b", "hello", "c", "d", "e"
 //从第3个元素开始不删除元素，并在第3个元素前面新增1个元素hello
console.log(a.splice(2,1,"hello")); 		//结果： "a", "b", "hello", "d", "e"
//从第3个元素开始且删除1个元素，并在原来第3个元素的位置新增1个元素hello
console.log(a.splice(-1,0,"hello"));       //结果："a", "b", "c", "d", "hello", "e"
//从最后1个元素开始且不删除元素，同时在最后1个元素前面新增1个元素hello
console.log(a.splice(-1,1,"hello"));         //结果："a","b","c","d","hello"
//　从最后1个元素开始并删除最后1个元素，同时在删除的最后1个元素的位置新增1个元素hello

注：详情见slice和splice的区别

8.push（ ） 方法（在数组结尾处）向数组添加一个新的元素,返回新数组的长度

9.pop（ ）方法从数组中删除最后一个元素，返回“被弹出”的值

10.shift（ ）删除首个数组元素，并把所有其他元素“位移”到更低的索引,返回被“位移出”的字符串

11.unshift（ ）方法（在开头）向数组添加新元素，并“反向位移”旧元素,方法返回新数组的长度

12 .toString() 把数组转换为数组值（逗号分隔）的字符串。

13.sort() 方法用于对数组的元素进行排序，生成新数组

将数组元素【从小到大排序】，是按照字符串方排列的
//var arr=[13,2,3,5,33];
//function my(a,b){return a-b};
//console.log(arr.sort(my));

比较数字，数字字符串，字母（从小到大）
//function a(num1,num2){
//	if(num1>num2){
//		return 1
//	}else if(num1<num2){
//		return -1
//	}else{
//		return 0
//	}
//}
//var b=arr.sort(a);
//console.log(b)

//【中文汉字】排序比较
//function num_str_china(value1, value2) {              //汉字拼音排序的函数参数
//    if (value1.localeCompare(value2) == -1) {          //小于，返回负数
//      return -1;
//    } else if (value1.localeCompare(value2) == 1) {       //大于，返回正数
//      return 1;
//    } else {                //其他，返回0
//      return 0;
//  }
//}

14 .includes（） 判断数组中是否包含指定的数据

语法：数组.includes(查找的元素 , 从哪开始找)
返回值：布尔值

    let arr = [1, 2, 3, 4, 5];
    let str = arr.includes(3)
    console.log(str); //true

includes()和indexOf()的区别
[1,2,NaN].includes(NaN); //true
[1,2,NaN].indexOf(NaN); //-1

15 .find（）找到数组中满足回调函数的第一个元素

语法：数组.find( 回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
返回值：满足条件的元素（没有返回undefined）

    let arr = [1, 2, 3, 4, 5];
    let str = arr.find((function(value,index,arr){console.log(value,index); return value>3}));
    console.log(str); //4

15.2 findIndex() 找到数组中满足回调函数的第一个元素的索引

var arr3 = ['red','pink','green'];
    var flag3 = arr3.findIndex(item => item === 'yellow')
    console.log(flag3)  // 得到：-1

16. reduce（） 数组求和

语法：数组.reduce(回调函数(累加器，处理的元素，下标，数组本身){},首次累加器的值)
返回值：累加器处理的结果

arr.reduce((total,,currentValue,currentIndex,arr)=>{
total：上一次调用的返回值或初始值
currentValue：当前元素
currentIndex：当前索引
arr：数组
initialValue：第一次调用callback的第一个参数

},initialValue)

var arr=[1,2,3,4]
var sum=arr.reduce((tot,val)=>{
return tot+val
},0)

//initialValue没有会从下标1开始，少循环一次

17. map（） 遍历数组执行指定的回调函数

语法：数组.map(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
返回值：每个元素执行完回调函数返回的结果组成的新数组

    let arr = [1,2,3,4,5]
    let str = arr.map(function(value,index,arr){console.log(value,index); return value>3});
    console.log(str);//[false, false, false, true, true]

18. forEach（）遍历数组

语法：数组.forEach(回调函数( ‘处理的元素’ , ‘下标’ , ‘数组本身’){},回调函数使用的this值)
返回值：undefined

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

区别：map用于数据要改变时候，forEach用于不会改变数组时

19. filter（） 筛选数组

语法：数组.filter(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
返回值：返回一个通过测试即通过回调函数的新数组

    let arr = [1,2,3,4,5]
    let str = arr.filter(function(value,index,arr){console.log(value,index); return value>3});
    console.log(str);//[4, 5]

20 .some（）遍历数组找到符合要求的数据,有一个true就true，都false才false

语法：数组.some(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
返回值：布尔值

let arr = [1,2,3,4,5,6]
let str = arr.some(function(a,index,arr){console.log(index,arr);return a%2===0 ;});
console.log(str);//true
 
//下标即index参数，会返回从0下标到符合值的下标，是可选参数
//数组本身即arr，会返回原数组，为可选参数
//回调函数this值也为可选参数

21. every（）和some一样，有一个false就false，都true就ture

22.entries（）使用[ ]遍历数组

const arr1 = [1, 2, 3]; 
console.log(Object.entries(arr1));  // [['0', 1], ['1', '2'], ['2', '3']]

23.Array. of()创建一个包含指定元素的数组

    let str = Array.of(7,6,5,4,3,2,1)
    console.log(str);//[7, 6, 5, 4, 3, 2, 1]

24.flat() 数组降维

    let arr = [1, [2, 3, 4], 5];
    let str = arr.flat();
    console.log(str);//[1, 2, 3, 4, 5]
  
 
    let arr = [1, [[2, 3], 4], 5];
    let str1 = arr.flat();
    let str2 = arr.flat(2);
    console.log(str1);//[1, Array(2), 4, 5]
    console.log(str2);//[1, 2, 3, 4, 5]

25.Array.from() 伪数组转换成数组

let imgs = Array.from(document.querySelectorAll('img'))

Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。

26.fill(参数,参数2,参数3)使用给定值，填充一个数组。

参数1：填充的值；
参数2（可选）：填充起始位置，
参数3（可选）：填充结束位置（不包括结束位置）

[1,2,3,4,4,4,4].fill(5,1,3)//[1,5,5,4,4,4,4]

27.copyWithin(target, start = 0, end = this.length)在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。

target（必需）：从该位置开始替换数据。如果为负值，表示倒数
start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。
end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算
说明：这三个参数都应该是数值，如果不是，会自动转为数值

[1, 2, 3, 4, 5].copyWithin(0, 3)//[4, 5, 3, 4, 5]
表示将从 3 号位直到数组结束的成员（4 和 5），复制到从 0 号位开始的位置，结果覆盖了原来的 1 和 2

28.Array.isArray(object) 判断是否是数组

 
Array.isArray([1, 2, 3, 4]);  // --> true
 
var obj = {
    a: 1,
    b: 2
};
Array.isArray(obj);  // --> false
 
Array.isArray(new Array);  // --> true
 
Array.isArray("Array");  // --> false

Math

Number.isInteger()判断是否为整数

Number.isInteger()用来判断一个值是否为整数。

需要注意的是，在JavaScript内部，整数和浮点数是同样的储存方法，所以例如5和5.0和5.00被视为同一个值。

Number.isInteger(5) // true
Number.isInteger(5.0) // true
Number.isInteger(5.00) // true
Number.isInteger(5.1) // false
Number.isInteger("5") // false
Number.isInteger(true) // false

Math.PI 返回圆周率（约等于3.14159）

Math.max() 返回一组数里的最大值

Math.max(...array1)

Math.max.apply(Math, arr)求数组最大值

var arr = [1, 23, 4, 5, 6, 7, 99, 8];
var max1 = Math.max.apply(Math, arr);
console.log('使用数学内置对象求得最大值:' + max1);

Math.min() 返回一组数里的最小值

Math.floor() 向下舍入，即它总是将数值向下舍入为最接近的整数(向下取整)

Math.round() 标准舍入，即它总是将数值四舍五入为最接近的整数(四舍五入)

Math.random() 返回 0 ~ 1 之间的随机数。

获取[n-m)之间的随机整数
  Math.floor(Math.random()*(m-n)+n);
  获取[n-m]之间的随机整数
  Math.round(Math.random()*(m-n)+n);

Math.ceil() 向上舍入，即它总是将数值向上舍入为最接近的整数(向上取整)

Math.pow(x,y) 返回 x 的 y 次幂的值。

Math.sqrt(x) 返回一个数的平方根。

.toFixed(2) 保留小数点后几位（转换完是字符串）

Math.trunc():去除一个数的小数部分，返回整数部分

注：对于参数是非数值的，内部会调用Number()方法先转换成数值，
再进行取整，对于空值或者无法截取整数的值，返回NaN

Math.sign()：用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

Math.cbrt() :计算一个数的立方根

Math.hypot()：返回所有参数的平方和的平方根

Number

Infinity 无穷大

无穷可以分为两种，正无穷和负无穷，JS 中对应的表示方式为：+Infinity(或者Infinity) 和 -Infinity。

这意味着Infinity和-Infinity（小于任何有限数的数字）都是number类型的特殊值：

Number.isFinite()：用来检查一个数值是否为有限的（finite）

Number.isNaN()：用来检查一个值是否为NaN

Number.isInteger()：用来判断一个数值是否为整数

Number.parseInt()：将字符串转换为整数

Number.parseFloat() ：将字符串转换为数值，包括浮点数

ES6新增极小的常量Number.EPSILON

作用：“ 能够接受的误差范围 ” 

es6 二进制和八进制表示法

安全整数

Number.isSafeInteger()：用来判断一个整数是否在-2 ^ 53到2^53范围之内

安全整数：JavaScript 能够准确表示的整数范围在-2^53到253之间（不含两个端点），超过这个范围，无法精确表示这个值。

指数运算符(求幂运算符)（**）

BigInt（大整数）第八种数据类型

在JavaScript中超过 53 个二进制位的数值，无法保持精度，超过 2 的 1024 次方的数值，无法表示，会返回Infinity。
BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。

Date 对象 new Date()

var dat=new Date()

dat.Date() 返回当日的日期和时间。

getDate() 天 (1 ~ 31)。

getDay() 星期 (0 ~ 6)。

getMonth() 月 (0 ~ 11)。

getFullYear() 年。

getHours() 小时 (0 ~ 23)。

getMinutes() 分钟 (0 ~ 59)。

getSeconds() 秒数 (0 ~ 59)。

getTime() 返回 1970 年 1 月 1 日至今的毫秒数。

---

setDate() 设置 Date 对象中月的某一天 (1 ~ 31)。

setMonth() 设置 Date 对象中月份 (0 ~ 11)。

setFullYear() 设置 Date 对象中的年份（四位数字）。

setHours() 设置 Date 对象中的小时 (0 ~ 23)。

setMinutes() 设置 Date 对象中的分钟 (0 ~ 59)。

setSeconds() 设置 Date 对象中的秒钟 (0 ~ 59)。

setTime() 以毫秒设置 Date 对象。

toLocaleString() 根据本地时间格式，把 Date 对象转换为字符串。

时间戳转换时间

const date = new Date('1999-6-3 08:34:00')
const time=date.getTime()
console.log(time)//928370040000
console.log(new Date())//Thu Jun 03 1999 08:34:00 GMT+0800 (中国标准时间) {}

对象

对象.hasOwnProperty(‘属性’); 判断对象上是否有属性（不包含原型链）有时候不准确

console.log(obj.hasOwnProperty('age'));        //  true

【】/ . 会获取到原型上的属性

Object.hasOwn(‘对象’，‘属性’) 更加安全（不包含原型链）

属性 in 对象;判断对象上是否有属性（包含原型链）

var mycar = { make: "Honda", model: "Accord", year: 1998 };
console.log("make" in mycar);   // 返回true

Object.is() 判断两个值是否相等

console.log(Object.is(123,123))//true

var o1={a:1}
var o2=o1
console.log(Object.is(o1,o2))//true

Object.assign() 对象合并

Object.assign(obj1,obj2)
相同的覆盖掉，不同不变
// Object.assign(this.searchParams, this.$route.query);

用于跨路由动态传递属性，只会覆盖掉传过来的属性

Object.setPrototypeOf() 设置原型对象

Object.getPrototypeOf() 获取原型对象

const school={'name':'abc'}
const city={'xiaoqu':['上海','北京']}
Object.setPrototypeOf(school,city)
 Object.getPrototypeOf(school) //{xiaoqu: Array(2)}

Object.keys(obj) 遍历 键名

const obj = { name:"张三", age:25, address:"深圳" } 
console.log( Object.keys(obj) )//['name', 'age', 'address']

Object.values(obj) 遍历 键值

const obj = { name:"张三", age:25, address:"深圳" } 
console.log( Object.values(obj) )//['张三', 25, '深圳']

Object.entries(obj)对象转二维数组

const obj = { name:"张三", age:25, address:"深圳" } 
console.log( Object.entries(obj) )

0: (2) ['name', '张三']
1: (2) ['age', 25]
2: (2) ['address', '深圳']

Object.fromEntries([‘name’,‘张三’,‘age’,‘34’])二维数组转对象

Object.create(proto, [propertiesObject]);创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。

参数一：必须值，新创建对象的原型对象（新创建的对象_proto_属性指向现有属性），如果第一个值为null，那么创建出来的对象是一个{}（空对象）并且没有原型;
参数二：可选，新创建实例对象上的属性，和defineProperty四个属性一样

Object.create({'a':1},{
		'name':{
			value:'张三'
		}
	})

和构造函数的区别
new Object()继承内置对象Object，而Object.create()则是继承指定对象
可以通过Object.create(null) 创建一个干净的对象，也就是没有原型，而 new Object()创建的对象是 Object的实例，原型永远指向Object.prototype

Reflect

和proxy的方法一一对应，一共13个

Reflect.get(target,‘name’)判断某属性值

Reflect.set(target, propertyKey, value) 添加方法属性

Proxy与Reflect联合使用，前者完成拦截赋值操作，后者完成赋值默认行为，而且传入了receiver，则Reflect.set会触发Proxy.defineProperty拦截。

let p = {
  a: 'a'
};

let handler = {
  set(target, key, value, receiver) {
    console.log('set');
    Reflect.set(target, key, value, receiver)
  },
  defineProperty(target, key, attribute) {
    console.log('defineProperty');
    Reflect.defineProperty(target, key, attribute);
  }
};

let obj = new Proxy(p, handler);
obj.a = 'A';
// set
// defineProperty

Reflect.has(obj,‘name’)判断是否有属性

Reflect.deleteProperty(obj,‘name’)删除属性

Reflect.construct(target, args)new生成构造函数

function Greeting(name) {
  this.name = name;
}

// new 的写法
const instance = new Greeting('张三');

// Reflect.construct 的写法
const instance = Reflect.construct(Greeting, ['张三']);

Reflect.getPrototypeOf(target) __ proto__ 属性

Reflect.setPrototypeOf(target, prototype)设置原型

const arr=Reflect.ownKeys(obj) 返回所有key

Reflect详解

循环对象

1.for in

const obj = { name:"张三", age:25, address:"深圳" } 

for(let i in obj){
	console.log(i)//name，age，address
	console.log(obj[i])//张三,25,深圳
}

2.for of循环对象

for (let i of Object.keys(obj)){
	console.log(i)//name，age，address
}
for (let a of Object.values(obj)){
	console.log(a)//张三,25,深圳
}

3.Reflect.ownKeys(obj)

var obj = {
       1: '未开始',
       2: '生成中',
       3: '生成完成',
       4: '生成失败',
   }

Reflect.ownKeys(obj).forEach(key=>{
console.log(key,obj[key]);
});