知识点

一、语法和数据类型

1、函数提升

  • 函数声明会被提升到顶部。 ```javascript foo(); // “bar”

function foo() { console.log(“bar”); }

  2. - 函数表达式不会被提升
  3. ```javascript
  4. baz(); // 类型错误：baz 不是一个函数
  6. var baz = function() {
  7.   console.log("bar2");
  8. };

2、常量Const

  • 对象属性被赋值为常量的时候是不受保护的。

    1. const MY_OBJECT = {"key": "value"};
    2. MY_OBJECT.key = "otherValue";

  • 数组被定义成常量也是不受保护的。

    1. const MY_ARRAY = ['HTML','CSS'];
    2. MY_ARRAY.push('JAVASCRIPT');
    3. console.log(MY_ARRAY); //logs ['HTML','CSS','JAVASCRIPT'];（不报错）

    3、数据类型Symbol

  • ES6新增，实例是唯一且不可改变的。

    4、字符串转换成数字

  • parseInt() 和 parseFloat()

  • 使用一元加法运算符：

    1. "1.1" + "1.1" = "1.11.1"
    2. (+"1.1") + (+"1.1") = 2.2   
    3. // 注意：加入括号为清楚起见，不是必需的。
    4. // 第一个可以不加，后面的必须加。

    5、数组字面量

  • 数组里面多写的逗号（没赋值），则访问arr[n]初始值为undefined，但是打印arr时，那个位置的值是empty。

  • 如果是元素列表的末尾多加了逗号，将会被忽略

    6、对象字面量

  • 对象属性名字可以是任意字符串，包括空串。如果对象属性名字不是合法的javascript标识符，它必须用””包裹。属性的名字不合法，那么便不能用.访问属性值，而是通过类数组标记(“[]”)访问和赋值。

    1. var unusualPropertyNames = {
    2. "": "An empty string",
    3. "!": "Bang!"
    4. }
    5. console.log(unusualPropertyNames."");   // 语法错误: Unexpected string
    6. console.log(unusualPropertyNames[""]);  // An empty string
    7. console.log(unusualPropertyNames.!);    // 语法错误: Unexpected token !
    8. console.log(unusualPropertyNames["!"]); // Bang!

  • 注意

    1. var foo = {a: "alpha", 2: "two"};
    2. console.log(foo.a);    // alpha
    3. console.log(foo[2]);   // two
    4. //console.log(foo.2);  // SyntaxError: missing ) after argument list
    5. //console.log(foo[a]); // ReferenceError: a is not defined
    6. console.log(foo["a"]); // alpha
    7. console.log(foo["2"]); // two

    7、块级作用域

  • let 和 const 是块级作用域的，var 不是。

    1. var x = 1;
    2. {
    3. var x = 2;
    4. }
    5. alert(x); // 输出的结果为 2

    8、条件判断语句

  • 在条件表达式中使用赋值。通常在赋值语句前后额外加上一对括号：

    1. if ((x = y)) {
    2. /* statements here */
    3. }

  • 被当成错误的值：

false、undefined、null、0、NaN、空字符串（""）
当传递给条件语句所有其他的值，包括所有对象会被计算为真 。
不要混淆原始的布尔值true和false 与 Boolean对象的真和假：

  1. var b = new Boolean(false);
  2. if (b) //结果视为真
  3. if (b == true) // 结果视为假

9、异常处理语句

  • 用 throw 语句抛出一个异常并且用 try...catch 语句捕获处理它。 ```javascript function getRectArea(width, height) { if (isNaN(width) || isNaN(height)) { throw ‘Parameter is not a number!’; } }

try { getRectArea(3, ‘A’); } catch (e) { console.error(e); // expected output: “Parameter is not a number!” }

  1. <a name="CkGqy"></a>
  2. ### 二、循环与迭代
  3. <a name="EvQfD"></a>
  4. #### 1、label语句
  6. - 提供一个让你在程序中的其他位置引用它的标识符。可以与`continue`和`break`联合使用，继续循环或者停止循环。
  8. 未添加`label`，使用`break`跳出循环：
  9. ```javascript
  10. var num = 0;
  11. for (var i = 0 ; i < 10 ; i++) {   // i 循环
  12.   for (var j = 0 ; j < 10 ; j++) { // j 循环
  13.     if( i == 5 && j == 5 ) {
  14.        break; // i = 5，j = 5 时，会跳出 j 循环
  15.     } // 但 i 循环会继续执行，等于跳出之后又继续执行更多次 j 循环
  16.   num++;
  17.   }
  18. }
  19. alert(num); // 输出 95

添加label-break之后：

  1. var num = 0;
  2. outPoint:
  3. for (var i = 0 ; i < 10 ; i++){
  4.   for (var j = 0 ; j < 10 ; j++){
  5.     if( i == 5 && j == 5 ){
  6.       break outPoint; // 在 i = 5，j = 5 时，跳出所有循环，
  7.                       // 返回到整个 outPoint 下方，继续执行
  8.     }
  9.     num++;
  10.   }
  11. }
  12. alert(num); // 输出 55

使用continue语句，可达到与未添加label相同的效果。

  1. var num = 0;
  2. outPoint:
  3. for(var i = 0; i < 10; i++) {
  4.   for(var j = 0; j < 10; j++) {
  5.     if(i == 5 && j == 5) {
  6.       continue outPoint;
  7.     }
  8.     num++;
  9.   }
  10. }
  11. alert(num);  // 95

2、for-in和for-of

  • for-in 遍历的是key（键），不建议数组使用

  • for-of 遍历的是value（值）

    三、JS对象和原型链

    1、对象与原型链，_proto_和prototype

  • 原型对象：_proto_ 属性的值

每个对象一定对应一个原型对象，并从原型对象继承属性和方法。

  1. var one = {x: 1};
  2. var two = new Object();
  3. one.__proto__ === Object.prototype // true
  4. two.__proto__ === Object.prototype // true
  5. one.toString === one.__proto__.toString // true
  • prototype

