基础篇

基础类型

1. typeof类型判断

typeof 对于原始类型来说，除了 null 都可以显示正确的类型

typeof 1 // 'number'
typeof '1' // 'string'
typeof undefined // 'undefined'
typeof true // 'boolean'
typeof Symbol() // 'symbol'

typeof 对于对象来说，除了函数都会显示 object，所以说 typeof 并不能准确判断变量到底是什么类型

如果我们想判断一个对象的正确类型，这时候可以考虑使用 instanceof，因为内部机制是通过原型链来判断的

const Person = function() {}
const p1 = new Person()
p1 instanceof Person // true

var str = 'hello world'
str instanceof String // false

var str1 = new String('hello world')
str1 instanceof String // true

对于原始类型来说，你想直接通过 instanceof来判断类型是不行的

2. 字符串操作属性

1、Unicode编码（charCodeAt方法）

返回一个整数，代表指定位置字符的Unicode编码。

strObj.charCodeAt(index)

说明： index将被处理字符的从零开始计数的编号。有效值为0到字符串长度减1的数字。如果指定位置没有字符，将返回NaN。例如：

var str = "ABC"; 
str.charCodeAt(0); 
结果：65

2、Unicode返回字符串（fromCharCode方法）

从一些Unicode字符串中返回一个字符串。

String.fromCharCode([code1[,code2...]])

说明： code1，code2…是要转换为字符串的Unicode字符串序列。如果没有参数，结果为空字符串。例如：

String.fromCharCode(65,66,112); 
结果：ABp

提示： charCodeAt和fromCharCode刚好是两个相反的方法，charCodeAt返回的是指定位置的字符的字符编码，而fromCharCode返回的是指定字符编码代表的字符。

3、索引位置（charAt方法）

返回指定索引位置处的字符。如果超出有效范围的索引值返回空字符串。

strObj.charAt(index)

说明： index想得到的字符的基于零的索引。有效值是0与字符串长度减一之间的值。例如：

var str = "ABC"; 
str.charAt(1); 
结果：B

4、查找（indexOf方法）

返回String对象内第一次出现子字符串索引位置（从左到右搜索）。如果没有找到子字符串，则返回-1。

strObj.indexOf(substr[,startIndex])

说明：

参数substr为要在String对象中查找的子字符串。
参数startIndex为该整数值指出在String对象内开始查找的索引。如果省略，则从字符串的开始处查找。例如：

01234567 
var str = "ABCDECDF"; 
str.indexOf("CD"，1); // 由1位置从左向右查找 123... 
结果：2

提示： charAt和indexOf刚好是两个相反的方法，charAt返回的是指定索引位置的字符，而indexOf返回的是指定字符的索引位置。

5、lastIndexOf方法

返回String对象中字符串最后出现的位置。如果没有匹配到子字符串，则返回-1。

strObj.lastIndexOf(substr[,startindex])

说明：

substr要在String对象内查找的子字符串。
startindex该整数值指出在String对象内进行查找的开始索引位置。如果省略，则查找从字符串的末尾开始。例如：

01234567 
var str = "ABCDECDF"; 
str.lastIndexOf("CD",6); // 由6位置从右向左查找 ...456 
结果：5

6、返回字符串片段（slice方法）

返回字符串的片段。

strObj.slice(start[,end])

说明：

如果只有一个参数，则复制的是参数数字所表示的长度，索引从0开始
start指明子字符串的起始位置，该索引从0开始起算。如果start为负，将它作为length+start处理，此处length为字符串的长度。
end指明子字符串的结束位置，该索引从0开始起算。如果end为负，将它作为length+end处理，此处length为字符串的长度。

例如：

012345 
var str = "ABCDEF"; 
str.slice(2,4); 
结果：CD 
str.slice（1）
结果：A

7、返回指定字符串（substring方法）

返回位于String对象中指定位置的子字符串。

strObj.substring(start,end)

说明：

start指明子字符串的起始位置，该索引从0开始起算。
end指明子字符串的结束位置，该索引从0开始起算。
substring方法使用start和end两者中的较小值作为子字符串的起始点。
如果start或end为NaN或者为负数，那么将其替换为0。

例如：

012345 
var str = "ABCDEF"; 
str.substring(2,4); // 或 str.substring(4,2); 
// 结果：CD

8、截取一段字符串（substr方法）

