ES6中的迭代器和set、map集合

什么是迭代器？

一种机制，也是一种接口，为数据结构提供统一访问接口，依次处理数据据结构成员?
? 只要实现了迭代器接口，就可以使用for...of循环遍历。

/**
 * 迭代器是一种机制 是一种接口 只要数据解构实现了接口 就可以使用for ...of遍历
 */
// 遍历字符串  str = 'hello'
/**
 * 1.for 循环
 * 2.for in循环 
 * 3.split('')
 * 4.Array.from()
 * 5.Array.prototype.slice.call(str,0)
 * 6.[...res] = str;
 * 7.for of循环遍历字符串
 */
let str = 'hello';
for(let key of str){
  console.log(key);
}

for(let i=0;i<str.length;i++){
  console.log(i,str[i])
}
for(let key in str){
  console.log(key,str[key]);
}

? 迭代器本质就是迭代器对象调用next方法，迭代对象理解为指针对象，指针指向数据结构成员
? 第一次调用指向第一个成员 依次调用指向后面成员 。

let arr = ['terry','larry','ronda','jacky','briup'];
let keys = arr.keys();//返回值是迭代器对象 实现了迭代器接口 for ...of遍历 
let values = arr.values();
let entries = arr.entries();
console.log(keys,values,entries);
// console.log(keys);
/**
 * 迭代器本质就是迭代器对象调用得next方法 迭代器对象创建一个指针 指向数据结构首位成员位置
 * 第一次调用指向第一个成员 依次调用依次指向后面成员
 */
console.log(keys.next());//{ value: 0, done: false }
console.log(keys.next());//{ value: 1, done: false }
console.log(keys.next());//{ value: 2, done: false }
console.log(keys.next());//{ value: 3, done: false }
console.log(keys.next());//{ value: 4, done: false }
let result;
while(!(result=keys.next()).done){
  console.log(result)
}
for(let key of keys){
  console.log(key);
}
for(let value of values){
  console.log(value);
}
for(let entry of entries){
  console.log(entry);
}
console.log(values.next());
console.log(entries.next());

function foo(){
  for(let key of arguments){
    console.log(key);
  }
}
foo(1,2,3,4)
let arr1 = [1,2,3,4];
for(let key of arr1){
  console.log(key,'222');
}
let obj = {
  name:'zhangsan',
  age:12,
  gender:'male'
}
for(let key of obj){
  console.log(key,'333');
}

set集合?

? 类似于数组，特点内部成员不会重复,Set构造函数创建set集合，接收参数实现了迭代器接口数据结构
? ????????key和value一致

? 1.添加成员

? set.add('hello')
? set.add(10)
? set.add(null);
? set.add('hello');//不会被添加?
? set.add([]);
? set.add([]);//会被依次添加

? 2.删除成员?

? set.delete('hello');
? set.delete(arr);

? 3.清空成员

? set.clear();

? 4.遍历成员?

? set.forEach((key,value)=>{

? })

? 5.keys ?获取key值组成数组

? ? values 获取value值组成数组
? ? entries 获取key value组成数组

? 6.获取成员个数?

? set.size?

? 7.检测set有没有次成员?

? set.has('hello');

? 可以用set来进行数组去重复?

/**
 * set 类似于数组  使用Set构造函数创建  key和value是一致得
 * 特点：成员的值都是唯一得 参数：数组或者实现了迭代器接口对象
 */
// let set = new Set([1,2,3,4,3,2,1]);
// let set1 = new Set('hello');
// // let set2 = new Set({name:'zhangsan'});报错 
// console.log(set,set1);
let set = new Set();
// 添加成员 add
set.add('hello');
set.add(10);
set.add('hello');
let arr = [];
set.add(arr);
set.add([]);
// console.log(set);
// 删除成员 delete 
// console.log(set.delete('hello'));
// console.log(set.delete(arr));
// console.log(set);

// keys values entries 
// console.log(set.keys());
// console.log(set.values());
// console.log(set.entries());
// for(let key of set.keys()){
//   console.log(key);
// }

// forEach 遍历set集合
// set.forEach((key,value)=>{
//   console.log(key,value)
// })

// 返回set成员个数
// console.log(set.size,'返回成员个数');
// 判断set集合中有没有这个成员
// console.log(set.has(null))
// 清空set成员
// set.clear();
// console.log(set)

// set应用 数组去重 
let set1 = new Set([1,2,3,4,5,4,3,2,1]);
console.log(Array.from(set1));
console.log([...set1])

map集合?

? 类似于对象，也是键值对形式得数据结构，键可以是任意数据类型，实现了迭代器接口?
? let map = new Map();//接收参数数组 键值对组成数组

? 1.添加键值对?

? map.set(funtion(){},null);
? map.set(1,1);

? 2.删除一个属性

? map.delete(1)

? 3.keys values entries?

? keys返回得是键迭代器对象
? values返回的是值迭代器对象
? entries返回得键值对迭代器对象

? 4.forEach

? map.forEach((value,key)=>{

? })

? 5.size?

? map.size 获取键值对个数

? 6.获取属性?

? map.get(键)

/**
 * 对象键只能是string类型和symbol类型
 * Map类似于对象 
 */
// let obj = {
//   name:'zhangsan',
//   null:'hello',
//   [Symbol('email')]:'xxxx.com'
// }
let obj = {
  name:'zhangsan',
  age:12
}
// console.log(Object.entries(obj));
let map = new Map(Object.entries(obj));
// 添加成员 set
map.set({name:'map'},'hello');
let foo = function(){}
map.set(foo,null);
// console.log(map);

// 删除成员 
// map.delete('name');
// map.delete(foo);
// console.log(map);

// 获取成员键所对应的值
console.log(map.get('age'));
console.log(map.get(foo));

console.log(map.size);//获取成员个数 

console.log(map.keys());//获取键组成迭代器对象 
console.log(map.values());//获取值组成迭代器对象
console.log(map.entries());//获取键和值组成迭代器对象

// 遍历map
map.forEach((value,key)=>{
  console.log(value,key)
})
console.log(Map.prototype.get,Set.prototype);

对象和map区别?

1.对象键只能是symbol值或者字符串,map键可以是任意数据类型
2.map属性是有序得，按照插入键得顺序依次返回，对象属性无序的，但是也保留字符串或symbol值得插入顺序
3.map键值对个数可以通过size获取，对象键值对个数只能手动计算
4.map实现了迭代器接口，可以直接使用for...of遍历，对象没有实现迭代器接口，无法直接for..of遍历但是对象可以调用keys,values,entries得到数组进行遍历
5.都是引用数据类型，都有原型对象