只有函数才有prototype。当创建函数时，js会为这个函数自动添加prototype属性。
当把这个函数当作构造函数使用时，函数通过prototype来存储要共享的属性和方法，也可以设置prototype 指向现存的对象来继承该对象。

  • 对象的_proto_指向自己构造函数的prototype。obj.__proto__.__proto__...的原型链由此产生，包括我们的操作符instanceof正是通过探测obj.__proto__.__proto__... === Constructor.prototype来验证obj是否是Constructor的实例。
  • ES规范定义对象字面量的原型就是 Object.prototype。
  • JS是单继承的。Object.prototype是原型链的顶端，所有对象从它继承了包括toString等等方法和属性。
  • Object本身是构造函数，继承了Function.prototype;Function也是对象，继承了Object.prototype。 ```javascript Function本身就是函数，Function.proto是标准的内置对象Function.prototype。 Function.prototype.proto是标准的内置对象Object.prototype。 Object instanceof Function // true Function instanceof Object // true Function 继承 Function 本身，Function.prototype 继承 Object.prototype.

Function.prototype和Function.proto都指向Function.prototype，这就是鸡和蛋的问题怎么出现的。 Object.prototype.proto === null，说明原型链到Object.prototype终止。

  2. - 所有对象均从`Object.prototype`继承属性。
  4. ![原型.PNG](https://cdn.nlark.com/yuque/0/2020/png/1870059/1607866142250-f453ba4b-75a3-44c9-a596-1b9bc950534f.png#align=left&display=inline&height=335&margin=%5Bobject%20Object%5D&name=%E5%8E%9F%E5%9E%8B.PNG&originHeight=335&originWidth=617&size=22868&status=done&style=none&width=617)
  6. - **最后总结：先有`Object.prototype`（原型链顶端），`Function.prototype`继承`Object.prototype`而产生，最后，`Function`和`Object`和其它构造函数继承`Function.prototype`而产生。**
  10. <a name="jfmLD"></a>
  11. ## JS全局方法
  12. <a name="l9hWw"></a>
  13. ## 数组方法
  14. <a name="3k8YF"></a>
  15. ### 一、属性
  16. <a name="MyVVX"></a>
  17. #### 1、length
  18. 使用：arr.length
  19. <a name="O9vpe"></a>
  20. #### 2、constructor
  21. 返回对创建此对象的数组函数的引用。<br />`let arr1 = new Array() 或 let arr2 = new F`<br />当每一个函数（F、Array）被创建时，都会有一个 prototype 属性，prototype 有一个 constructor 属性，且constructor 指向函数的一个引用。<br />用于对对象类型进行判断，比如 
  22. ```javascript
  23. arr1.constructor === Array // true
  24. arr2.constructor === F.prototype.constructor // true

但是constructor易变，不可信赖（当函数被改写时，函数的 constructor 指向对象也会随之改变。解决方法是： F.prototype = {}），可用 instanceof 代替。

二、方法

1、concat()—合并数组。不变。

用于合并两个或多个数组，不会改变现有数组，而是返回一个新数组。
arr0.concat(arr1,arr2,arr3...)：arrx 可以是具体值，也可以是数组，也可混合使用。
数组直接赋值a1 = a0会导致更改 a0，a1 也会改变。如果用 a1 = a0.concat()就不会出现这类问题。

  • 浅拷贝 let newArr = arr.concat()

    2、join()—转成字符串。不变。

    arr.join(separator)：输出字符串。将 arr 中的每个元素转换成字符串，然后用分隔符（separator，如果为空，则默认逗号）连接起来。

    3、toString()—转成用逗号链接的字符串。不变。

    返回字符串。

    4、toLocaleString()—转换成字符串。不变。

    将数组转换成本地字符串。使用地区特定的分隔符把生成的字符串连接起来，形成一个字符串。
    时间（date）的 toLocalString() 和 toString() 不一样。

    5、valueOf()—返回原始值

    原始值和引用值（指针）对应。打印时间显示毫秒。

    6、pop()—删除最后一个元素并返回该元素。改变。

    如果数组为空，则不改变数组，并返回 undefined。

    7、shift()—删除数组第一个元素并返回该元素。改变。

    如果数组为空，则不改变数组，并返回 undefined。

    8、push()—末尾添加元素，返回新长度。改变。

    9、unshift()—开头添加元素（一个或多个），返回新长度。改变。

    10、reverse()—颠倒元素顺序。改变。

    直接将数组全部元素反转。

    11、slice()—返回选定元素。不改变。

    arr.slice(start,end)：返回一个新数组，包括从 start（必需，负数从尾部算起）到 end（可选，不包括该元素。如无值，则默认最后一个。可为负值，从尾部算起。）中的元素。

  • 浅拷贝 let arr2 = arr1.slice()。

    12、filter()—返回符合条件的数组。不变。

    array.filter(function(currentValue,index,arr), thisValue)

  • filter() 不会对空数组进行检测。

    13、every()—返回布尔值。不变。

    array.every(function(currentValue,index,arr), thisValue)
    检测数组所有元素是否都符合指定条件（通过函数提供）

  • 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。

  • 如果所有元素都满足条件，则返回 true。

    14、forEach()—返回undefined。改变。

    array.forEach(function(currentValue, index, arr), thisValue)
    用于调用数组的每个元素，并将元素传递给回调函数。

  • 对于空数组是不会执行回调函数的。

  • 不支持 continue。使用 return 会跳过当前元素return之后的函数，然后继续下一个元素。

  • 不支持 break，用 try catch/every/some 代替（跳出循环的方法）

    1. try {
    2.   var array = ["first","second","third","fourth"];        // 执行到第3次，结束循环
    3.   array.forEach(function(item,index){
    4.       if (item == "third") {
    5.           throw new Error("EndIterative");
    6.       }
    7.       alert(item);// first,sencond
    8.   }); 
    9. } catch(e) { 
    10.   if(e.message!="EndIterative") throw e; 
    11. };

    15、some()—返回布尔值。不变。实现与every()相反。

    array.some(function(currentValue,index,arr),thisValue)
    用于检测数组中的元素是否满足指定条件（函数提供）。

  • 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。

  • 如果没有满足条件的元素，则返回false。

  • 不会对空数组进行检测。

    16、map()—返回处理后的新数组。不变。

    array.map(function(currentValue,index,arr), thisValue)

  • 不会对空数组进行检测。

    17、splice()—删除或添加元素。改变。

    向/从数组中添加/删除项目，然后返回被删除的项目组成的数组，如果没有删除的，则返回空数组。
    arrayObject.splice(index,howmany,item1,.....,itemX)：
    index：必需，删除或添加项目的位置，负数表示从尾部算起。
    howmany：必须，删除的项目的数量，为0则不会删除。
    item1,…..itemX：可选，向数组添加的新项目。
    删除和添加可同时进行。

    18、sort()—排序。改变。

    arr.sort(function(a,b){})：sort方法会调用每个数组项的toString()方法，得到字符串，然后再对得到的字符串进行排序。
    函数：如果调用该方法时没有使用参数，将按按照字符编码的顺序对数组中的元素进行排序，
    返回值<0：a 排在 b 之前。
    返回值=0：a，b 元素位置不变。
    返回值>0：b 排在 a 之前。

    19、indexOf()—返回数组中指定元素第一次出现的位置。不变。

    array.indexOf(item,start)：item 必须，查找的元素。start 可选，起始位置。

    • 没找到元素返回 -1。
    • 不可查找 NaN。它内部使用严格相等运算符（===）进行判断，这会导致对NaN的误判。

      20、lastIndexOf()—返回指定元素的最后位置。不变。

      从后面向前查找。其余与indexOf 一样。

      21、Array.isArray(obj)—判断obj是否为数组。返回布尔值（是数组返回 true，否则返回 false。）。

      22、reduce()—返回计算结果。不变。

      array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