返回一个从指定位置开始的指定长度的子字符串。

strObj.substr(start[,length])

说明： start所需的子字符串的起始位置。字符串中的第一个字符的索引为0。 length在返回的子字符串中应包括的字符个数。例如：

012345 
var str = "ABCDEF"; 
str.substr(2,4); 
结果：CDEF

9、查找（search方法）

返回与正则表达式查找内容匹配的第一个字符串的位置。如果没有匹配到子字符串，则返回-1。

strObj.search(reExp)

说明： reExp包含正则表达式模式和可用标志的正则表达式对象。例如：

var str = "ABCDECDF"; 
str.search("CD"); // 或 str.search(/CD/i); 
结果：2

10、concat

将两个或多个字符的文本组合起来，返回一个新的字符串。

str.concat([string1[,string2...]])

说明： string1，string2要和所有其他指定的字符串进行连接的String对象或文字。例如：

var str = "ABCDEF"; 
str.concat("ABCDEF","ABC"); 
结果：ABCDEFABCDEFABC

和“+”的效果是一样的

11、分割（split）

将一个字符串分割为子字符串，然后将结果作为字符串数组返回。

strObj.split([separator[,limit]])

说明：

separator字符串或正则表达式对象，它标识了分隔字符串时使用的是一个还是多个字符。如果忽略该选项，返回包含整个字符串的单一元素数组。
limit该值用来限制返回数组中的元素个数。例如：

var str = "AA BB CC DD EE FF"; 
alert(str.split(" ",3)); 
结果： 
["AA", "BB", "CC"]

12、toLowerCase方法

返回一个字符串，该字符串中的字母被转换成小写。例如：

var str = "ABCabc"; 
str.toLowerCase(); 
结果：abcabc

13、toUpperCase方法

返回一个字符串，该字符串中的所有字母都被转换为大写字母。例如：

var str = "ABCabc"; 
str.toUpperCase(); 
结果：ABCABC

14、match方法

可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。 match() 方法将检索字符串 String Object，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。例如：

var str = "The rain in SPAIN stays mainly in the plain"; 
var n=str.match(/ain/gi);
结果：["ain", "AIN", "ain", "ain"]

15、replace() 方法

用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。该方法返回替换后的新字符串，该方法不会改变原始字符串。 replace如果替换数据时，默认只替换第一个。例如：

var str=“Mr Blue has a blue house and a blue car.”; 
var n=str.replace(/blue/g,"red");
结果：Mr Blue has a red house and a red car.

16、trim()方法去除字符串两边的空白

浏览器兼容性： IE9及以上

17、valueOf() 方法可返回 String 对象的原始值。

注意： valueOf() 方法通常由 JavaScript 在后台自动进行调用，而不是显式地处于代码中。

例如：
var str="Hello world!";
document.write(str.valueOf());
结果：Hello world!

3. 数组操作属性

增加数组

1、原始的通过下标增加：

var arr = [];
arr[0] = 'a';
arr[1] = 'b';
arr[2] = 1;
arr[3] = 2;
console.log(arr); // ["a", "b", 1, 2]
console.log(arr.length); // 4

2、通过改变length属性增加：

var arr = [];
arr[0] = 'a'; // 给数组arr添加一个`a`数组项
arr.length = 5; // 改变数组的`length`值为`5`
console.log(arr); // ["a", undefined × 4]

3、数组原生的方法（push）增加：

var arr = [];
arr.push('a','b');
console.log(arr); // ['a','b']

说明：push是增加到数组的最后面，其实就是原本的是需要小标才可以增加的，这个方法将这个封装了起来而已。

4、使用unshift() 方法增加到数组前面：

var arr = ['a','b'];
arr.unshift(1,2);
console.log(arr); // [1, 2, "a", "b"]

5、使用splice() 方法指定位置增加：

var arr = ['a','b','c',1,2];
arr.splice(2,0,'d','c','e');//从第二位增加
console.log(arr); // ["a", "b", "d", "c", "e", "c", 1, 2]

6、使用 concat()方法在原有的数组上增加：

var arr = ['a','b','c'];
var arr2 = arr.concat('d',1,2,['e',3]);
console.log(arr); // ["a", "b", "c"]
console.log(arr2); // ["a", "b", "c", "d", 1, 2, "e", 3]

删除数组

