红宝书读书笔记 第六章

不得不说，这书内容真丰富啊，读一章就要好久。。。

集合引用类型

Object

一般更倾向用对象字面量创建对象

//用对象字面量传入函数参数
//这种模式适合函数有大量可选参数
/*
命名参数更直观，但在可选参数过多时，最好对必选参数命名，对可选参数通过对象字面量封装多个可选参数
*/
function displayInfo(args) {
    let output = ''
    if(typeof args.name == 'string') {
        console.log('string')
    }
    if(typeof args.age == 'number') {
        console.log('number')
    }
}
displayInfo({
    name:'aaa',
    age:22
})

console.log(person['name'])
console.log(person.name)

Array

JavaScript的数组每个槽位(slot)可以存储任意类型的数据;同时也是动态的，会随着数据添加而自动增长

let colors = new Array()
//构造函数创建
let colors = new Array(20)
//length为20的数组
let colors = new Array('red','yellow')
//创建包含三个字符串的数组

//new Array(3)是长度为3，不是只有3
//没有new也可以


//数组字面量也可以

数组空位应该为undefined，但应该避免数组出现空位

数组索引：可以以此来替换、增加大小等等、改变length也可以改变数组大小

相关方法

//创建数组的静态方法
Array.from()  Array.of()
Array.from() 用于将类数组结构转换为数组实例(可迭代的结构或有一个length属性和可索引元素的结构)，可接受三个参数
of()用于将一组参数转换为数组实例
console.log(Array.from('matt'))
const m = new Map().set(1,2)
                    .set(3,4);
const s = new Set().add(1)
                   .add(2)
                   .add(3)
                   .add(4)
console.log(Array.from(m))
console.log(Array.from(s))
const a = [1,2,3,4]
console.log(Array.from(a))

输出：
[ 'm', 'a', 't', 't' ]
[ [ 1, 2 ], [ 3, 4 ] ]
[ 1, 2, 3, 4 ]
[ 1, 2, 3, 4 ]


console.log(Array.of(1,2,3,4))

//判断一个对象是不是为数组
Array().isArray()

//迭代器方法
keys()
返回数组索引的迭代器
values()
返回数组元素的迭代器
entries()
返回索引/值对的迭代器
数组结构
const a = ['foo','bar']
for(const [idex,ele] of a.entries()) {
    console.log(idex)
    console.log(ele)
}

//复制和填充方法
fill()  用其他值填充数组
copyWithin()  复制数组一部分再插入到数组中

//转换方法
valueOf()返回数组本身
toString()拼接成字符串，用逗号拼接
join()//用指定符号拼接

//栈方法、队列方法
push() pop()
shift() unshift()

//排序方法
reverse()反转
sort()排序，

//操作方法
concat()拼接成新数组
slice()截取数组
splice()去除同时插入：可以实现删除、插入、替换

阻止自动打平数组
let moreColors = {
    [Symbol.isConcatSpreadable]: true;,
    length: 2,
    0:1,
    1,2
}
let newColors = ['yellow','green']
newColors[Symbol.isConcatSpreadable] = true;
//设置为true，即可实现


//搜索和位置方法
indexOf()
lastIndexOf()
includes()
find()
findIndex()


//迭代方法
every()对每一项进行，全部返回true不然返回false
filter()对数组每一项运行传入函数，返回true的项组成数组返回
forEach()对每一项运行传入函数无返回值
map()对每一项运行，所有结果组成数组返回
some()对每一项运行，有一个则返回true


//归并方法
都会迭代数组所有项，在此基础上构建一个最终返回值
reduce()从左向右
reduceRight()从右向左

定型数组(TypedArray)(类型化数组mdn翻译)

https://www.cnblogs.com/xiaohuochai/p/7261022.html
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/TypedArray (感觉mdn写的没那么清除，但是方法属性都很全面)
同时了解下大端序、小端序
相比于第一次读，明白了很多，但还是不那么清晰，包括一部分内容也没怎么学，以后再学吧

Map

const m1 = new Map([
    ['key1','value1'],
    ['key2','value2'],
    ['key3','value3']
])
//创建的同时初始化实例可以给Map构造函数
//传入一个可迭代对象，需要包含键值对数组

m1.set('key4','value4')
console.log(m1.has('key1'))
console.log(m1.delete('key1'))
console.log(m1.clear())

顺序与迭代
Map可以根据插入顺序执行迭代操作;映射实例可以提供一个迭代器，能以插入顺序生成[key,value]形式的数组

entries() // Symbol.iterator
const m = new Map([
    ['key1','value1'],
    ['key2','value2'],
    ['key3','value3']
])
console.log(m.entries == m[Symbol.iterator])
for(let pair of m.entries()) {
    console.log(pair)
}
for(let pair of m[Symbol.iterator]()) {
    console.log(pair)
}


keys()
values()
分别是键、值的迭代器

键和值在迭代遍历时可以修改，但内部映射无法改变
const m = new Map([
    ['key1','value1']
])

for(let pair of m.keys()) {
    pair = 'sss'
    console.log(m.has(pair)) //false
    console.log(m.get('key1'))//value1
}

Map与Object
内存方面、插入性能、删除性能Map占优
查找方面Object更好

Set

如果想在创建的同时初始化，可以传入一个可迭代对象，其中包含需要插入到新集合实例的元素
const m1 =  new Set(['val1','val2'])
m1.add('val3')
console.log(m1.has('val3'))
m1.delete('val3')
console.log(m1.has('val3'))
m1.clear()
console.log(m1)

集合实例可以提供一个迭代器，能以插入顺序生成集合内容。可以通过values()keys()Symbol.iterator属性取得迭代器

const m =  new Set(['val1','val2'])
console.log(m.keys==m.values)
console.log(m[Symbol.iterator] == m.keys)

const m =  new Set(['val1','val2'])
for(let value of m.values()) {
    console.log(value)
}
for(let value of m.keys()) {
    console.log(value)
}
for(let value of m[Symbol.iterator]()) {
    console.log(value)
}

定义正式集合操作
可以跟着书练练手

迭代与拓展操作

有四种原生集合类型定义了默认迭代器
Array Map Set TypedArray

let iterableThings = [
    Array.of(1,2),
    typedArr = Int16Array.of(3,4),
    new Map([[5,6],[7,8]]),
    new Set([9,10])
]
for(const i of iterableThings) {
    for(const x of i) {
        console.log(x)
    }
}
//似乎没有values什么也能迭代
输出
1
2
3
4
[ 5, 6 ]
[ 7, 8 ]
9
10

所以这些类型都兼容扩展操作符。扩展操作符在对可迭代对象执行浅复制时特别有用

let arr1 = [1,2,3]
let arr2 = [...arr1]
console.log(arr1)
console.log(arr2)
console.log(arr1 === arr2)
[ 1, 2, 3 ]
[ 1, 2, 3 ]
false

对于挈带可迭代对象的构造函数，只要传入一个可迭代对象就可以实现复制

let map1 = new Map([[1,2],[3,4]])
let map2 = new Map(map1)
console.log(map2)

等等

let arr = [1,2,3]
let arr2 = [1,...arr,2,3]
let arr1 = [1,2,3]
let typedArr1 = Int16Array.of(...arr1)
let typedArr2 = Int16Array.from(arr1)
let map = new Map(arr1.map(x => [x,'val' + x]))
console.log(map)
let set = new Set(typedArr1)
console.log(set)
let arr2 = [...set]
console.log(arr2)

WeakMap

MDN

WeakSet