参数 描述
function(total,currentValue, index,arr) 必需。用于执行每个数组元素的函数。
函数参数:		 参数 描述
:—- :—-
total 必需。初始值, 或者计算结束后的返回值。
currentValue 必需。当前元素
currentIndex 可选。当前元素的索引
arr 可选。当前元素所属的数组对象。

| | initialValue | 可选。传递给函数的初始值 |

  • 对于空数组是不会执行回调函数的。 ```javascript var numbers = [65, 44, 12, 4];

function getSum(total, num) { return total + num; } function myFunction(item) { document.getElementById(“demo”).innerHTML = numbers.reduce(getSum); }

  1. <a name="deLQi"></a>
  2. ### ES6
  3. <a name="VZvMd"></a>
  4. #### 1、扩展运算符
  5. 复制数组 `...`：`const a2 = [...a1]`与`const a2 = a1.concat()`效果一样。<br />字符串转换成数组：`[...'hello'] //['h','e','l','l','o']`<br />将定义了遍历器接口的对象转换成真正的数组：
  6. ```javascript
  7. let nodeList = document.querySelectorAll('div');
  8. let arr = [...nodeList];

2、Array.from( 对象，处理函数)—将类似数组和可遍历对象转换成真正的数组，返回转换后形成的的数组。

参数为数组：

返回数组，空位转换成 undefined。

类似数组的对象：必须含有 length 属性，且元素属性名必须是数值或者可转换为数值的字符。

返回 length 长度的数组，
元素属性名不为数值且无法转换为数值，返回长度为 length 元素值为 undefined 的数组

  1. let arrayLike = {'0':'a','1':'b','2':'c',length:'3'}
  2. let arr2 = Array.from(arrayLike); // ['a','b,'c']

字符串：

Array.from('hello') // ['h','e','l','l','o']

处理函数：可选，返回处理后的函数

console.log(Array.from([1, 2, 3], (n) => n * 2)); // [2, 4, 6]

3、find()—返回符合条件的第一个元素。不变。

array.find(function(currentValue, index, arr),thisValue)：currentValue 必须，其他可选。

  1. let arr = Array.of(1, 2, 3, 4);
  2. console.log(arr.find(item => item > 2)); // 3
  4. // 数组空位处理为 undefined
  5. console.log([, 1].find(n => true)); // undefined
  • 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
  • 如果没有符合条件的元素返回 undefined。
  • 空数组不执行

  • 可查找NaN。[NaN].findIndex(y => Object.is(NaN, y))

    4、findIndex()—返回符合条件的第一个元素的索引。不变。

    除了返回符合条件的索引，且没找到时返回 -1 ，其他与 find() 一样。
    可查找NaN。

    5、fill()—返回改变后的数组。将一个固定值替换数组元素。改变。

    array.fill(value, start, end)：value 必须，是填充的值，其他可选。end 默认数组末尾（不包括end）。
    注意，如果填充的类型为对象，那么被赋值的是同一个内存地址的对象，而不是深拷贝对象。

  • 将空位视为正常的数组位置。

    凡是用了fill()填充之后的，再 arr[n].push(值) 就会数组里的每一个都push。但是 fill() 如果有起始位置（只要不是全部替换），就不会出现push时全部push进去。

    ```javascript let arr = new Array(3).fill({name: “Mike”}); arr[0].name = “Ben”; arr // [{name: “Ben”}, {name: “Ben”}, {name: “Ben”}]

let arr = new Array(3).fill([]); arr[0].push(5); arr // [[5], [5], [5]]

let arr0 = new Array(3).fill(0); console.log(arr0, “arr0”); // [ 0, 0, 0 ] arr0 console.log(arr0.push(1)); // 4 console.log(arr0); // [ 0, 0, 0, 1 ] let arr1 = [, , ,]; arr1.fill(0);
console.log(arr1, “arr1”); // [ 0, 0, 0 ] arr1 console.log(arr1.push(1)); // 4 console.log(arr1); // [ 0, 0, 0, 1 ]

  1. <a name="VJdeK"></a>
  2. #### 6、copyWithin()--返回改变后的数组，从指定位置拷贝元素到另一个指定位置中。改变。
  3. `array.copyWithin(target, start, end)`：<br />target 必须：从该位置开始替换数据。如果为负值，表示倒数。<br />start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。<br />end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。
  5. - 会连空位一起拷贝。
  6. <a name="O4YTs"></a>
  7. #### 7、entries()--遍历键值对。返回遍历器对象。不变。
  8. ```javascript
  9. // 用 for of 循环进行遍历
  10. for (let [index, elem] of ['a', 'b'].entries()) {
  11.   console.log(index, elem);
  12. }
  13. // 0 "a"
  14. // 1 "b"
  16. // 手动调用遍历器对象的next方法，进行遍历。
  17. let letter = ['a', 'b', 'c'];
  18. let entries = letter.entries();
  19. console.log(entries.next().value); // [0, 'a']
  20. console.log(entries.next().value); // [1, 'b']
  21. console.log(entries.next().value); // [2, 'c']

8、keys()—遍历键名。返回遍历器对象。不变。与 for…in 遍历的一样。

  • 获取可枚举属性的名称（数组为序列值，且包括原型链上的可枚举属性） ```javascript for (let index of [‘a’, ‘b’].keys()) { console.log(index); } // 0 // 1