1、使用pop() 方法从末尾删除：

var arr = ['a','b','c','d',1,2];
arr.pop();
console.log(arr); // ["a", "b", "c", "d", 1]

2、使用shift() 方法从前面删除：

var arr = ['a','b','c','d',1,2];
arr.shift();
console.log(arr); // ["b", "c", "d", 1, 2]

说明：不管是pop（）还是shift（）都是每次只能删除一个。

3、使用slice()删除多个：

var arr = [1,2,3,4,'a','b'];
var arr2 = arr.slice(2);
console.log(arr); // [1, 2, 3, 4, "a", "b"]
console.log(arr2); // [3, 4, "a", "b"]
console.log(arr3); // ["a", "b"]

说明：slice() 方法可以给一个数组中删除多个数组项，只不过不同的是， slice() 不会影响原数组，只是会在原数组基础上创建一个数组副本

4、使用splice() 方法指定位置删除：

var arr = [1,2,3,4,'a','b','c'];
var arr2 = arr.splice(2,2);
console.log(arr); // [1, 2, "a", "b", "c"]
console.log(arr2); // [3, 4]

更改数组

使用splice() 方法改变一个数组：

var arr = [1,2,3,4,5,6];
var arr2 = arr.splice(2,3,'a','b','c');
console.log(arr); // [1, 2, "a", "b", "c", 6]
console.log(arr2); // [3, 4, 5]

查询数组

使用slice() 方法提取数组的数据：

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

基础类型转换

字符串转数组

1：使用split()方法

split()方法用于将给定字符串拆分为字符串数组，该方法是使用参数中提供的指定分隔符将其分隔为子字符串。

在条件判断时，除了 undefined，null， false， NaN， ''， 0， -0，其他所有值都转为 true，包括所有对象

str.split(separator, limit)

separator 可选。字符串或正则表达式，从该参数指定的地方分割 string Object。
limit 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

var str="Welcome to here ！";

var n=str.split("");

console.log(n);
(17) ["W", "e", "l", "c", "o", "m", "e", " ", "t", "o", " ", "h", "e", "r", "e", " ", "！"]

2：使用Array.from()方法

Array.from()方法是javascript中的一个内置函数，它从给定的数组创建一个新的数组实例。对于字符串，字符串的每个字母表都会转换为新数组实例的元素；对于整数值，新数组实例simple将获取给定数组的元素。

语法：

Array.from(str)

示例：

var str="Welcome to here ！";``
var n=Array.from(str);``
console.log(n);
(17) ["W", "e", "l", "c", "o", "m", "e", " ", "t", "o", " ", "h", "e", "r", "e", " ", "！"]

数组转字符串

1、 toString() 方法读取数组的值。

数组中 toString() 方法能够把每个元素转换为字符串，然后以逗号连接输出显示。

var a = [1,2,3,4,5,6,7,8,9,0];  //定义数组
var s = a.toString();  //把数组转换为字符串
console.log(s);  //返回字符串“1,2,3,4,5,6,7,8,9,0”
console.log(typeof s);  //返回字符串string，说明是字符串类型

2、toLocalString() 方法读取数组的值。

toLocalString() 方法与 toString() 方法用法基本相同，主要区别在于 toLocalString() 方法能够使用用户所在地区特定的分隔符把生成的字符串连接起来，形成一个字符串。

var a = [1,2,3,4,5];  //定义数组var s = a.toLocalString();  //把数组转换为本地字符串console.log(s);  //返回字符串“1,2,3,4,5,6,7,8,9,0”

在上面示例中，toLocalString() 方法根据中国的使用习惯，先把数字转换为浮点数之后再执行字符串转换操作。

3、 join() 方法可以把数组转换为字符串。

join() 方法可以把数组转换为字符串，不过它可以指定分隔符。在调用 join() 方法时，可以传递一个参数作为分隔符来连接每个元素。如果省略参数，默认使用逗号作为分隔符，这时与 toString() 方法转换操作效果相同。

纯文本复制
var a = [1,2,3,4,5];  //定义数组var s = a.join("==");  //指定分隔符console.log(s);  //返回字符串“1==2==3==4==5”

4、split() 方法把字符串转换为数组。

split() 方法是 String 对象方法，与 join() 方法操作正好相反。该方法可以指定两个参数，第 1 个参数为分隔符，指定从哪儿进行分隔的标记；第 2 个参数指定要返回数组的长度。

