文章详细介绍了JavaScript中的数据类型，包括字符串(String)的特性、方法，数组(Array)的操作，如非破坏性和破坏性方法，以及Number类型的属性和方法，如Math对象的数学运算。还涵盖了Object对象的属性和方法，如原型链、数据描述符，以及Date和JSON的相关知识。
主要用于记录ES6新增的数据类型方法，还有一些原生的，包含String、Number、Array、Object、Date、Map/Set、定时器、JSON、Math
1.1 string类型
字符串定义：字符串是由数字、字母、下划线组成的一串字符。它是编程语言中表示文本的数据类型，在程序设计中，字符串为符号或数值的一个连续序列。
字符串与数组的区别：字符串是静态类型，存在栈当中，不可变，只能查看，不能增删改。
属性（property）
- length 用于表示一个字符串的字符个数
代码解析： pos是position的简写形式，表示定位下标pos:number表示pos的书写格式为number类型，string表示返回值是字符型。searchString：表示待查找字符串- | 表示或者
- [ ？ 都表示可有可无
-
string.prototype.startsWith(searchString, position)
作用：判断是否以目标字符串开头。
给定参数：- searchString：要检查的目标字符串。
- position（可选）：给定下标，指定从哪个位置开始检查，默认为
0。
-
string.prototype.endsWith(searchString, length)
作用：判断是否以目标字符串结尾。
给定参数：- searchString：要检查的目标字符串。
- length（可选）：指定字符串的有效长度。默认是 str.length。
-
string.protoype.charAt(pos:number)
作用：根据下标位置返回所在字符；
返回值：如果下标超出左右范围，则输出一个空字符串，也就是“”
给定参数：下标为空字符串或false表示0，true表示1 -
string.protoype.indexOf(searchString, position?)
作用：根据给出下标位置（从左往右）开始搜寻待查找字符串，返回该字符串开始位置的下标。
返回值：- 若找到该字符串则返回该字符串开始位置的下标，
- 反则返回
-1，表示目标中不包含待查找字符串。
给定参数： - 若给定下标超出左范围（负值）则被重置为
0； - 若超出右范围，则该方法返回
-1。
-
string.protoype.lastIndexOf(searchString, pos?)
作用：从右往左开始查找待查找字符串
给定参数：下标超左（负值）则该方法返回-1，超右重置为0 -
string.protoype.concat(...strings)
作用：该方法将会根据提供的参数合并成一个新的字符串并进行返回。
例如：var str1 = "ha"; var str2 = str1.concat(str1, "21"); console.log(str2); 结果值：haha21 -
string.protoype.includes(searchString, pos?)
作用：根据提供的下标位置开始查找给定字符，若存在返回真，否则返回假。IE可能不支持
给定参数：- 下标超出左范围，该下标被重置为
0， - 下标超出右范围，该方法将会返回假
false。
- 下标超出左范围，该下标被重置为
-
string.protoype.repeat(count)：
作用：根据给出的数值来对字符串进行重复，并返回一个新的字符串。
返回值：如果给定数值为0或者参数为空，将会返回一个空字符串。
注意：count表示该字符串打印的次数，一旦数值为负值将会报错。 -
string.protoype.replace(serchValue:string | RegExp, reokaceVakye: string)
解析： 待查找字符串 | 正则表达式，替换字符串
作用：在目标中查找给定字符串，然后使用替换字符串将其替换掉
注意：如果第二个参数缺省的话则认为第二个参数为undefined。且只替换找到的第一个给定字符
例如：使用正则表达式，找出所有的/，并删除"中国/湖北省/武汉市/黄冈/.../../..".replace(/\//g, '') -
string.protoype.search(string|RegExp)
作用：在目标中查找给定字符串，
返回值：如果找到了则返回下标，否则返回-1。
与indexof比较：不支持起始查找位置设定，但search支持正则表达式
- 例如：/ i. / 点在正则表达式中表示任意字符；
/^i/ ，^表示待查找字符必须是首字符
-
string.protoype.trim()去除空白
作用：用来删除目标字符串两端的空白字符。
trimRight()、trimLeft()，虽然早于规范，但不在规范当中，尽量不适用 -
string.prototype.trimStart()或string.prototype.trimLeft()
作用：删除字符串开头的空白字符。 -
String.prototype.trimEnd()或String.prototype.trimRight()
作用：删除字符串结尾的空白字符。 -
string.protoype.toLowerCase()：
作用：用来将目标字符串全部调整为小写，并返回新的小写字符串。 -
string.protoype.toUpperCase()：
作用：用来将目标字符串全部调整为大写，并返回新的大写字符串。 -
string.protoype.split(separater: string | RegExp, limit?:number)分割
解析： 分隔符，限制
作用：根据给定分割符对目标字符串进行分割，分割的部分被当做独立的元素放入一个数组结构当中。
limit的作用：决定最终保留元素的个数。返回值：当保留个数超出左右范围时，都将会把所有元素进行保留。
给定参数：一旦所有参数都缺省，则将目标字符串整体作为一个元素放入到数组当中。 -
string.protoype.slice(start?, end?)：提取
作用：根据给定的起始与终止下标来提取字符串，提取的规则为左闭右开（包含start下标的元素，不包含end下标的元素）。
给定参数：- 一旦给定的范围没有落在目标字符串上，则取出一个空字符串；
- 如果第二参数缺省，则认为从起始下标一直拿到结尾；
- 如果两个参数都缺省，则将整个字符串提取出来。
- 注意：该方法支持下标负值表示法。
例如： var result = str.slice(-9,3);结果值：el
表示从下标为-9（从左往右）的字符开始向右取，取到下标为2（从右往左）的字符停止var result = str.slice(-10,-4);
表示从下标为-10的字符开始向右取，取到下标为-5的字符停止
| h | e | l | l | o | w | o | r | l | d |
| :–: | :–: | :–: | :–: | :–: | :–: | :–: | :–: | :–: | :–: |
| -10 | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
-
string.protoype.substr(startIndex, length?)：
作用：根据给定的起始下标与要取出的字符长度对目标进行提取
给定参数：- 一旦长度为负值，那么将会提取出一个空字符串。
- 如果第二参数缺省，那么将会提取到最大值（从下标为from的字符取到最后一个字符）；
- 如果两个参数全部缺省则返回整个字符串。该方法支持下标负值表示法。
-
string.protoype.substring(start?, end?)：
作用：该方法可以参照slice方法，
给定参数：- 两个值任意一个较大的值系统将它作为
end，较小值为start； - 该方法不支持下标的负值表示法，若超出左范围，则重置为
0；若超出右范围，则重置为this.length。 - 需要先判断string是否为空
- 两个值任意一个较大的值系统将它作为
-
String.prototype.padStart(length, padString)和String.prototype.padEnd(length, padString)
作用：在字符串的开头/结尾添加指定的字符，直到字符串达到指定的长度。
给定参数：- targetLength：目标字符串的长度。
- padString（可选）：用于填充的字符串，默认为空格。
例如：‘123’.padStart(5, 1) // 返回12311
-
String.prototype.fromCodePoint()
作用：返回一个由指定的 Unicode 字符序列组成的新字符串。- codePoints：一个或多个 Unicode 字符码点。
-
string.prototype.codePointAtt(position)
作用：返回指定位置的字符的 Unicode 编码点。 -
string.prototype.normalize(form)
作用：返回标准化的字符串形式，可以解决某些字符集中的变音符号或组合字符问题。 -
string.prototype.localeCompare(compareString, locales, options)
作用：比较两个字符串在本地环境下的顺序。
示例：1、字符串排序：根据字母顺序对字符串进行排序时 let fruits = ['苹果', '香蕉', '橙子', '梨子']; fruits.sort((a, b) => a.localeCompare(b));// ["香蕉", "橙子", "苹果", "梨子"] 2、多语言环境下的字符串比较 let arr = ['Zebra', 'apple', 'banana']; arr.sort((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }));// ["apple", "banana", "Zebra"] 3、大小写敏感或不敏感的比较 localeCompare() 允许你通过选项来控制大小写敏感或不敏感的比较。例如，sensitivity 选项可以设置为 'base'（不区分大小写）或 'accent'（区分重音符号）。 let letters = ['a', 'A', 'b']; console.log(letters.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }))); // ["a", "A", "b"] console.log(letters.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'accent' }))); // ["A", "a", "b"]
1.2 Array类型
JavaScript 数组的长度和元素类型都是非固定的。因为数组的长度可随时改变，并且其数据在内存中也可以不连续，所以 JavaScript 数组不一定是密集型的，这取决于它的使用方式。
属性
Array.length表示数组的长度（非Object的属性）- constroutor
- prototype
方法
1.2.1 非破坏性方法
定义：利用原数组创建一个新的数组，并不会影响原数组
-
Array.protoype.indexOf(searchElement, fromIndex?)
作用：根据给定的起始下标（从左往右）开始查找待查找元素，若未找到元素则返回-1，否则返回所在元素的下标；
参数：若第二个参数为负数，则重置为0；第二个参数可缺省，表示从第一个元素开始查找。 -
Array.protoype.lastIndexOf(serchElement, fromIndex?)
作用：根据给定的起始下标（从右往左）开始查找待查找元素，若未找到元素则返回-1，否则返回所在元素的下标；
参数：若支持负数形式，与String.prototype.slice()相同；超右重置为this.length-1
第二个参数可缺省，表示从最后一个元素开始查找。 -
Array.protoype.concat(varlue1[, value2[, ...[, valueN]]])合并
作用：该方法会将参数作为新的元素与目标中的元素进行合并，并且放置在新的数组中；
现象：若参数是一个数组，则该方法会解开一层数组结构再进行合并。var oldArray = [1, 2, 3] var newArray = oldArray.concat([3, [6, 7, 2]]) [1, 2, 3, 3, [6, 7, 2]] -
Array.prototype.flat(level)拉平数组
作用：将多维数组“拉平”为一维数组。
给定参数：
- level：指定要提取嵌套数组的结构深度，默认值为 1，如果直接转成一维数组，可以用
Infinity关键字作为参数。[1, [2, 3], [4, [5, 6, [7, 8]]]].flat(2); //解开2层 [1, 2, 3, 4, 5, 6, [7, 8]] [1, 2, 3, [4, 5, 6, [7, 8, [9]]]].flat(Infinity) // 解开所有
-
Array.prototype.flatMap()
作用：首先使用映射函数处理每个元素，然后将结果“拉平”为一维数组。
使用场景：（1）可以实现filter+map结合使用的需求、（2）特定情况下，在指定item后面加一项基本用法 [1, 2, 3, 4].flatMap(x => [x * 2]);// [2, 4, 6, 8] filter+map结合使用场景 [1, 2, 3, 4, 5, 6].filter(v => v % 2 === 0).map(v => v + 2) //[4, 6, 8] 改成flatMap [1, 2, 3, 4, 5, 6].flatMap(v => v % 2 === 0 ? [v + 2] : []) // [4, 6, 8] 特定情况下，在指定`item`后面加一项，例如在3后面加两个0 [1, 2, 3, 4, 5, 6].flatMap(v => v === 3 ? [v, 0, 0] : [v]) // [1, 2, 3, 0, 0, 4, 5, 6] -
Array.protoype.includes(searchElement, fromIndex?)：
作用：根据给定数组，判断该元素是否存在，返回布尔值。console.log([2, 4, 5].includes(1)) false console.log([2, 4, 5].includes(2)) true -
Array.protoype.slice(start?,end?)：提取
作用（提取）：根据给定的起始与终止下标对目标数组中的元素进行提取，该方法遵循左闭右开原则。
给定参数：- 如果第一个参数缺省则表示从第一个元素开始提取；
- 如果第二个元素缺省则表示从给定起始下标一直提取到最后一个元素为止；
- 若两个参数都缺省则返回整个数组。
- 支持负值表示法
-
Array.protoype.join(separator?):string：分割
作用：该方法与string.split()是互斥方法，将所有的元素通过给定分隔符进行连接并形成一个字符串进行返回。
参数：若缺省，则用逗号连接；若为空字符，则直接连接每个元素，不用任何分隔符分割。 -
Array.protoype.isArray();
作用：传入一个待查看的值，若该值是数组则返回true，否则返回falsearr instanceof Array表示当前对象arr是否是构造函数Array实例化而来，不光能判断原生类型，还能判断详细的数据类型
-
Array.protoype.forEach(callbackfn:(value, index, array), thisArg?):void遍历
作用：对每一个元素进行遍历，每遍历一个元素都调用一次回调函数，并把本次遍历的元素的数据提供给回调函数，该方法为无返回值方法。
形参：
- value 遍历数组元素
- index 遍历数组元素的下标
- array 被遍历元素的数组
执行过程：当它遍历到某个元素时，会调用回调函数，并且将当前遍历元素的值传递给第一个形参，将遍历数组的下标传递给第二个形参，将被遍历的数组传送给第三个形参；再进行其他操作。
var arr = [1, 2, 3, 4];
function foo (value, index, array) {
if(index % 2 == 0){
console.log(value);
}
}
arr.forEach(foo);
foo在这里是形参，并且是回调函数（被调用），也是具名函数声明表达式
arr.forEach(foo);中的foo是实参，forEach调动foo回调函数
通常简写成以下方式：
arr.forEach(function (value, index, array) { //function匿名函数声明表达式
if(index % 2 == 0){
console.log(value);
}
});
Array.protoype.map(callback, thisArg?):any[]
作用：该方法用来对原数组的每个元素统一进行相同操作，并返回新数组。
执行过程：该方法在内存中创建一个空数组，新数组的元素是原数组中每个元素调用一次函数后返回的值，最终返回这个数组。
- 该方法是有返回值函数，非破坏性方法
var arr = [1, 4];
arr.map(function(){
console.log(arguments); //arguments接收实参
})
结果值：{0:1, 1:0, 2:[1,4]} 解析：元素1的下标为0，数组是[1, 4]
{0:4, 1:1, 2:[1,4]} 解析：元素4的下标为1，数组是[1, 4]
Array.protoype.some(callback,this?):boolean：有返回值函数
作用：该方法用来对每个元素进行测试，只要有一次结果为真那么整体结果就为真，如果所有结果都为假，那么整体结果为假，返回值永远是布尔值
var arr = [1, 4, 3, 5];
var result = arr.some(function (value, index, array) {
if (value == 4) {
return 2;//无论返回值是什么类型，都返回布尔值
}else{
return false;
}
});
console.log(result);
结果值：true
-
Array.protoype.every(callback,this?):boolean
作用：该方法与对每个元素进行测试，任何一个元素不满足条件，则返回falsevar arr = [1, 4, 3, 4]; var result = arr.every(function (value, index) { return value > 2; }) console.log(result); 结果值：false -
Array.protoype.filter(callback, this?)滤镜
作用：该方法使用相同的逻辑对数组的每一个元素进行测试，通过测试的元素将会被添加到新的数组当中，最后返回新数组。var arr = [1, 4, 3, 4]; var result = arr.filter(function (value, index, array) { return value > 2; }) console.log(result); 结果值：[4, 3, 4] -
Array.protoype.find(callback, this?)
作用：该方法返回通过测试的第一个元素的值，否则返回undefinedvar arr = [1, 2, 3, 4, 5] var result = arr.find(function(value, index, array){ return value > 3; }); 结果值：4 -
Array.protoype.findIndex(callback, this?)
作用：该方法返回通过测试的第一个元素所对应的下标，否则返回 -1var arr = [1, 4, 3, 4]; var result = arr.findIndex(function (value, index, array) { return value > 6; }) console.log(result); 结果值：-1注意：
Array.protoype.indexOf()只能查找一个固定的值，而Array.protoype.findIndex可以根据某个逻辑来查找元素 -
Array.protoype.reduce(callback, this?)迭代
作用：将上一个行为的输出当做输入传递给下一个行为，最后一个行为的输出作为该方法的返回值进行返回，也可以说是在原有的基础上进行二次操作。- 例题解析：第一次遍历时，第二个参数（即9），在这里是
previewvalue的初始值，每次遍历的元素作为currentValue的值，每次调用函数的返回值作为下一次调用时previewValue的新值（也称累积值），最终回调函数的返回值是最后一次调用时previewValue的值；若第二个参数缺省，则将数组中第一个元素作为previewValue的初始值，下一个元素作为每次调用函数时currentValue的值（也称迭代值，currentIndex是当前迭代值的索引（下标））。
var arr = [1, 2, 3]; var result = arr.reduce(function (previewValue, currentValue, currentIndex, array) { console.log("上一个为：" + previewValue + "当前为：" + currentValue); return previewValue + currentValue; }, 9); console.log(result); 结果值： 上一个为：9 当前为：1 pValue = 9 ，cValue = 1 pValue+cValue=10 上一个为：10 当前为：2 pValue = 10 ，cValue = 2 pValue+cValue=12 上一个为：12 当前为：3 pValue = 12 ，cValue = 3 pValue+cValue=15 15 - 例题解析：第一次遍历时，第二个参数（即9），在这里是
-
Array.protoype.from(obj)将一个类数组对象，或者可遍历对象转成一个Array
类数组对象：就是具有length属性的对象Array.from('hello');// ['h', 'e', 'l', 'l', 'o'] let shuiguo ={ 0:'apple', 1:'banana', 2:'orange', length:3 /** 必须要有length，才能使用Array.from，否则返回[]**/ } Array.from(shuiguo); // [ ‘apple’,‘banana’,‘orange’ ] -
Array.protoype.of()
作用：方法用于根据传入的参数创建一个新的数组，而不管传入的参数类型是什么。Array.of('apple', 'banana', 'orange');// ['apple', 'banana', 'orange'] Array.of({'a':'apple','b':'banana',2:'orange'}) // [{ 2: "orange", a: "apple", b: "banana" }] -
Array.protoype.fill(target, startIndex, endIndex)
作用：用一个固定值填充数组的全部或一部分元素。左闭右开。
参数：- target：要填充的元素
- startIndex：开始索引
- endIndex：结束索引，默认为Array.length
let arr = [1, 2, 3, 4, 5]; // 从索引 2 到 4（不含 4）填充为 0 arr.fill(0, 2, 4); // [1, 2, 0, 0, 5]
1.2.2 破坏性方法
定义：在原数组上进行操作，改变元素的结构，不返回新的数组
-
Array.protoype.splice(startpos:number,deleteCount?,...item)删除
作用（替换）：根据给出的起始位置与删除个数，对原数组进行删除操作，然后将参数提供的填充物粘合在被删除的位置上，返回操作完成后元素所组成的新数组；
给定参数：
若没有任何参数，则返回一个空数组
若第三个（即没有插入新元素）参数缺省，则等同于提取功能 -
Array.protoype.pop()：从目标数组中在尾部删除一个元素，并将该元素返回。 -
Array.protoype.shift：从目标数组中在首部删除一个元素，并将该元素返回。 -
Array.protoype.unshift(...item)：将给定参数作为元素，插入到目标数组的首部，并返回新数组的长度。 -
Array.protoype.push(...items)：将给定参数作为元素，插入到目标数组的尾部，并返回新数组的长度。 -
Array.protoype.reverse()：将目标数组进行倒置 -
Array.protoype.sort(function(a, b){}):this马甸排序
作用：排序，
给定参数：a - b 升序， b - a降序var arr = [1, 2, 3]; console.log(arr.sort(function(a, b){ return b-a })) 返回[3, 2, 1]
- 迭代方法：
reduce
遍历方法：forEach、some、every、map、sort
递归方法：不断重复某种逻辑，sort、reverse、reduce、
推送方法：push - 黏合：破坏性方法，破坏原数组，并在原数组中添加新元素，再返回新的数组
切片：非破坏性方法，不破坏原数组，返回新的数组
所有类型都具有 toString() 和 valueOf() 方法，辅助类型转换
-
*.protoype.toString()
作用：返回目标的字符形式 -
*.protoype.valueOf()
作用：返回目标本身
根据对象的属性查找另一个属性
const arr = [
{id: 1, name: '青山区', orgCode: '1-2-3456'},
{id: 2, name: '洪山区', orgCode: '1-2-7890'},
{id: 3, name: '光谷区', orgCode: '1-2-7890111'}
]
arr.find(item => item.name === '光谷区').orgCode
1.3 Number类型
JavaScript中无论是整型还是浮点型，底层使用的都是64位双精度浮点算法。
科学计数法1000 = 1*E+3
例题：
0.1 + 0.2 = 0.300..15个零..4
小数用浮点数来表示，计算机硬件（离散式）无法表示非整数状态，虽然有float算法，但是由于计算机硬件的原因，计算结果只能无限接近真正的值，而不能等于该值。
float 单精度浮点算法32bit
double float双精度浮点算法 64bit
32位的操作系统，最多能用4G内存条，大于4G的内存条，不能装32位系统
在JavaScript中没有整数算法，通用浮点算法，其中对小数位数有限制，若超出范围（16位）则切断不计算在内。
JS中不严格区分整型和浮点型，只是在形式上看，没有小数位就是整型，若有小数位但小数位不能超过误差范围，若误差过小也会被去除
JavaScript在底层无论是整型还是浮点型都用double float双精度算法
-
静态属性
-
Number.EPSILON：属性表示 1 和大于 1 的最小值的差值。 我们使用该值来衡量所能接受的最小误差。值接近于2.2204460492503130808472633361816E-16，或者 2^(-52)。console.log(0.1 + 0.2 - 0.3 < Number.EPSILON) 返回true console.log((0.1*100 + 0.2*100) === 0.3*100) -
Number.MAX_SAFE_INTEGER：该值为所能表示的最大安全整数，一旦超出该范围，那么将会出现比较大的计算误差。安全整数为 2^53 - 1 或 9007199254740991。
误差原因：当JavaScript中某个整数大于某个范围时，这个整数会不安全，误差当达到一定积累值时，可能会发生巨大变化Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 -
Number.MIN_SAFE_INTEGER：该值为所能表示的最小安全整数，安全整数为2^53 - 1或 -9007199254740991。 -
Number.MAX_VALUE：该值为所能表示的最大的无符号值，值接近于1.79E+308。大于MAX_VALUE的值代表Infinity。 -
Number.MIN_VALUE：该值为所能表示的最小的无符号值，小于该值时将被当成0处理，值约为5e-324。 -
Number.NEGATIVE_INFINITY： 属性表示负无穷大。Number.NEGATIVE_INFINITY的值和全局对象的Infinity属性的负值相同。
-
该值的行为同数学上的无穷大
(infinity)有一点儿不同：- 任何正值，包括
POSITIVE_INFINITY，乘以NEGATIVE_INFINITY为NEGATIVE_INFINITY。 - 任何负值，包括
NEGATIVE_INFINITY，乘以NEGATIVE_INFINITY为POSITIVE_INFINITY。0乘以NEGATIVE_INFINITY为NaN.NaN乘以NEGATIVE_INFINITY为NaN.NEGATIVE_INFINITY除以任何负值（除了NEGATIVE_INFINITY）为POSITIVE_INFINITY。NEGATIVE_INFINITY除以任何正值（除了POSITIVE_INFINITY）为NEGATIVE_INFINITY。NEGATIVE_INFINITY除以NEGATIVE_INFINITY或POSITIVE_INFINITY是NaN。- 任何数除以
NEGATIVE_INFINITY为0。
- 任何正值，包括
-
Number.POSITIVE_INFINITY： 属性表示正无穷大。数学中 正无穷+负无穷=0，但
JavaScript中等于NaNNumber.POSITIVE_INFINITY的值同全局对象Infinity属性的值相同。
-
该值的表现同数学上的无穷大有点儿不同：
- 任何正值，包括
POSITIVE_INFINITY，乘以POSITIVE_INFINITY为POSITIVE_INFINITY。 - 任何负值，包括
NEGATIVE_INFINITY，乘以POSITIVE_INFINITY为NEGATIVE_INFINITY。0乘以POSITIVE_INFINITY为NaN。NaN乘以POSITIVE_INFINITY为NaN。POSITIVE_INFINITY除以NEGATIVE_INFINITY以外的任何负值为NEGATIVE_INFINITY。POSITIVE_INFINITY除以POSITIVE_INFINITY以外的任何正值为POSITIVE_INFINITY。POSITIVE_INFINITY除以NEGATIVE_INFINITY或POSITIVE_INFINITY为NaN。- 任何数除以
POSITIVE_INFINITY为0。
- 任何正值，包括
-
-
实例化方法
-
Number.prototype.toFixed(digits):string：使用定点表示法来格式化一个数。digits：表示保留小数点后数字的个数（四舍五入）；介于 0 到 20 （包括）之间，实现环境可能支持更大范围。如果忽略该参数，则默认为 0。实现环境也可以支持更大或更小的值（兼容问题）。
-
Number.prototype.toPrecision([precision]):string：以定点表示法或指数表示法表示的一个数值对象的字符串形式，四舍五入到参数指定的显示数字位数（整数位算在内）。-
precision：可选。一个用来指定有效数个数的整数。如果precison参数不在 1 和 100 （包括）之间，将会抛出一个RangeError。执行环境也可以支持更大或更小的范围。var numObj = 5.123456; console.log(numObj.toPrecision()); //输出 5.123456 console.log(numObj.toPrecision(5)); //输出 5.1235 console.log(numObj.toPrecision(2)); //输出 5.1 console.log(numObj.toPrecision(1)); //输出 5 // 注意：在某些情况下会以指数表示法返回 console.log((1234.5).toPrecision(2)); // "1.2e+3"
-
-
Number.prototype.toExponential(fractionDigits)：一个用幂的形式 (科学记数法) 来表示数值的字符串。-
小数点后以
fractionDigits提供的值来四舍五入。如果fractionDigits参数被忽略了，小数点后的将尽可能用最多的位数来表示该数值。var numObj = 77.1238; alert( numObj.toExponential()); //输出 7.71238e+1 alert(numObj.toExponential(4)); //输出 7.7124e+1 alert(numObj.toExponential(2)); //输出 7.71e+1 alert(77.1234.toExponential()); //输出 7.71234e+1 alert(77 .toExponential()); //输出 7.7e+1
-
-
Number.prototype.toString([radix]):string：返回指定数值的字符串表示形式。-
radix指定要用于数字到字符串的转换的基数(从2到36，也就是进制)。如果未指定 radix 参数，则默认值为 10。var count = 10; console.log(count.toString()); // 输出 '10' console.log((17).toString()); // 输出 '17' console.log((17.2).toString()); // 输出 '17.2' var x = 6; console.log(x.toString(2)); // 输出 '110' console.log((254).toString(16)); // 输出 'fe' console.log((-10).toString(2)); // 输出 '-1010'
-
-
-
静态方法
-
Number.isSafeInteger(testValue)： 方法用来判断传入的参数值是否是一个**“安全整数”**（safe integer）。-
安全整数范围为 -(2^53 - 1)到 2^53 - 1 之间的整数，包含 -(2^53 - 1)和 253 - 1。 当整数值超出安全整数范围的时候，我们的计算将不再精确。
Number.isSafeInteger(3); // true Number.isSafeInteger(Math.pow(2, 53)) // false Number.isSafeInteger(Math.pow(2, 53) - 1) // true Number.isSafeInteger(NaN); // false Number.isSafeInteger(Infinity); // false Number.isSafeInteger("3"); // false Number.isSafeInteger(3.1); // false Number.isSafeInteger(3.0); // true
-
-
Number.isInteger(value)：用来判断给定的参数是否为整数。- 若被检测的值是整数返回true，否则返回false，注意
NaN和Infinity不是整数
Number.isInteger(0); // true Number.isInteger(-10); // true Number.isInteger(0.1); // false Number.isInteger("10"); // false Number.isInteger([1]); // false Number.isInteger(true); // false - 若被检测的值是整数返回true，否则返回false，注意
-
Number.isNaN(value)：用来判断一个给定参是否是NaN，该方法中无类型转换。
Window.isNaN(value)会进行基本类型转换console.log(window.isNaN(undefined)) //true console.log(Number.isNaN(undefined)) //false console.log(window.isNaN("1a")) //true console.log(Number.isNaN("1a")) //false -
Number.isFinite(value)：用来判断给定参数是否是有穷数，该方法无类型转换。console.log(Window.isFinite("123.4")) //返回true console.log(Number.isFinite("123.4")) //返回false -
Number.parseInt(string, radix?):num提炼方法：解析给定字符串并返回整数，radix默认是10进制，也就是将目标字符串当做10进制来解析，并返回成10进制；当无法完成提取时将会返回NaN，提取过程中一旦遇到无法提取的字符将终止提取过程（不识别小数点）。
radix默认值：10console.log(parseInt("123e4.56")) //返回123 console.log(parseInt("1234.56", 2)) //返回1 console.log(parseInt("2234.56", 2)) //返回NaN console.log(parseInt("2234.56", 8)) //返回1180 console.log(parseInt("4f2.56", 16)) //返回1266 过程：由于parseInt的功能是提炼number，第一个参数位期望值是字符串，所以优先将参数转换成字符串，再进行提炼 console.log(parseInt([1, 2, 3])) //返回1 分开写： console.log([1, 2, 3].toString()) //返回1, 2, 3 console.log(parseInt(1, 2, 3)) //返回1在
ES6之前window.parseInt()，所以window和number都有parseInt -
Number.parseFloat(string)：根据给定字符串进行浮点数组提取，与parseInt相似。
parseInt与parseFloat的区别在于parseFloat能识别小数点
注意：小数点的点只能有一个，多个属于非法字符，将割断后面的字符串console.log(parseFloat("2234.56")) //返回2234.56 console.log(parseFloat("2234.5.6")) //返回2234.5Window.parseFloat(string) -
Number()转换方法：转换过程中一旦遇到无法提取的字符将终止转换过程
对象，方法，构造函数，函数console.log(Number("4f2.56")) //返回NaN
-
Window对象与Number对象上的方法不同之处：
Window方法中的目标值都会进行基本类型转换，但Number（除parseInt、parseFloat外）上的所有方法皆无类型转换过程注意：
Window对象上也有parseInt、parseFloat方法，与Number对象上的无异。但是window对象上的isNaN、isFinite方法却与Number对象上的不同。
1.4 Math（内建数学对象）
属性
-
Math.E：自然对数的底，E表示在单位时间下增长率的极限
E属于常量，约等于2.718281828459045，永远接近于2.8，但达不到2.8。 -
Math.PI：圆周率，一个圆的周长和直径之比，约等于3.1415926 -
Math.SQRT1_2：1 / 2的平方根，约等于0.707 -
Math.SQRT2：2的平方根（根号2），约等于1.414
注意：Math是对象，但与基本数据类型无关
方法 -
Math.abs(x)：返回x的绝对值 -
Math.cbrt(x)：返回x的立方根 -
Math.sqrt(x)：返回x的平方根 -
Math.ceil(x)：返回x向上取整后的值，例如 1.2 返回2 -
Math.floor(x)：返回小于x的最大整数，向下取整，例如：1.2 返回1console.log(Math.ceil(1.2)) //返回2 console.log(Math.floor(3.3)) //返回3 超过16位就截断后面的数 console.log(Math.ceil (1.00000000000000009))//返回1 console.log(Math.floor(3.9999999999999999))//返回4 -
Math.round(x)：返回四舍五入后的整数 -
Math.trunc(x)：返回x的整数部分，去除小数 -
Math.fround(x)：返回数字的最接近的单精度浮点型表示- 将双精度浮点用单精度来表示，数据会缺失
- 单精度内存消耗低
console.log(Math.fround(1.32654))1.3265399932861328 -
Math.hypot([x [ , y [ ,....]]])：返回其参数平方和的平方根console.log(Math.hypot(4, 3)) //返回5 计算方法：4*4+3*3 = 25，5^2 = 25 -
Math.log10(x)：返回以10为底数的x的对数 -
Math.log2(x)：返回以2为底数的x的对数
Math.LNG2E以2为底，E的对数- 10^2 =100，
log10^100 = 2，10为底数，2为对数（指数），100为幂
Math.LN2以E为底，2的对数Math.LN10以E为底，10的对数 - 10^2 =100，
-
Math.max([x[, y[,...]]])：返回0个到多个数值中最大值 -
Math.min([x[, y[,...]]])：返回0个到多个数值中最小值 -
Math.pow(x,y)：返回x的y次幂，x底数，y指数，结果为幂，当y = 53时，可能会有误 -
Math.random()：返回0到1之间的伪随机数
在同一个空间和时间内生成相同的数是伪随机数
在同一个空间和时间内生成不同的数是真随机数 -
Math.sign(x)：返回x的符号函数，判定x是正负数、还是0console.log(Math.sign(+0)) //返回0 console.log(Math.sign(-0)) //返回-0 console.log(0 === -0) //返回true -
Math.sin(x)：返回正弦值，必须传入一个弧度角（360° = 2π） -
Math.cos(x)：返回x的余弦值 -
Math.tan(x)：返回x的正切值
圆周长 =2rπ90° = 1 / 4 -
有关多个 0 的知识点
- 当
0.的小数点后面的0有效位大于 7 时转换成用科学计数法表示 - 当整数型有效位超过21位时转换成用科学计数法表示，有小数位时会切掉小数位不要
console.log(0.0000008); //8e - 7 console.log(1000000000000000000000.5); // 1e + 21 - 当
1.5 Object
深度拷贝：JSON.parse(JSON.stringify(obj))
类型的属性方法（JavaScript元编程）
知识点：
- 元编程：元表示最基本、最原子化 的基本编程
分：原型链操作，属性操作 - 在
js中数组是混合集合，即一个数组中可以有多种类型的元素，但在其他语言中声明了数组类型就必须是该类型的数组 - 只要方法中带有Own就表示自有的属性，非原型链
- 系统将
Object.prototype保护起来，不允许修改该原型，若改动Object的原型会导致整个原型链都发生变动，所以Object.prototype = null; 失效 o.__proto__ = null; 拒绝继承，不继承Object原型中的属性，着对o来说无用
遍历for-in
注意：使用 for-in 循环遍历对象的属性时，原型链上的所有属性都将被访问，因此通常会使用hasOwnProperty来过滤掉非继承的原型链上的属性
let obj = {
a: 1,
b: 2,
c: 3
}
for(let i in obj){
console.log(obj[i]) // 1, 2, 3, fun....
}
for(let i in obj){
if(obj.hasOwnProperty(i) === true){
console.log(obj[i]) // 1, 2, 3
}
}
Object.create(proto, [ propertiesObject ])
作用：会使用指定的原型对象及其属性去创建一个新的对象。
注意：若propertiesObject不是对象或不为null，则会报错
Object.create(proto, [ propertiesObject ])
//propertiesObject参数对象是一组属性与值，该对象的属性名称将是新创建的对象的属性名称，值是属性描述符。如果 propertiesObject 参数不是 null 也不是对象，则抛出一个 TypeError 异常。
var o = Object.create(Object.prototype, {
msg: {
},
info: {
value: "=====",
configurable: true,
enumerable: true,
writable: true
}
});
var o1 = {
info: "=="
}
如果使用描述符来创建属性，如果没有给描述符，默认为false，value若不给，默认是undefined
如果是用字面量或构造函数创建的对象，则属性的所有描述符均为true
Object.getPrototypeOf
作用：返回实例化对象继承的原型（即, 内部 __proto__ 属性的值）。
Object.getPrototypeOf(object) == obj.__proto__
Object.setPrototypeOf
作用：设置一个指定的对象的原型 ( 即内部 __proto__ 属性）到另一个对象或 null。
Object.setPrototypeOf(o, Array.prototype);借用Array的原型对象
//警告: 由于现代 JavaScript 引擎优化属性访问所带来的特性的关系，更改对象的 [[Prototype]]在各个浏览器和 JavaScript 引擎上都是一个很慢的操作。其在更改继承的性能上的影响是微妙而又广泛的，这不仅仅限于 obj.__proto__ = ... 语句上的时间花费，而且可能会延伸到任何代码，那些可以访问任何[[Prototype]]已被更改的对象的代码。如果你关心性能，你应该避免设置一个对象的 [[Prototype]]。相反，你应该使用 Object.create()来创建带有你想要的[[Prototype]]的新对象。
Object.is
不会做类型转换
Object.is(value1, value2) //确定两个值是否是 相同的值。
Object.is(NaN, NaN) //true
Object.is(+0, -0) //false
//这种相等性判断逻辑和传统的 == 运算符所用的不同，== 运算符中如果它两边的操作数是不同类型的值则会做隐式的类型转换，然后才进行相等性比较，（所以才会有类似 "" == false 为 true 的现象），但 Object.is 不会做这种类型转换。
//当然，严格相等运算符 === 也不会对操作数进行类型转换，但是它会把 -0 和 +0 这两个数值视为相同的，还会把两个 NaN 看成是不相等的。
Object.freeze
可以冻结一个对象，冻结指的是不能向这个对象添加新的属性，不能修改和删除其已有属性的值，以及不能修改该对象已有属性的可枚举性、可配置性、可写性，也不能增加新属性（即阻止扩展）。也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。
控制目标：整个对象
注意： freeze 会遍历所有属性一次性全部更改，而defined、操作符要指定某个属性更改
- 阻止扩展与描述符无关，找不到原因
Object.freeze(obj)
configurable: false
enumerable: true
writable: false
Object.isFrozen
判断一个对象是否被冻结
Object.isFrozen(obj)
Object.getOwnPropertyDescriptor
作用：返回指定对象上一个自有属性对应的属性描述符。（自有属性指的是直接赋予该对象的属性，不需要从原型链上进行查找的属性）。
描述符：可以看到某属性的特点，一共有6个，常见的有四个
- value：该属性的值，可以是任何值(仅针对数据属性描述符有效)；
- writable：可写性，表示该成员变量的值是否可被修改。(仅针对数据属性描述有效)。
- configurable：可配置性，当它为false时，表示该属性的描述符（configurable、enumerable）不可进行更改，同时该属性不允许被删除；
- enumerable：可枚举性，表示该成员变量是否可被遍历；
- get获取该属性的访问器函数（getter）。如果没有访问器， 该值为undefined。(仅针对包含访问器或设置器的属性描述有效)；
等同于value，get是动态值（可以通过逻辑来返回该值），value是静态值 - set获取该属性的设置器函数（setter）。 如果没有设置器， 该值为undefined。(仅针对包含访问器或设置器的属性描述有效)；
- 注意：
- set和get属性必须是函数
- get属性有执行条件，只有在对象上获取该成员变量时才会激活该函数
只有在给该成员变量重新赋值时才会激活set属性 - get和set只要出现了任意一个，那么该成员变量就不能有value 和
writable: truevar flag = 0; var o = Object.create(Object.prototype,{ some:{ get: function(){ if(flag > 2){ return "2"; }else{ return "3"; } }, set: function(value){ flag = value; } } }); o.some = 5 console.log(o.some); - 只有在configurable为false时，修改描述符才会报错，其他情况不报错但也不会发生改变
Object.getOwnPropertyDescriptor(obj, prop)第一个参表示目标对象，第二个表示要获取描述符的属性名
Object.getOwnPropertyDescriptors
作用：获取一个对象的所有自身属性的描述符。
Object.getOwnPropertyDescriptors(obj)
Object.seal
控制目标：整个对象
可以让一个对象密封，并返回被密封后的对象。密封对象将会阻止向对象添加新的属性，并且会将所有已有属性的可配置性（configurable）置为不可配置（false），即不可修改属性的描述或删除属性。但是可写性描述（writable）为可写（true）的属性的值仍然被修改。
Object.seal(obj)
configurable: false
enumerable: true
writable: true
Object.isSealed
判断一个对象是否被密封
Object.isSealed(obj)
Object.defineProperty
直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象。
Object.defineProperty(obj, prop, descriptor)
例如：
Object.defineProperty(o, {
abc:{
value:"+++++++++"
}
})
Object.defineProperties
直接在一个对象上定义新的属性或修改现有属性，并返回该对象。
Object.defineProperties(arrLink, "0",{
enumerable: false
}) ;
key = 0的enumerable为false
//configurable: true
//writable: true
//为true的原因：key = 0的元素是以普通方式创建的，默认为true，后期我们也没有更改这两个描述符
Object.defineProperties(arrLink, 5,{
enumerable: false
}) ;
//value: undefined
//configurable: false
//writable: false
for-in无法遍历枚举性为false的元素，但该方法可以
for(var index in Object.getOwnPropertyNames(arrLink)){
console.log(arrLike[Object.getOwnPropertyNames(arrLink)[index]])
}
返回值: 000 111 222 undefined 3
Object.getOwnPropertyNames
返回值：返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的字符串数组。
Object.getOwnPropertyNames(obj)
var arrLike = {
0: "000",
1: "111",
2: "222",
length: 3
}
console.log(Object.getOwnPropertyNames(arrLike))
返回值：Array['0', '1', '2', 'length']
Object.preventExtensions
让一个对象变的不可扩展，也就是永远不能再添加新的属性
控制目标：整个对象
Object.preventExtensions(obj)
configurable: true
enumerable: true
writable: true
Object.isExtensible(obj) 返回false
Object.isExtensible
判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。
Object.isExtensible(obj)
//默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 __proto__ 属性可以被更改。Object.preventExtensions，Object.seal 或 Object.freeze 方法都可以标记一个对象为不可扩展（non-extensible）。
Object.prototype.isPrototypeOf 实例化方法
Object.prototype.isPrototypeOf(object)
//用于测试一个对象是否存在于另一个对象的原型链上。
null.isPrototypeOf(object)基础语法错误
Object.prototype.hasOwnProperty
Object.prototype.hasOwnProperty(prop)
//返回一个布尔值，指示对象是否具有指定的属性作为自身（不继承）属性。
Object.prototype.propertyIsEnumerable
Object.prototype.propertyIsEnumerable(prop) //返回一个布尔值，表明指定的属性名是否是当前对象可枚举的自身属性。
Object.prototype.valueOf
Object.prototype.valueOf() //返回指定对象的原始值。可以理解为取得对象PrimitiveValue。
object.prototype.toString
object.toString() //每个对象都有一个 toString() 方法，当对象被表示为文本值时或者当以期望字符串的方式引用对象时，该方法被自动调用。默认情况下，toString() 方法被每个继承自Object的对象继承。如果此方法在自定义对象中未被覆盖，toString() 返回 "[object type]",其中type是对象类型。
1.6 Date
Date.now() 返回自1970年1月1日 `00:00:00 UTC`到当前时间的毫秒数
Date.parse(dateString) 解析一个表示某个日期的字符串，并返回从`UTC` 到该日期对象的毫秒数
var myDate = new Date();
myDate.getYear(); //获取当前年份(2位)
myDate.getFullYear(); //获取完整的年份(4位,1970-???)
myDate.getMonth(); //获取当前月份(0-11,0代表1月)
myDate.getDate(); //获取当前日(1-31)
myDate.getDay(); //获取当前星期X(0-6,0代表星期天)
myDate.getTime(); //获取当前时间(从1970.1.1开始的毫秒数)
myDate.getHours(); //获取当前小时数(0-23)
myDate.getMinutes(); //获取当前分钟数(0-59)
myDate.getSeconds(); //获取当前秒数(0-59)
myDate.getMilliseconds(); //获取当前毫秒数(0-999)
myDate.toLocaleDateString(); //获取当前日期
var mytime = myDate.toLocaleTimeString(); //获取当前时间
myDate.toLocaleString( ); //获取日期与时间
日期格式转换
let birthday = '1990-01-01' 改为'1990/01/01'
方法一：
let newBirthday = formData.birthday.replace(/-/g, "/"); // [1990, 1, 1]
newBirthday = newBirthday.toLocaleDateString() // '1990/01/01'
// toTimeString、toLocaleDateString都可以
方法二
let newBirthday = new Date(newBirthday)
// Thu Jan 01 1970 08:00:01 GMT+0800 (中国标准时间) 格林威治时间
let year = newBirthday.getFullYear()
let month = newBirthday.getMonth() + 1
let strDate = newBirthday.getDate()
if (month >= 1 && month <= 9) {
month = "0" + month;
}
if (strDate >= 0 && strDate <= 9) {
strDate = "0" + strDate;
}
newBirthday = year + '/' + month + '/' + strDate; // '1990/01/01'
返回某一天的凌晨 00:00:00
new Date(new Date(date).toLocaleDateString()).getTime()
1.7 定时器
-
延时定时器
setTimeout(handler: TimerHandler, timeout?:number,.....arguments:any[])
直接调用，无需创建和声明，称为内置函数解析：
- handler：函数引用地址
- timeout：函数执行延迟时间
1000ms=1s - arguments：多个实参
注意：
- 第一个值必须是函数，
setTimeout调用函数，function函数本身不调用；
所以在非简写形式中，实参不能写括号，否则代表调用function函数。 - 回调函数我们无法直接进行传送实参，只能用间接方法
间接方法：在setTimeout从第三个开始参数上进行传送实参，可以有多个实参
function add(a, b){ console.log(a + b); } setTimeout(add, 3000, 5, 9); add指向堆空间所存储函数的地址 // 简写形式 setTimeout(function(a, b){ //setTimeout调用函数 console.log(a + b); }, 3000, 5, 9); -
循环定时器
setInterval(handler: TimerHandler, timeout?, ... arguments:any[]:number)解析：
handler: TimerHandler函数引用地址，timeout：间隔时间，2000 = 2S；arguments：实参
var count = 1; setInterval(function(){ count = count + 1; console.log("---".repeat(count)); }, 2000) -
终止定时器
clearInterval(hanle?)：当达到某种标准时，停止定时器（不再执行下一次定时器回调）参数：所要停止的定时器的ID
var count = 0; var timer1 = setInterval(function(){ if(count < 10){ console.log("你真好看!"); console.log("++++++++++++++++++++++++++++") count = count + 1; }else{ clearInterval(timer1); console.log("================") } console.log("------------------------") }, 500);
1.8 Set\Map
Set是ES6 提供的一种新数据结构 ，本身是一个构造函数。
let set = new Set(value);
- value 可以是array或 具有迭代接口的其他数据结构，用来初始化
- 类似于数组，但没有 length ，有 size
- 要求所有成员的值都是唯一的，也就是会对成员进行去重
- 该数据结构没有数组中的 index，所以无法用 index 来遍历成员，可以使用
for...of遍历 - Set 结构没有键名，只有键值（或者说键名和键值是同一个值）
属性和方法
size：成员总数，类似于Array.lengthadd(value)：添加某个值delete(value)：删除某个值has(value)：返回一个布尔值，表示该值是否为Set的成员。clear()：清除所有成员，没有返回值。keys()：返回键名的遍历器values()：返回键值的遍历器entries()：返回键值对的遍历器forEach()：使用回调函数遍历每个成员Array.from()：可以将 Set 结构转为数组
let set = new Set([1, 2, 3]);
let a = NaN;
let b = NaN;
set.add(a).add(b);
set.add({}).add({});
set //Set(6) [ 1, 2, 3, NaN, {}, {} ]
set.has(NaN); //true
set.delete(1) //Set(5) [2, 3, NaN, {}, {} ]
set.clear(); //Set(0)[]
set.entries() // Set{ 1=>1, 2=>2, 3=>3 }
for (let item of set.keys()) { //与value()方法结果相同
console.log(item); // 1 2 3
}
set = new Set([1, 4, 9]);
set.forEach((value, key) => console.log(key + ' : ' + value));
// 1 : 1
// 4 : 4
// 9 : 9
const array = Array.from(set); // [1, 4, 9]
Map是JS的对象
本质上是键值对的集合（Hash 结构），但是传统上只能用String/Symbol当作键。这给它的使用带来了很大的限制。Map方法的主要作用是在不改变原有数据的基础上，添加附加数据关联。
- 无法用for循环、可以用for-in、 for-of、forEach来遍历，WeekMap同理
- 在map中除了null 以外？任意数据类型都可以作为key来使用
- map转换， […map]具有遍历器接口，
- 数组转 Map要求传入的参数必须是二维数组，且每个数组必须是2个元素
方法与属性：
size：返回成员总数set(key, value)：添加某个值get(key)：读取key对应的键值delete(key)：删除某个值has(key)：返回一个布尔值，表示该值是否为在Map对象中clear()：清除所有成员，没有返回值。keys()：返回键名的遍历器values()：返回键值的遍历器entries()：返回所有成员的遍历器。forEach()：遍历 Map 的所有成员。- Map转为数组用扩展运算符（…），数组转为Map用new Map([…])
Object.fromEntries(map)可以将Map转成对象
const m = new Map();
let o = {p: 'Hello World'};
m.set(o, 'content') // Map(1) { {p: 'Hello World'}: 'content'}
m.has(o) // true
m.delete(o) // true
m.has(o) // false
const map = new Map([
['F', 'no'],
['T', 'yes'],
]);
for (let item of m.entries()) {
console.log(item[0], item[1]);
}
// {p: 'Hello World'} 'content'
WeakSet
WeakSet 结构与 Set 类似，也是不重复的值的集合，但有两个区别：1、WeakSet 的成员只能是对象，而不能是其他类型的值，且不能加引用计数；2、WeakSet 中的对象都是弱引用，即若其他对象都不再引用改对象，则会自动回收WeakSet占用的内存。
方法与属性
add(value)：向 WeakSet 实例添加一个新成员。delete(value)：清除 WeakSet 实例的指定成员。has(value)：返回一个布尔值，表示某个值是否在 WeakSet 实例之中。- 没有size属性，所以无法遍历
WeakMap
WeakMap结构与Map结构类似，也是用于生成键值对的集合。区别有两点：1、WeakMap只接受对象作为键名（null除外），不接受其他类型的值作为键名；2、WeakMap的键名所指向的对象，不计入垃圾回收机制，同WeakSet
1.9 JSON
对象使用JS对象字面量但是表示，而JSON中的对象必须使用“”把属性名包围起来
let person = {
name: "Nicholas",
age: 29
};
// JSON
{
"name": "Nicholas", // js中对象的属性名加上引号，等同于上面的效果
"age": 29
}
JSON与对象的不同
- 没有变量声明（ JSON 中没有变量）。
- 最后没有分号（不需要，因为不是 JavaScript 语句）。
- 用引号将属性名包围起来才是有效的 JSON。
方法：
- JSON.stringify()：将js对象序列化为一个JSON字符串
- JSON.parse()：把JSON字符串转化为响应的SJ值
序列化选项
JSON.stringify() 方法除接收序列化的对象参数外，还可以接收两个参数。用于指定其序列化 JavaScript 对象的方式。
- 第一个参数：序列化的对象（必输）
- 第二个参数：过滤器结果，可以是一个数组或函数（可选）
- 第三个参数：数字或字符串，控制输出字符串缩进和空格（可选）
// 第二个参数为数组：只保留数组中的key键值
let book = {
title: "Professional JavaScript",
authors: [
"Nicholas C. Zakas",
"Matt Frisbie"
],
edition: 4,
year: 2017
};
let jsonText = JSON.stringify(book, ["title", "edition"]);
console.log(jsonText); // {"title":"Professional JavaScript","edition":4}
// 第二个参数为函数：二次处理
let jsonText = JSON.stringify(book, (key, value) => {
switch (key) {
case "authors":
return value.join(",") // 用 ，分隔 authors 属性值
case "year":
return 5000; // year 属性值改为 5000
case "edition":
return undefined; // edition 属性值改为 undefined 所以不显示
default:
return value; // 其他属性直接返回结果
}
});
console.log(jsonText);
// {"title":"Professional JavaScript","authors":"Nicholas C. Zakas,Matt Frisbie","year":5000}
类型转换
[1, 2, 3].toString() => '1,2,3'
强制类型转换，String(123)、Number('123')、Boolean('123')
隐式类型转换（用+） 123+'' => '123' null + '' => 'null'
paseInt可以将字符串中含有非数字内容且以数字内容开头的字符串转换为数字型，只能取整
paseInt('12dd') => 12 paseInt('123.45') => 123 paseInt('ad12') => NaN
parseFloat 与paseInt相同，但它可以保存小数位
paseInt('12.1dd') => 12.1 paseInt('123.45') => 123.45 paseInt('ad12') => NaN
isInteger(2.2)用来判断一个值是否为整数
ES6
Object.is(value1, value2) 比较两个值是否相等
Object.assage(target, value1, ...) 合并对象 与Array.concat相同
Object.keys() 返回一个由参数的所有“可遍历属性的键名”组成的数组
Object.values() 返回一个由参数的所有“可遍历属性的值”组成的数组，且可根据键名排序（键名是数字的情况下）
Object.value('abc') => ['a', 'b', 'c']
Object.value({9: 'H', 4: 'a', 1: 'c'}) => ['c', 'a', 'H']
Object.entries() 等同于Object.value() 与 Object.keys()的合并方法
Object.entries({9: 'H', 4: 'a', 1: 'c'}) => [[9, 4, 1], ['c', 'a', 'H']]
扩展运算符，可用来解构赋值
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 }; => x:1,y:2, z:{a:3,b:4}
{...a} 等同于 Object.assign({}, a)
解构赋值，且可以有默认值（可以是表达式/函数，惰性求值）
let [a, b, c = 45] = [1, 2, 3] => a=1,b=2,c=3
let [a, b] = [1] => a=1, b=undefined
let {a, b} = {f: 1, g: 2} => a=1, b=2
let [a, b] = 'hello' => a='h', b='e'
解构的用途：
1. 交换变量值 let x =1;let y=2 [x,y] = [y,x]
2. 接收函数返回值
3. 函数参数的定义
4. 提取JSON数据
数组
Array.from({'0': 'a', '1': 'c', length: 2} =>[a,c] 将两类对象转成数组（类似于数组的对象/可遍历的对象）
Array.of(2, 3, 4) => [2,3,4] 将一组值转成数组
arr.find() arr.findIndex()
new Array(3).fill(7) 使用给定的值，填充一个数组
arr.includes(value, index) 数组是否包含某个值，起始下标
箭头函数注意点：
（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。
异常捕获
try{} catch(error){}错误捕获语句，两者必须同时出现
- try尝试
- catch捕获：必须有变量，用来接收错误对象
var a;
// 若代码报错了而引擎继续运行会造成引擎崩坏
try {
console.log(a.name);
}
catch (error) { //捕获try代码中的错误，一旦出错，则error接收该错误
console.log(error);
}
console.log("---")
手动抛出错误
例题：要求传入的参数必须是number
function add(a, b) {
try{
if ((typeof a) === "number" && (typeof b) === "number") {
return a + b;
}
else{
//console.log("参数必须为数值型");代码依然完成执行
// uncaugth excepit未捕获的异常
//等同于throw new Error("参数必须为数值型"); //抛出错误
throw "参数必须为数值型";
//throw终止代码执行，激活中断机制，若throw的内容被catch接收到才不会终止代码
}
}catch(e){ //判断我们所写的代码是否有逻辑错误
console.log(e);
}finally{ //最终
return 0;
}
}
console.log(add(5, "hefa"));
解析：尝试运行if语句，若有错误，就被catch接收，把错误信息传给e，最后运行return
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