// 也可使用 next()，方法与entries() 一样。 // for (let index in [‘a’, ‘b’]) { console.log(index); } // 0 // 1

  1. <a name="p8X27"></a>
  2. #### 9、values()--遍历键值。返回遍历器对象。不变。与 for...of 遍历的一样。
  3. ```javascript
  4. for (let elem of ['a', 'b'].values()) {
  5.   console.log(elem);
  6. }
  7. // 'a'
  8. // 'b'
  10. for (let index of ['a', 'b']) {
  11.   console.log(index);
  12. }
  13. // a
  14. // b

10、includes()—判断一个数组是否包含一个指定的值，如果是返回 true，否则false。ES7。不变。

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)
fromIndex：默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始。

可判断NaN。

11、flat()—嵌套数组转一维数组。返回被拍平的数组。改变。

arr.flat(n)：拍平n维数组。

  • 如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。

[1, [2, [3]]].flat(Infinity) // [1, 2, 3]

  • 如果原数组有空位，flat()方法会跳过空位。

[1, 2, , 4, 5].flat() // [1, 2, 4, 5]

12、flatMap(回调函数)—先对数组中每个元素进行处理，再将处理后的数组拍平。返回处理后的数组。改变。

  1. // 参数1：遍历函数，该遍历函数可接受3个参数：当前元素、当前元素索引、原数组
  2. // 参数2：指定遍历函数中 this 的指向
  3. console.log([1, 2, 3].flatMap(n => [n * 2])); // [2, 4, 6]
  5. // 只能拍平一层数组。
  6. // 相当于 [[[2]], [[4]], [[6]], [[8]]].flat()
  7. [1, 2, 3, 4].flatMap(x => [[x * 2]])
  8. // [[2], [4], [6], [8]]

数组的空位

  1. Array(3) // [, , ,]

  • 空位不是undefined，一个位置的值等于undefined，依然是有值的。空位是没有任何值，in运算符可以说明这一点。

    1. 0 in [undefined, undefined, undefined] // true
    2. 0 in [, , ,] // false

  • forEach(), filter(), reduce(), every() 和some()都会跳过空位。

  • map()会跳过空位，但会保留这个值

  • join()和toString()会将空位视为undefined，而undefined和null会被处理成空字符串。

    ES6 则是明确将空位转为undefined。

  • for...of循环也会遍历空位。

    字符串方法

    一、属性

    1、constructor

    2、length

    二、方法

    //查找

    1、charAt(index)—返回指定位置的一个字符。

    2、charCodeAt(index)—返回指定位置（一个）的字符的 Unicode 编码。

    3、indexOf(searchvalue,start)—返回某个指定的字符串值在字符串中首次出现的位置。

  • 如果没有找到匹配的字符串则返回 -1。

  • 区分大小写。

  • searchvalue 必需，需检索的字符串或正则表达式。start 可选，合法取值是 0 到 string Object.length - 1。如省略该参数，则将从字符串的首字符开始检索。

    4、lastIndexOf(searchvalue,start)—返回一个指定的字符串值最后出现的位置。

  • 查找的字符串最后出现的位置，如果没有找到匹配字符串则返回 -1。

  • searchvalue 必需。规定需检索的字符串值或正则表达式。
  • 如果指定第二个参数 start，则在一个字符串中的指定位置从后向前搜索。
  • 开始检索的位置在字符串的 start 处或字符串的结尾（没有指定 start 时）。

  • 区分大小写。

    5、includes(searchvalue, start)—找到匹配的字符串则返回 true，否则返回 false。ES6。

  • 区分大小写。

  • searchvalue 必需，要查找的字符串。start 可选，设置从那个位置开始查找，默认为 0。

    6、match(regexp)—未找到返回null，找到返回由满足条件的元素组成的数组。

    如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。

    7、search(searchvalue)—返回查找到的字符串或者满足正则表达式相匹配的位置。未找到返回-1。

    8、startsWith(searchvalue, start)—返回布尔值。查看第start个位置是否以searchvalue开头。ES6

  • searchvalue 必需，要查找的字符串。

  • start 可选，查找的开始位置，默认为 0。

  • 大小写敏感。

    9、endsWith(searchvalue, end)—返回布尔值。查看前end个位置是否以searchvalue结尾。ES6

  • searchvalue 必需，要查找的字符串。

  • end 可选，查找的结束位置(不包括第end个位置)，默认全部字符串。

  • 大小写敏感。

    9、valueOf()—返回原始值。

    // 连接

    1、string.concat(string1, string2, …, stringX)—连接字符串，返回新字符串。不变。

    // 改变字符串

    1、string.fromCharCode()—将 Unicode 编码转为一个字符.返回一个字符串。

    2、str.repeat(次数)—返回复制指定次数并连接在一起的新字符串。ES6。

  • 小数，会向下取整。

  • 负数或者Infinity，会报错。
  • 0 至 -1 之间的小数取整得到 -0 ，
  • NaN，等同于 repeat 零次。

  • 如果传入的参数是字符串，则会先将字符串转化为数字。

    3、str.replace(searchvalue,newvalue)—将searchvalue替换成newvalue。返回一个新的字符串。不变。

  • searchvalue 必须。子字符串（直接量文本模式）或要替换的模式的 RegExp 对象。

  • 当 searchvalue 为字符串时，区分大小写，只替换第一个找到的.
  • 当 searchvalue 为 RegExp 对象时，加上全局（/g）就可以全部替换，否则也只替换第一个。

  • newvalue 必须。

    4、str.replaceAll(searchvalue,_replacement)—将_searchvalue替换成newvalue。返回一个新的字符串。不变。

  • searchValue可以是一个字符串，也可以是一个全局的正则表达式（带有g修饰符，不带会报错）。

  • replacement除了为字符串，也可以是一个函数，该函数的返回值将替换掉第一个参数searchValue匹配的文本。 ```javascript const str = ‘123abc456’; const regex = /(\d+)([a-z]+)(\d+)/g;

function replacer(match, p1, p2, p3, offset, string) { return [p1, p2, p3].join(‘ - ‘); }