纯文本复制
var s = "1==2== 3==4 ==5";
var a = s.split("==");
console.log(a);
console.log(a.constructor == Array);

其他类型转换Boolean

在条件判断时，除了 undefined，null， false， NaN， ''， 0， -0，其他所有值都转为 true，包括所有对象

Math对象

1、取整

// 丢弃小数部分,保留整数部分
parseInt(5/2)　　// 2

2、向上取整

Math.ceil()

返回符合条件值；向上取整,有小数就整数部分加1

Math.ceil(7/2)　　// 4

3、向下取整

Math.floor()

返回符合条件值；向下取整,丢弃小数部分

Math.floor(7/2)　　// 3
Math.floor( 45.95); // 45
Math.floor( 45.05); // 45
Math.floor( 4 ); // 4
Math.floor(-45.05); // -46
Math.floor(-45.95);// -46

4、四舍五入

Math.round()

返回符合条件值；四舍五入

Math.round(7/2)　　// 3

5、取最大值

Math.max()

返回参数中的最大值；非数值需要使用Number()方法先将其转换为数值，再进行max计算(); 使用：Math.max(参数1, 参数2, 参数n...);

Math.max(1, 2, '3') // 3
Math.max(1, 2, '-3') // 2

Math.max(-1, -2, '-3', null) // 0 - 使用Number转换为Math.max(-1, -2, -3, 0)
Math.max(-1, -2, '-3', '') // 0 - Math.max(-1, -2, -3, 0)
Math.max(-1, -2, '-3', true) // 1 - Math.max(-1, -2, -3, 1)
Math.max(-1, -2, '-3', false) // 0 - Math.max(-1, -2, -3, 0)

Math.max(1, 2, '3a') // NaN  - 使用Number转换为Math.max(1, 2, NaN)
Math.max(1, 2, undefined) // NaN  - Math.max(1, 2, NaN)
Math.max(1, 2, NaN) // NaN  - Math.max(1, 2, NaN)

6、取最小值Math.min()

7、取余

返回符合条件值；数值取余

7%2　　// 1

提升篇

字符串

判断字符串是否包含另一个字符串

startsWith（）、endsWith（）、includes（）

let message = "foobarbaz"

console.log(message.startsWith("foo"));    //true
console.log(message.startsWith("bar"));    //false

console.log(message.endsWith("baz"));    //true
console.log(message.endsWith("bar"));    //false

console.log(message.startsWith("bar"));    //true
console.log(message.startsWith("qux"));    //false

删除字符串空格

trim() 不改变原始字符串 trimLeft()和trimRight()方法分别用于字符串开始和末尾清理空格符。

let stringValue = "  hello world  ";
let trimmedStringValue = stringValue.trim();
console.log(stringValue);             // "  hello world  "
console.log(trimmedStringValue);      // "hello world"

复制字符串

repeat() 接受一个参数复制多少次

let stringValue = "na "
console.log(stringValue.repeat(16) + 'batman');
// na na na na na na na na na na na na na na na na  batman

padStart()和padEnd() 复制字符串

let stringValue = "foo";
console.log(stringValue.padStart(6));            // "   foo"
console.log(stringValue.padStart(9, "."));       // "......foo"

console.log(stringValue.padEnd(6));              // "foo   "
console.log(stringValue.padEnd(9, "."));         // "foo......"

不仅限于一个字符串。提供多个字符串，则会将其拼接并截断以匹配指定长度。

let stringValue = "foo";
console.log(stringValue.padStart(8, 'bar'));            // "barbafoo"
console.log(stringValue.padStart(2));                   // "foo"

console.log(stringValue.padEnd(8, 'bar'));              // "foobarba"
console.log(stringValue.padEnd(2));                     // "foo"

大小写转换

toLowerCase（）、toLocaleLowerCase（）、toUpperCase（）、toLocaleUpperCase（）。

let stringValue = "hello world";
console.log(stringValue.toLocaleUpperCase());       // "HELLO WORLD"
console.log(stringValue.toUpperCase());             // "HELLO WORLD"
console.log(stringValue.toLocaleLowerCase());       // "hello world"
console.log(stringValue.toLowerCase());             // "hello world"

toLocaleLowerCase() 和 toLocaleUpperCase（）特定地区的方法。

