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

原始类型方法

原始类型

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

数字类型

1. toString(base)
   • 直接对一个数字使用,要使用两个点:

   123456..toString(32); //2n9c
   

2. Math.floor向下 地板

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

3. Math.ceil向上

   Math.ceil(3.6) //4
   Math.ceil(3.4) //4
   

4. Math.round四舍五入

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

5. Math.trunc删除小数点

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

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

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

7. isFinite()是否是常规数字

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

8. parseInt()获取整数

   parseInt("100px"); //100
   

9. parseFloat()获取浮点数

   parseFloat("1.5em"); //1.5
   

10. Math.random()0~1之间的随机数

字符串类型方法

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
2. includes(substr,pos)判断是否包含，返回True/false

数组

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

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

7. find

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

8. filter

   let results = arr.filter(item=>item.id<3);
   

   • find返回第一个，filter返回符合条件元素的集合
9. map
   使用并返回一个新数组
10. 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);
    // 比较函数只需要返回一个正数表示大于，负数表示小于
    

11. reverse颠倒
12. 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

1. 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"}
   }