str.replaceAll(regex, replacer) // 123 - abc - 456

  2. - 第一个参数是捕捉到的匹配内容，第二个参数捕捉到是组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置，最后一个参数是原字符串。
  3. <a name="7qLYb"></a>
  4. #### 5、str.trim()--返回去掉头尾空格的字符串。不变。
  6. - 空白符包括：空格、制表符 tab、换行符等其他空白符等。
  7. - 不适用于 null, undefined, Number 类型。（`'1234'`可以）
  8. <a name="AnE2M"></a>
  9. #### 6、str.trimStart()--返回去掉头部空格的字符串。不变。
  11. - 其余与 trim() 一样。
  12. <a name="NjRKf"></a>
  13. #### 7、str.trimEnd()--返回去掉尾部空格的字符串。不变。
  15. - 其余与 trim() 一样
  16. <a name="wjcqe"></a>
  17. #### 8、str.padStart(num,string)--头部补全。返回新字符串。不变。
  19. - num：指定生成的字符串的最小长度。
  20. - string：用来补全的字符串。如果没有指定第二个参数，默认用空格填充。
  21. - 如果指定的长度小于或者等于原字符串的长度，则返回原字符串。
  22. - 原字符串加上补全字符串长度大于指定长度，则截去超出位数的补全字符串。
  23. <a name="TNkIb"></a>
  24. #### 9、str.padEnd(num,string)--尾部补全。返回新字符串。不变。
  26. - num：指定生成的字符串的最小长度。
  27. - string：用来补全的字符串。如果没有指定第二个参数，默认用空格填充。
  28. - 如果指定的长度小于或者等于原字符串的长度，则返回原字符串。
  29. - 原字符串加上补全字符串长度大于指定长度，则截去超出位数的补全字符串。
  30. <a name="3cqef"></a>
  31. ### // 提取
  32. <a name="nRFYg"></a>
  33. #### 1、slice(_start_,_end_)--以新字符串的形式返回被提取的部分。
  35. - start    必须. 要抽取的片断的起始下标。第一个字符位置为 0。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。
  36. - end 可选。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。
  37. - 截取的数字不包括第end位。
  38. <a name="eOhLg"></a>
  39. #### 2、str.split(_separator_,_limit_)--不变。返回一个字符串组成的新数组。
  41. - 参数皆可选。_separator：_字符串或正则表达式，从str的具有这个分割符的地方开始切割。
  43. _limit：_可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。
  45. - 空字符串 ("") 用作 separator，那么 str 中的每个字符之间都会被分割。
  46. - 不会返回 separator 本身。即str中用作切割的不会返回。
  47. ```javascript
  48. // 空格（引号之间没空格）切割每个字符
  49. let str1 = 'hello cat ~';
  50. console.log(str1.split(''));
  51. // 输出：[
  52.   'h', 'e', 'l', 'l',
  53.   'o', ' ', 'c', 'a',
  54.   't', ' ', '~'
  55. ]
  57. // 用空格（字符串本身有）分割
  58. let str1 = 'hello cat ~';
  59. console.log(str1.split(' '));
  60. // 返回： [ 'hello', 'cat', '~' ]

3、str.substr(start,length)—返回从start位置开始length长度的字符串。

  • start 必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。

  • length 可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。

    4、str.substring(from, to)—返回从from处（包括）到 to（不包括）位置的字符。

  • from 必需。一个非负的整数，规定要提取的子串的第一个字符在 string Object 中的位置。

  • to 可选。一个非负的整数，比要提取的子串的最后一个字符在 string Object 中的位置多 1。如果省略该参数，那么返回的子串会一直到字符串的结尾。

    // 转换

    1、str.toLowerCase()—将字符串转换成小写。不变。返回改变后的新字符。

    2、str.toUpperCase()—将字符串转换成大写。不变。返回改变后的新字符。

    3、str.toLocaleLowerCase()—根据本地主机的语言环境把字符串转换为小写。不变。返回改变后的新字符串。

    4、str.toLocaleLowerCase()—根据本地主机的语言环境把字符串转换为大写。不变。返回改变后的新字符串。

    5、str.toString()—返回一个表示 String 对象的值。


    数字方法

    一、属性

    1、constructor—返回对创建此对象的Number函数的引用。

    2、Number.MAX_VALUE—返回js中的最大数。

  • 是js的静态方法，使用自己创建的 x Number 对象(x.MAX_VALUE)将无法获取 。返回 undefined。

  • 近似值为 1.7976931348623157 x 10。

  • 大于MAX_VALUE的数表示无穷大。

    3、Number.MIN_VALUE—返回 Javascript 的最小数。

  • 近似值： 5 x 10。

  • 比 MIN_VALUE 属性小的数将用 0 表示。
  • 其余与 Number.MAX_VALUE 一样。

  • 负值属性为 MAX_NUMBER。

    4、Number.NEGATIVE_INFINITY—返回负无穷大。溢出时返回该值。

  • 表示小于 Number.MIN_VALUE 的值。

  • 返回值：-Infinity。溢出时也会返回这个。

    5、Number.POSITIVE_INFINITY—返回正无穷大。溢出时返回该值。

  • Infinity

  • 其余与上面几个一样。

    6、Number.NaN—返回NaN。

    7、Number.EPSILON—返回1 和比最接近 1 且大于 1 的最小 Number 之间的差别的数字.ES6

  • 值为2.220446049250313e-16。

    8、Number.MIN_SAFE_INTEGER—返回最小的安全的 integer 型数字.ES6

  • -(2 - 1)

    9、Number.MAX_SAFE_INTEGER—返回最大的安全整数。ES6

  • (2```` - 1)

    二、方法

    1、Number.isFinite(value)—返回布尔值。检测value是否为有限值（是返回true）。ES6

  • 如果 value 是 NaN（非数字），或者是正、负无穷大的数，则返回 false。

  • 不会将检测值转换为 Number对象，如果检测值不是 Number 类型，则返回 false。

  • 全局的 isFinite() 会先把检测值转换为 Number ，然后再检测。

    1. Number.isFinite(123) //true
    2. Number.isFinite(-1.23) //true
    3. Number.isFinite(5-2) //true
    4. Number.isFinite(0) //true
    5. Number.isFinite('123') //false
    6. Number.isFinite('Hello') //false
    7. Number.isFinite('2005/12/12') //false
    8. Number.isFinite(Infinity) //false
    9. Number.isFinite(-Infinity) //false
    10. Number.isFinite(0 / 0) //false

    2、num.isNaN()—返回布尔值。ES6。

  • 用来检查一个值是否为NaN。

  • 只对数值有效。

    1. Number.isNaN(NaN) // true
    2. Number.isNaN(15) // false
    3. Number.isNaN('15') // false
    4. Number.isNaN(true) // false
    5. Number.isNaN(9/NaN) // true
    6. Number.isNaN('true' / 0) // true
    7. Number.isNaN('true' / 'true') // true

    2、num.toExponential(x)—返回指针记法的字符串。

  • x：可选。规定指数计数法中的小数位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。如果省略了该参数，将使用尽可能多的数字。

    3、num.toFixed(x)—返回有x位小数的数字型字符串。

  • 四舍五入。

  • x：如果省略了该参数，将用 0 代替。规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。

    4、num.toPrecision(x)—返回指定长度x的数字型字符串。

  • x:可选。规定要转换为几位数，该参数是 1 ~ 100 之间（且包括 1 和 100 ）的值。如果省略了该参数，则调用方法 toString()，返回原始数字的字符串形式。如果 precison 参数不在 1 和 100 （包括）之间，将会抛出一个 RangeError 。

    5、 number.toString(radix)—将数字转换成radix进制的字符串

  • radix：可选。规定表示数字的基数，是 2 ~ 36 之间的整数。若省略该参数，则使用基数 10。但是要注意，如果该参数是 10 以外的其他值，则 ECMAScript 标准允许实现返回任意值。

    6、num.valueOf()—返回数字的原始值，number类型。

    7、Number.parseInt()，Number.parseFloat()

    1. Number.parseInt === parseInt // true
    2. Number.parseFloat === parseFloat // true

    8、Number.isInteger()—判断数值是否为整数。返回布尔值。

  • 如果不是数值（包括'134'），会返回false。

  • 25和25.0会被视为同一个值，都返回true。

  • 有精度限制。

    对象方法

    一、属性

    1、Object.length—值为1

    2、Object.prototype—为所有Object类型的对象添加属性。

    二、方法

    1、Object.assign(target,source1,source2…)—复制对象。将源对象分配到目标对象，返回目标对象，目标对象改变。

  • 对象里的键如果相同，后面的会覆盖前面的。

  • 如果只有一个参数，会直接返回该参数。
  • 如果该参数不是对象，会先转成对象typeof Object.assign(2) // "object"(但打印出来还是2)
  • 由于undefined和null无法转成对象，所以它们作为首参数，会报错。
  • 如果非对象参数出现在源对象的位置（即非首参数），那么处理规则有所不同。首先，这些参数都会转成对象，如果无法转成对象，就会跳过。这意味着，如果undefined和null不在首参数，就不会报错。
  • 其他类型的值（即数值、字符串和布尔值）不在首参数，也不会报错。但是，除了字符串会以数组形式，拷贝入目标对象，其他值都不会产生效果。 ```javascript const v1 = ‘abc’; const v2 = true; const v3 = 10;