数组

判断是否包含某一个元素

方法一：includes(item, start);

该方法返回布尔值，如果数组中存在给定的元素，则返回true。否则返回false

start:表示搜索的起始位置，默认为 0 。

如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为 -4 ，但数组长度为 3 ），则会重置为从 0 开始。

let arr = [1, 1, 3, 5, 7];
arr.includes(1); // true
arr.includes(4); // false


[1, 2, 3].includes(3, 3); // false

[1, 2, 3].includes(3, -1); // true

方法二：indexOf(item,start);

Item:要查找的值；start：可选的整数参数，缺省则从起始位子开始查找。

indexOf();返回元素在数组中的位置，如果没有则返回-1；

var arr = ['aaa','bbb','ccc','ddd','eee'];
var a = arr.indexOf('ddd');
console.log(a); 　　//3
var b = arr.indexOf('d');
console.log(b);　　//-1

//我通常的用法：
if(arr.indexOf(要查找的元素)>-1){
    元素存在的操作
};

indexOf( )无法查找NaN

方法三：arr.find();

Arr.find()的参数是一个回调函数，数组所有元素会遍历这个回调函数，

直到找到第一个返回值为true的元素，然后返回该元素否则返回undefined；

var arr=['aaa','bbb','ccc','ddd','eee'];

var a=arr.find(function(value,index,arr){
　　return value=='bbb';
})

console.log(a);　　//bbb,这里返回的不是true，而是返回值为true的这个元素；

//我通常的用法：

arr.find(function(value){
　　If(value==要查找的值）{
　　　　//所做的操作
　　}
})

方法四：array.findIndex();

findIndex()和find()的用法相似，find()返回的是元素，findIndex返回的是元素的位置。

findIndex()；返回第一个符合条件的数组元素的位置，如果所有元素都不符合条件则返回-1；findIndex（），数组中的每一个元素都会调用一次函数，但是当条件返回true时，findIndex()返回符合条件的元素的位置，之后的值不会再调用执行函数。　

var arr=['aaa','bbb','ccc','ddd','eee'];
var a=arr.find(function(value,index,arr){
　　return value=='bbb';
})
console.log(a);//1,后面的值不会再调用函数。
// 说明：findIndex()和find()可以用来查找NaN；

var arr=['1','2','3',NaN];
var a=arr.find(function(value){
　　return isNaN(value);
})
console.log(a);    //NaN

方法五：for()或forEach()

循环遍历，然后用if判断

方法六：使用jquery的inArray方法，

该方法返回元素在数组中的下标，如果不存在与数组中，那么返回－１;

var arr=['aaa','bbb','ccc','ddd','eee'];
var a= $.inArray('bbb',arr);
console.log(a);　　　　//1

去重过滤

filter 用于对数组进行过滤。 filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

实例1. 返回数组nums中所有大于5的元素。

let nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let res = nums.filter((num) => {
  return num > 5;
});
console.log(res);  // [6, 7, 8, 9, 10]

实例2. 对数组进行过滤，筛选出年龄大于 18岁的数据

const arr = [
	{
        name: 'tom1',
        age: 23
    },
    {
        name: 'tom2',
        age: 42
    },
    {
        name: 'tom3',
        age: 17
    },
    {
        name: 'tom4',
        age: 13
    },
]
const res = arr.filter(item => item.age > 18);
console.log(res);  //[{name: 'tom1',age: 23},{name: 'tom2',age: 42}]
console.log(arr);

实例3. 利用 filter 遍历出所有偶数

let arr = [56, 15, 48, 3, 7];

let newArr = arr.filter(function (x) {
    return x % 2 === 0;
});

console.log(newArr)
// [56, 48]

实例4.把一个Array中的空字符串删掉，可以这么写：

var arr = ['A', '', 'B', null, undefined, 'C', '  '];
var r = arr.filter(function (s) {
    return s && s.trim(); // 注意：IE9以下的版本没有trim()方法
});
r; // ['A', 'B', 'C']

实例5. 利用 filter 进行数组去重

function unique(arr) {
  return arr.filter(function(item, index, arr) {
    //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
    return arr.indexOf(item, 0) === index;
  });
}
var arr = [1,1,'RUNOOB','RUNOOB',true,true,15];
console.log(unique(arr))
// [1, "RUNOOB", true, 15]

var arr = ['apple','strawberry','banana','pear','apple','orange','orange','strawberry']
var temp_arr = arr.filter(function (element, index, self) {
    return self.indexOf(element) === index
})
console.log(temp_arr)

indexOf总是返回第一个元素的位置，后续的重复元素位置与indexOf返回的位置不相等，因此被filter滤掉了，所以重复的元素仅会保留第一个位置的元素

对象键名替换

将数组的name，和id转成 label和，value 键名。

let campusList=[
    {
    	name:1,
    	id:2,
    },
    {
        name:3,
    	id:4,
    }
]

JSON.parse(JSON.stringify(this.campusList).replace(/name/g, 'label').replace(/id/g, 'value'))

JSON.parse()【从一个字符串中解析出json对象】

JSON.stringify()【从一个对象中解析出字符串】

先在对象中解析成字符串修改，再把字符串解析成json对象

高级篇

数组

将数组转换为对象

const plants = ['Saturn', 'Earth', 'Uranus', 'Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter'];
const plantsObj = {...plants }
console.log(plantsObj); // {'0': 'Saturn','1': 'Earth', '2': 'Uranus','3': 'Mercury','4': 'Venus','5': 'Earth','6': 'Mars','7': 'Jupiter'}

js遍历数组以及获取数组对象的key和key的值方法

数组：arr:[
		{"aa":[{"num":"23"}]},
		{"bb":[{"num":"43"}]},
		{"cc":[{"num":"42"}]},
	]
arr.forEach((value,i)=>{ //数组循环
for(var pl in value){ //数组对象遍历
	console.log(pl); //获取key
	console.log(value[pl]) //获取key的值
	}
})

js数组对象检测是否有重复的值

比如说根据用户id判断

let arr = [
    {id:1,name:2,age:3},

	{id:2,name:3:age:24},

	{id:1,name:5,age:6}
]

const ids = arr.map(value=>value.id);

const idsSet = new Set(ids);

if(idsSet.size() == ids.length){

	console.log(“不存在同个值”)

}else{

	console.log(“存在同个值”)

}

对象

遍历对象的四种方式

方法一：

for … in 循环遍历对象自身的和继承的可枚举属性

(循环遍历对象自身的和继承的可枚举属性(不含Symbol属性))

let dog ={ dName:"coco", type:"阿拉斯加", age: "5岁", color: "棕红色" }

for (let i in dog){
    console.log(i, ":" dog[i])
}

dNmae:coco
type:阿拉斯加
age:5岁
color:棕红色

方法二：

使用Object.keys()遍历

(返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含Symbol属性).).

