JavaScript易忽略点补漏02(个人记录没有观看价值)-CSDN博客

本文链接：https://blog.csdn.net/leave_the_poor/article/details/107719123

本文探讨了JavaScript中的原始类型方法，包括数字类型、字符串类型的方法，以及数组、迭代、映射和集合Map&Set的相关操作。特别强调了原始类型在方法操作时如何创建对象模型进行处理，并介绍了迭代器的概念以及类数组对象的处理方式。

摘要由CSDN通过智能技术生成

原始类型方法

文章目录

原始类型方法

原始类型

原始类型和对象的核心区别：
- 原始类型的数据内容存储在栈。
- 对象的数据内容存储在堆。
原始类型的对象方法:
- 原始类型的进行方法操作时，是将原始类型创建一个对象模型，在对象模型上进行操作。
原始类型方法的使用：
- 对原始类型创建"对象模型"
- 使用对象模型对数据进行处理
- 将结果返回
- 删除对象模型
原始类型添加方法：
- 在use strict模式下==>ERROR
- 非严格模式下，会对原始类型的对象模型添加方法，但之后对象模型会被删除。

数字类型

toString(base)
- 直接对一个数字使用,要使用两个点:
```
123456..toString(32); //2n9c
```

Math.floor向下地板

Math.floor(3.6) //3
Math.floor(3.4) //3

Math.ceil向上
```
Math.ceil(3.6) //4
Math.ceil(3.4) //4
```

Math.round四舍五入

Math.round(3.6) //4
Math.round(3.4) //3

Math.trunc删除小数点

Math.trunc(3.6) //3
Math.trunc(-3.4) //-3

toFixed(n)四舍五入小数点后N位

let num = 1.23456
num.toFixed(2) //"1.23"
num.toFixed(3) //"1.235"

isFinite()是否是常规数字

isFinite(num);
//结果是True，除非输入的不是数字或NaN、Infinity、-Infinity

parseInt()获取整数
```
parseInt("100px"); //100
```
parseFloat()获取浮点数
```
parseFloat("1.5em"); //1.5
```
Math.random()0~1之间的随机数

字符串类型方法

str.indexOf(substr,pos)``````substr在str中出现的位置，从str[pos]开始检索，返回位置
- 获取子字符串出现的所有位置：
```
let str = "As sly as a fox, as strong as an ox";
let target = "as";

let pos = -1;
while ((pos = str.indexOf(target, pos + 1)) != -1) {
    console.log( pos );
}
```
- 用于判断应当这么写indexOf()!=-1
- 或使用~=>~n==-(n-1)=>~str.indexOf()
- **现代提供了更有效的判断是否包含的函数includes
includes(substr,pos)判断是否包含，返回True/false

数组

push/pop比shift/unshift性能快
for...of...遍历获取元素值
数组遍历尽量不要用for...in...
arr.splice(index[,deleteCount,elem1,...,elemN])
- 从index开始删除deleteCount个元素并在当前位置插入elem1,...,elemN
- 返回删除的元素的数组
arr.concat(arg1,arg2..)合并数组
- 对包含Symbol.isConcatSpreadable属性的对象，作为数组将其属性作为元素合并
- 对不包含该属性的对象，作为整体添加进数组。

forEach

arr.forEach(function(item,index,array){
    //..函数体
});

find

let user = user.find(item=> item.id ==1);

filter
```
let results = arr.filter(item=>item.id<3);
```
- find返回第一个，filter返回符合条件元素的集合
map
使用并返回一个新数组

sort

sort()默认字典排序
可以提供一个规则给sort

function compareNum(a,b){
    if (a>b) return 1;
    if (a=b) return 0;
    if (a<b) return -1;
}
let arr = [1,15,2];
arr.sort(compareNum);
console.log(arr);  // 1,2,15

// 可简化
arr.sort((a,b)=>a-b);
// 比较函数只需要返回一个正数表示大于，负数表示小于