const obj = Object.assign({}, v1, v2, v3); console.log(obj); // { “0”: “a”, “1”: “b”, “2”: “c” }

  2. - 拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（`enumerable: false`）。
  3. ```javascript
  4. const obj = Object.create({foo: 1}, { // foo 是个继承属性。
  5.     bar: {
  6.         value: 2  // bar 是个不可枚举属性。
  7.     },
  8.     baz: {
  9.         value: 3,
  10.         enumerable: true  // baz 是个自身可枚举属性。
  11.     }
  12. });
  14. const copy = Object.assign({}, obj);
  15. console.log(copy); // { baz: 3 }
  • 浅拷贝，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
  • 异常会打断后续拷贝任务 ```javascript const target = Object.defineProperty({}, “foo”, { value: 1, writable: false }); // target 的 foo 属性是个只读属性。

Object.assign(target, {bar: 2}, {foo2: 3, foo: 3, foo3: 3}, {baz: 4}); // TypeError: “foo” is read-only // 注意这个异常是在拷贝第二个源对象的第二个属性时发生的。

console.log(target.bar); // 2，说明第一个源对象拷贝成功了。 console.log(target.foo2); // 3，说明第二个源对象的第一个属性也拷贝成功了。 console.log(target.foo); // 1，只读属性不能被覆盖，所以第二个源对象的第二个属性拷贝失败了。 console.log(target.foo3); // undefined，异常之后 assign 方法就退出了，第三个属性是不会被拷贝到的。 console.log(target.baz); // undefined，第三个源对象更是不会被拷贝到的。

  5. <a name="RMnKw"></a>
  6. #### 2、delete
  8. - 可删除对象里的某个属性
  10. `delete Object.property`
  11. <a name="Ct1bF"></a>
  12. #### 3、Object.create(prototype,**propertiesObject**)--创建一个基于原型的新对象
  14. - 第一个参数必须，是新建对象的原型对象。
  16. 就是`_proto_`里面的值，是在`_proto_`原型上去添加。<br />调用原型上的方法：直接 `newObj.方法名()`
  18. - 第二个参数可选，是新创建的实例对象上的属性。
  20. 就跟普通对象添加键值对一样。
  22. - 与`new`的区别。
  24. `new`创建的`_proto_`指向构造函数的`prototype`
  25. ```javascript
  26. function aa(){}
  27. aa.prototype = {
  28.   a_fn: function(){
  29.       this.aa = 'aa的prototype值'
  30.   }
  31. }
  32. console.log(new aa())

结果：new创建的新对象.PNG

  • 创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。 ``javascript const person = { isHuman: false, printIntroduction: function() { console.log(My name is ${this.name}. Am I human? ${this.isHuman}`); } };

const me = Object.create(person);

me.name = ‘Matthew’; // “name” is a property set on “me”, but not on “person” me.isHuman = true; // inherited properties can be overwritten

me.printIntroduction(); // expected output: “My name is Matthew. Am I human? true”

  2. - **propertiesObject**是一个对象，它的自身的可枚举属性可添加至新对象。
  3. - 如果`propertiesObject`参数是 [`null`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/null) 或非原始包装对象，则抛出一个 [`TypeError`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/TypeError) 异常。
  4. <a name="ZiqJT"></a>
  5. #### 3、Object.defineProperties(obj, props)--obj对象上定义新的属性或修改现有属性，并返回该对象。改变。
  7. - obj：会被修改的对象。
  8. - props：一个对象，要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符主要有两种：
  9.    - configurable：`true`，只有该属性描述符的类型可以被改变并且该属性可以从对应对象中删除。
  11. 默认为 `false`。
  13.    - enumerable：`true`只有在枚举相应对象上的属性时该属性显现。默认`false`。
  14.    - value：与属性关联的值，可以是任何有效`JS`值。默认`undefined`。
  15.    - writable：只有与该属性相关联的值可被赋值改变时为`true`，默认false。为false时不能改变对象的属性值。
  16.    - get：函数返回的值将会被用作属性的值，默认`undefined`。当访问该属性时，会调用此函数。
  17.    - set：函数仅接收属性的新值作为参数。当属性被修改时，会调用此函数，会传入赋值时的this对象。
  18. - <br />
  19. ```javascript
  20. var obj = {};
  21. Object.defineProperties(obj, {
  22.   'property1': {
  23.     value: true,
  24.     writable: true
  25.   },
  26.   'property2': {
  27.     value: 'Hello',
  28.     writable: false
  29.   }
  30.   // etc. etc.
  31. });

4、Object.defineProperty((obj, prop, descriptor))—会直接在一个对象上定义一个新属性或者修改现有属性，返回此对象。改变。

  • 应该在Object上直接调用此方法。
  • 默认情况下（configurable为false），使用该方法添加的属性值是不可修改的。 ```javascript const object1 = {};