let dog ={ dName:"coco", type:"阿拉斯加", age: "5岁", color: "棕红色" }

Object.keys(dog).forEach(function(key){
    console.log(key, dog[key])
})

dNmae coco
type 阿拉斯加
age 5岁
color 棕红色

方法三：

Object.getOwnPropertyNames(obj)

返回一个数组,包含对象自身的所有属性(不含Symbol属性,但是包括不可枚举属性).

let dog ={ dName:"coco", type:"阿拉斯加", age: "5岁", color: "棕红色" }

Object.getOwnPropertyNames(dog).forEach(function(key){
    console.log(key, dog[key])
})

dNmae coco
type 阿拉斯加
age 5岁
color 棕红色

方法四：

Reflect.ownKeys(obj)遍历

返回一个数组,包含对象自身的所有属性,不管属性名是Symbol或字符串,也不管是否可枚举.

let dog ={ dName:"coco", type:"阿拉斯加", age: "5岁", color: "棕红色" }

Reflect.ownKeys(dog).forEach(function(key){
    console.log(key, dog[key])
})

dNmae coco
type 阿拉斯加
age 5岁
color 棕红色

修改对象key值，value值不变

const array = [{value:0, label:'a'},{value:1, label:'c'},{value:2, label:'vv'},{value:3, label:'b'},{value:4, label:'vc'}];

const result = array.map(item =>{
  return {
    value:`key${item.value}`,
    label:item.label
  }
})
console.log(result)

[ 
{value: 'key0', label: 'a'}
{value: 'key1', label: 'c'}
{value: 'key2', label: 'vv'}
{value: 'key3', label: 'b'}
{value: 'key4', label: 'vc'}
]

JavaScript 基础查阅手册

基础篇