reverse颠倒
reduce类似于迭代
- 将元素中的每一个元素与前一次的结果进行计算
```
let arr = [1,2,3,4,5];
let result = arr.reduce((sum,current) => sum + current,0);
console.log(result); //15
```
- 第一次sum=0 current=arr[0]=>sum=0+1
- 第二次sum=1 current=arr[1]=>sum=1+2
- 第三次sum=3 current=arr[2]=>sum=3+3

迭代

迭代器

任何想要作为某种集合的对象，都可以通过使用Symbol.iterator使得可以通过for...of...进行循环

let range ={
    from:1,
    to:5,
};
range[Symbol.iterator] = function(){
    return{
        current:this.from,
        last:this.to,
        // for... of...会调取next();
        
        next(){
            //next()要返回{done：..,value:...}格式的对象
            if (this.current <=this.last){
                return{ done:false,value:this.current++};
            }else{
                return{ done:true};
            }
        }
    };
};

for (let num of range) {
    console.log(num);  //1 2 3 4 5
}

对象通过系统symbol创建了一个对象方法object[symbol.iterator]()
object[symbol.iterator]()内构造了一个返回对象，该对象拥有一个next()方法
next()方法返回for...of...所需要的对象，对象包含两个属性done、value
done:false继续/true停止
value:真正遍历到的值

//显示调用迭代器
let range ={
    from:1,
    to:5,
};
range[Symbol.iterator] = function(){
    return{
        current:this.from,
        last:this.to,
        // for... of...会调取next();
        
        next(){
            //next()要返回{done：..,value:...}格式的对象
            if (this.current <=this.last){
                return{ done:false,value:this.current++};
            }else{
                return{ done:true};
            }
        }
    };
};
// 和 for .. of 做相同的事
let iterator = range[Symbol.iterator]();
while(true){
    let result = iterator.next();
    if (result.done) break;
    console.log(result.value);
}

类数组

一个对象有索引和length属性 => 类数组对象

let arrayLike ={
    0:"Hello",
    1:"Hello",
    length:2,
};

类数组对象进行迭代仍然需要迭代器方法[Symbol.iterator]()
类数组不是数组，不能使用pop,push,shift,unshift
Array.from(obj[,mapFn,thisArg])方法可以把一个可迭代对象或类数组对象
mapFn将在元素添加到新数组前应用于每一个元素,thisArg为函数设置this

let arr = Array.from(range,num=>num*num);
console.log(arr);//1 4 9 16 25

映射和集合Map&Set

Map的比较

Map使用SameValueZero进行比较。

Map的迭代

map.keys() 遍历所有的键
map.values() 遍历所有的值
map.entries() 遍历每个映射
迭代的顺序与插入到顺序相同
forEach(fn)对每个元素进行处理

Map的方法

map.delete(key)
map.clear()
map.has(key)
map.size

Object生成Map/Map生成Object

let obj ={
    name:"Wang",
    age:25,
};
let map = new Map(Object.entries(obj));
let obj2 = Object.fromEntries(map);
let map2 = new Map(Object.entries(obj2));

Object.entries()方法根据对象生成一个Map
Object.fromEntries()根据Map生成一个对象

Set

Set类型与Golang中的Hashmap类似，不过区别在于：

Go的Hashmap中，唯一的是key而Set唯一的是值。

弱映射和弱集合WeakMap & WeakSet

WeakMap 与 Map的不同：

Map的Key可以是任意类型； WeakMap的Key只能是对象。
Map中的Object类型的Key是复制的对象的引用，WeakMap不是。
所以：Map的Object类型的key不会因原值而丢失引用，WeakMap会。

///map
let john = {name: 'John'};
let map = new Map();
map.set(john,"...");
john = null;
for (let key of map.keys()){
    console.log(key); // {name:"John"}
}

//weakMap
let john = {name: 'John'};
let weakMap = new WeakMap();
weakMap.set(john,"...");
john = null;
for (let key of map.keys()){
    console.log(key); // {name:"John"}
}