Object.defineProperty(object1, ‘property1’, { value: 42, writable: false // 为true则可以改变值 });

object1.property1 = 77; // throws an error in strict mode

console.log(object1.property1); // expected output: 42

var o = {};

o.a = 1; // 等同于： Object.defineProperty(o, “a”, { value: 1, writable: true, configurable: true, enumerable: true });

  1. <a name="Nt0rS"></a>
  2. #### 5、Object.entries(obj)--返回对象自身可枚举属性的键值对数组。不变。
  4. - 排列与`for...in`循环遍历该对象时返回顺序一致，但`for...in`还会枚举原型链中的可枚举属性。
  5. - 返回值是一个数组，然后数组里面的每一个数组都是一个键值对。且是字符串
  6. - 可以将`object`转换成`Map`
  7. ```javascript
  8. var obj = { foo: "bar", baz: 42 };
  9. var map = new Map(Object.entries(obj));
  10. console.log(map); // Map { foo: "bar", baz: 42 }

6、Object.freeze()—冻结一个对象，返回的对象与传入的对象参数相同。改变。

  • 被冻结的对象不能再修改，包括添加新属性，删除已有属性。修改对象已有属性的可枚举性，可配置性，可写性、value。冻结对象的原型也不能修改。
  • 如果一个属性的值是个对象，则这个对象中的属性是可以修改的，除非也是个冻结对象。（浅冻结）
  • 字符串，数字和布尔总是不可变的，而函数和数组是对象。要使对象不可变，需要递归冻结每个类型为对象的属性（深冻结）
  • 用Object.seal()密封的对象可改变它们现有的属性，而使用Object.freeze()冻结的对象中现有属性是不可变的。

  • 深冻结函数： ```javascript function deepFreeze(obj) {

    // 取回定义在obj上的属性名 var propNames = Object.getOwnPropertyNames(obj);

    // 在冻结自身之前冻结属性 propNames.forEach(function(name) { var prop = obj[name];

    // 如果prop是个对象，冻结它 if (typeof prop == ‘object’ && prop !== null)

    1. deepFreeze(prop);

    });

    // 冻结自身(no-op if already frozen) return Object.freeze(obj); }

obj2 = { internal: {} };

deepFreeze(obj2); obj2.internal.a = ‘anotherValue’; obj2.internal.a; // undefined

  1. <a name="ETeVs"></a>
  2. #### 7、Object.fromEntries(iterable)--将键值对列表转换成一个对象，返回一个新对象。
  4. - `iterable`，类似Array、Map或其它可迭代对象。
  5. - 即是与`Object.entries()`互逆的操作。
  6. ```javascript
  7. const entries = new Map([
  8.   ['foo', 'bar'],
  9.   ['baz', 42]
  10. ]);
  12. const obj = Object.fromEntries(entries);
  14. console.log(obj);
  15. // expected output: Object { foo: "bar", baz: 42 }
  • 对对象的值进行处理： ```javascript const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries( Object.entries(object1) .map(([ key, val ]) => [ key, val * 2 ]) );

console.log(object2); // { a: 2, b: 4, c: 6 }

  1. <a name="hNI9Y"></a>
  2. #### 8、Object.getOwnPropertyDescriptor(obj,属性名)--返回对象的一个自有属性对应的属性描述符。
  3. ```javascript
  4. const object1 = {
  5.   property1: 42
  6. };
  8. const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');
  10. console.log(descriptor1.configurable);
  11. // expected output: true
  13. console.log(descriptor1.value);
  14. // expected output: 42

9、Object.getOwnPropertyDescriptors(obj)—获取对象的所有属性描述符。

  • 如果没有任何自身属性，则返回空对象。

  • 返回一个对象，对象里面以键值对的形式，值是一个对象，包含此属性的所有属性描述符。

    10、Object.getOwnPropertyNames(obj)—返回由指定对象所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。

  • 返回的数组中枚举属性与通过for...in循环（或Object.keys）迭代该对象属性时一致。不可枚举属性的顺序未定义。

  • 对于数组和类数组对象会返回由他们的序列号字符串组成的数组。
  • 该方法不会获取到原型链上的属性。
  • ES5中，如果参数不是一个原始对象参数，将抛出TypeError异常；在ES6中，非对象参数会被转换成对象。

    11、Object.getOwnPropertySymbols(obj)—返回给定对象自身的所有Symbol属性的数组。

  1. var obj = {};
  2. var a = Symbol("a");
  3. var b = Symbol.for("b");
  5. obj[a] = "localSymbol";
  6. obj[b] = "globalSymbol";
  8. var objectSymbols = Object.getOwnPropertySymbols(obj);
  10. console.log(objectSymbols.length); // 2
  11. console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
  12. console.log(objectSymbols[0])      // Symbol(a)

12、Object.getPrototypeOf(obj)—返回指定对象的原型。

  • 如果对象没有继承属性，则返回null。

  • ES6中，如果参数不是一个对象，则会被强制转换成对象。

    13、Object.is(val1,val2)—判断两个值是否是一个值，返回布尔值。

  • 与==不同，==会对两边的变量的类型进行强制转换，且将-0和+0视为相等，将NaN与NaN视为不等。而Object.is不会。

  • 与===也不同，将-0和+0视为相等，将NaN与NaN视为不等。
  • 满足以下条件则两个值相等：
    • 都是 undefined
    • 都是 null
    • 都是 true 或 false
    • 都是相同长度的字符串且相同字符按相同顺序排列
    • 都是相同对象（意味着每个对象有同一个引用，[]和[]为false）
    • 都是数字且
      • 都是 +0
      • 都是 -0
      • 都是 [NaN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/NaN)，或者0/0（0/0与NaN为true）
      • 或都是非零而且非 NaN 且为同一个值

  • 特例：

    1. Object.is(0, -0);            // false
    2. Object.is(+0,-0);                         // false
    3. Object.is(0, +0);            // true
    4. Object.is(-0, -0);           // true
    5. Object.is(NaN, 0/0);         // true

    14、Object.isExtensible()—判断一个对象是否可以在上面添加新的属性。返回布尔值。

  • 默认情况下，对象是可扩展的，以及它们的_proto属性可被更改。

    15、Object.isFrozen(obj)—判断一个对象是否被冻结。返回布尔值。

  • 被冻结的对象：

    • 不可扩展：Object.isExtensible(frozen) //=== false。
    • 所有属性不可配置。
    • 所有数据属性不可写（没有getter或setter）
    • 是一个密封对象：Object.isSealed(frozen) //=== true。
    • 当对象的属性为存取描述符时，不考虑可写或不可写，只考虑是否可配置。

  • 冻结一个对象最方便的方法：

    1. var frozen = { 1: 81 };
    2. Object.isFrozen(frozen) //=== false
    3. Object.freeze(frozen);
    4. Object.isFrozen(frozen) //=== true

  • 一个对象（包括空对象）默认可扩展，即非冻结（false）。

    1. var oneProp = { p: 42 };
    2. Object.isFrozen(oneProp) //=== false

  • 不可扩展的空对象同时也是一个冻结对象：

    1. var vacuouslyFrozen = Object.preventExtensions({});
    2. Object.isFrozen(vacuouslyFrozen) //=== true;

  • 不可扩展的非空对象不是冻结对象，因为属性仍是可配置且可写的。

    1. Object.preventExtensions(oneProp);
    2. Object.isFrozen(oneProp) //=== false

  • 如果此时，删除了它的属性，则它会变成一个冻结对象：

    1. delete oneProp.p;
    2. Object.isFrozen(oneProp) //=== true

  • 当一个不可扩展的对象的可配置（configurable）和可写（writable）同时为false时，为冻结对象，否则任何一个为true都为非冻结。

  • 一个不可扩展的对象，拥有一个访问器属性（存取描述符），当可配置（configurable）为false时，为冻结对象。

  • ES5中，如果参数不是一个对象类型，将抛出异常。ES6中，非对象类型将被视为一个普通的冻结对象，返回true。

    16、Object.isSealed(obj)—判断一个对象是否密封。返回布尔值。

  • 密封对象指：

    • 不可扩展。
    • 所有自身属性皆不可配且因此不可删除。
    • 不一定是不可写
  • 新建的对象默认是不密封。
  • 不可扩展的空对象是密封对象。仅仅不可扩展的非空对象不是密封对象。
  • 不可扩展且不可配置的非空对象是密封对象。
  • 当密封对象的属性为数据描述符时，如果为可写的，则是非冻结对象，否则为冻结对象。

  • ES5如果此方法的参不是一个对象，会抛出错误。ES6会返回true。

    17、Object.keys(obj)-返回对象自身可枚举属性组成的数组。

  • 返回一个元素为字符串，对象的属性名组成的数组。

  • 顺序与手动遍历该对象属性时一致。 ```javascript // simple array var arr = [‘a’, ‘b’, ‘c’]; console.log(Object.keys(arr)); // console: [‘0’, ‘1’, ‘2’]

// array like object var obj = { 0: ‘a’, 1: ‘b’, 2: ‘c’ }; console.log(Object.keys(obj)); // console: [‘0’, ‘1’, ‘2’]

// array like object with random key ordering var anObj = { 100: ‘a’, 2: ‘b’, 7: ‘c’ }; console.log(Object.keys(anObj)); // console: [‘2’, ‘7’, ‘100’]

// getFoo is a property which isn’t enumerable var myObj = Object.create({}, { getFoo: { value: function () { return this.foo; } } }); myObj.foo = 1; console.log(Object.keys(myObj)); // console: [‘foo’]

  2. - ES5中此方法的参数不是对象会抛出错误，ES6则会将之转换成对象：
  3. ```javascript
  4. Object.keys("foo");
  5. // TypeError: "foo" is not an object (ES5 code)
  7. Object.keys("foo");
  8. // ["0", "1", "2"]                   (ES2015 code)

18、Object.preventExtensions(obj)—让一个对象变得不可扩展，返回不可扩展的对象。改变。

  • 不可扩展的对象：自身不能添加新的属性，其原型能添加新的属性。
  • 不可扩展的对象的属性仍能被删除。
  • 一旦对象变为不可扩展，就再也不能使其可扩展。

  • 在ES5中，如果参数不是一个对象类型，将抛出异常，ES6中，非对象参数将被视为一个不可扩展的普通对象，直接被返回。

    19、Object.prototype.hasOwnProperty()—检测对象中是否有指定的键，返回布尔值。

  • 参数是String，或者Symbol。

  • 会忽略掉那些从原型链上继承到的属性。
  • 只要属性存在，即使是null或者undefined，依旧会返回true。

  • 如果对象有一个键名是hasOwnProperty时，可以使用以下方法：

    • 直接使用原型链上真正的hasOwnProperty方法：

      1. var foo = {
      2. hasOwnProperty: function() {
      3. return false;
      4. },
      5. bar: 'Here be dragons'
      6. };
      7. ({}).hasOwnProperty.call(foo, 'bar'); // true

    • 使用Object原型上的hasOwnProperty属性：

      1. Object.prototype.hasOwnProperty.call(foo, 'bar'); // true

      20、Object.prototype.isPrototypeOf(obj)—测试一个对象是否在于另一个对象的原型链上。

  • object instanceof AFunction，object的原型链是针对AFunction.prototype进行检查的，而非AFunction本身。

  • obj的原型链上是否有Object。

三、属性描述符

  • 就是对象属性的可设置的值。
  • 包括两种：数据描述符和存取描述符。一个描述符只能是这两者之一。
    • 数据描述符：具有值的属性，可写可不写。
    • 存取描述符：由getter和setter函数所描述的属性。
  • 一个描述符如果不具有 value、writable、get 和 set 中的任意一个键，那么它将被认为是一个数据描述符。
  • 如果一个描述符同时拥有 value 或 writable 和 get 或 set 键，则会产生一个异常。
  • 下面这些键值不一定是自身属性，也要考虑继承来的属性。为了确认保留这些默认值，在设置之前，可能要冻结Object.prototype，明确指定所有选项，或者通过Object.creat(null)将_proto__指向null。
  • 使用点运算符时，布尔值默认为true

两种描述符都是对象，共享以下键值：

1、configurable

  • 默认false，（除了 writable和value，属性的其它都不可以配置修改，也不能delete，configurable重置为true也会报错，哪怕相同的赋值也会报错），当该属性的这个键值为true时，该属性的描述符才能被改变），同时该属性也能从对应的对象上被删除。

    2、enumerable

  • 默认false，仅当属性的这个键值为true时，该属性才会出现在对象的枚举属性中。

  • 决定了对象的属性是否可以在for...in循环和Object.keys()中被枚举。只有enumerable值为true才能被遍历出来。
  • 如果使用直接赋值的方式创建对象：o.d = 4，那么enumerable为true。
  • 当此值为false时，读取为undefined：o.b // undefined

数据描述符具有以下键值：

1、value

  • 默认undefined，为该属性对应的值，可以是任何有效的JS值

    2、writable

  • 默认false，仅当该属性的此值为true时，value才能被赋值运算符改变。

存取描述符具有以下键值：

1、get

  • 默认undefined。当访问属性时，会调用此函数。执行时不传入任何参数，但会传入this对象（由于继承关系，这里的this并不一定是定义该属性的对象）。该函数的返回值会被用作属性的值。 ```javascript // 在对象中添加一个设置了存取描述符属性的示例 var bValue = 38; Object.defineProperty(o, “b”, { // 使用了方法名称缩写（ES2015 特性） // 下面两个缩写等价于： // get : function() { return bValue; }, // set : function(newValue) { bValue = newValue; }, get() { return bValue; }, set(newValue) { bValue = newValue; }, enumerable : true, configurable : true });

o.b; // 38 // 对象 o 拥有了属性 b，值为 38 // 现在，除非重新定义 o.b，o.b 的值总是与 bValue 相同 ```

2、set

  • 默认undefined，当属性值被修改时，会调用此函数。该方法接受一个参数（被赋予的新值），传入赋值时的this对象。

你好呀，你是谁你是谁，你好呀，你是谁呀，欢迎光临

JS全局

全局属性

1、Infinity—代表正的无穷大的数值

  • 在Javascript中，超出 1.7976931348623157E+103088 的数值即为Infinity，小于 -1.7976931348623157E+103088 的数值为无穷小。
  • 超出最大范围的数字就会显示成 Infinity。

    2、