中Set数据结构,Set数据结构学习

ES6 提供了新的数据结构
Set。它好像于数组,可是成员的值都是唯一的,未有再度的值。

世家好混元霹雳手Ziksang又来了,给大家讲讲es陆,Set那些新的数据结构

澳门葡京 1

新禧初叁,先给我们拜个年,作者领会自家的拜情势错了!!红包将要打到你的支付宝中,请接到!

20一柒年的靶子便是把ecmscript陆颇具的知识点全弄了解,作者深信之后会基于ecmascript陆的新特色显著会出部分更牛B的框架,就像vue一样用了Object.defineProperty
ecmascript五的新特性来拓展多少威逼,所以作者很希望

一.简要介绍

  ES6提供了新的数据结构SetSet对象不是数组,
能够用来保存对象恐怕基本类型, 全体保留的值都以唯一的,
chrome浏览器>38和FF>13,以及nodeJS,对Set支撑美好,
以下的部分代码,都足以拷贝到调控台直接运行哦;

Set 本身是贰个构造函数,用来生成 Set 数据结构。

回顾介绍一下吗

Set基本介绍

Set是ES陆中数据结构中内部1个新的性状,大家看起来往往很像数组,不过他的每一个成员都以唯壹的,不会存在重新的值

Set也是多少个构造函数,用来生成Set这几个数据结构,大家得以看看他实例原型上有这么些东西,简单看一下

澳门葡京 2

在set原型上放了如此多措施,接下去本人逐一介绍一下啊,记住学习必就要学到根本!!!!

专注自个儿的每一步代码都以自上而下有着关系的

add方法

let set = new Set()
let array = [1,"ziksang",3,3,true,5,5]
array.forEach(item => {
        set.add(item)
})
console.log(set)
// Set {1, "ziksang", 3, true, 5}

一.先new出set那个构造函数实列,我们存在set变量上
二再声可瑞康个array这一个数组,里面包车型大巴数组成员有各类数据类型和重复的值
三.用Set原型上add方法把用es5中each方法把各类值增添到set成员里
四.打字与印刷出来是三个对象,里面一样档次同样值都会去掉,不过中间的总体结构和类组数对象同样,有着和谐的长度

 for (let i of set) {
         console.log(i);
         console.log(typeof i)
}

如上大家再一次用for
of的不二等秘书籍也,同样也是es六的新天性,此时就可以把set对象里每一个值能够打印出来,里面包车型地铁打字与印刷出的每贰个数据类型也同样是我们array数组里定义的数据类型


地方代码通过add方法向Set结构加入成员,结果证明Set结构不会助长重复的值。
Set函数能够承受叁个数组(或看似数组的对象)作为参数,用来初步化。

        function demo(){
            let set = new Set(arguments)
            console.log(set)
        }
        demo(1,2,4,4,5)
        //Set {1, 2, 4, 5}
        let set = new Set([1,2,4,4,5])
        console.log(set)
        //Set {1, 2, 4, 5}

一.Set函数里大家得以承受参数来作为开端化跟new
Array[1,2,3,4]品质是同1的
2.率先个自我在demo函数里让set函数接收了demo里arguments对象作为参数
三.次之个自小编平素在set函数里放入一个数组
四.两都console.log()打字与印刷出来的是一样的,相同不会含有同系列一样的值的积极分子

size方法

中Set数据结构,Set数据结构学习。size方法是用来剖断出,set里成员的个数

var items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
items.size // 5

一.固然上边小编定义了7个分子数量,可是最终个数只有几个,因为还是一如既往的不会把重复同品种同样的值算进去,只算三个

数组去重方法
在从前数自个儿面试的时候别人1直接自身数组去重如何,小编今日只想应对他,看下面

       let array = [1,2,2,3,3,4]
       let set = new Set(array)
       array = [...set]
       console.log(array)
      //[1,2,3,4]

1.宣称叁个数组
二.把数组作为set构造函数的伊始化成员
3.再把set用[…set]来再一次复制给array//简称拓展运算符…
四.扩展运算符(…)内部采取for…of循环,所以也足以用于Set结构。

至于类型调换,NaN,object的区分

在往set数据结构中增添值的值,并不会产生类型转变,肆和“四”不相同的数据类型不会发生转移,他的中间是用Same-value equality,也正是跟恒等诸多,但是NaN不雷同很越发

       console.log(NaN === NaN) //false
       const a = NaN;
       const b = NaN;
       const c = "1";
       const d = 1;
       let set = new Set()
       set.add(a)
       set.add(b)
       set.add(c)
       set.add(d)
       console.log(set) //Set {NaN, "1", 1}

1.比方单纯的比对NaN ===
NaN料定是不等于的,但是在set数据结构中,里面包车型客车计算原理是把NaN看成相等的


对于三个对象的话,无是内部是或不是有值
,可者有怎么样的值都以不对等的,空对象也不对等

       let set = new Set()
       set.add({})
       set.add({})
       console.log(set)  //Set {Object {}, Object {}}
       console.log(set.size)//2

1.方可看出空对象是不对等的,所以它们被视为七个值。总个数还是是3个


Set实例的质量和方法,相当于Set构造函数上定义的章程和性质

Set结构的实例有以下属性。
Set.prototype.constructor:构造函数,暗中同意正是Set函数。
Set.prototype.size:再次来到Set实例的成员总量。

Set实例的章程分为两大类:操作方法(用于操作数据)和遍历方法(用于遍历成员)。下边先介绍四个操作方法。

add(value):增加某些值,重回Set结构自个儿。
delete(value):删除有些值,重回一个布尔值,表示删除是或不是中标。
has(value):再次回到三个布尔值,表示该值是或不是为Set的分子。
clear():清除全部成员,未有再次来到值。

size和add笔者在前头已经讲过了,再轻易提一下啊

        let set = new Set()
        set.add(3).add(2).add(2).add("ziksang");
        console.log(set)//set{3,2,ziksang}
        console.log(set.has(3)) //true
        console.log(set.delete(2))  //true
        console.log(set)   //set{3,ziksang}
        console.log(set.clear()) //undefined
        console.log(set) //set{}

一.我们new出Set构造函数的实列对象开始展览一个一个add进行增多,但是加多了三个同种类一样值
的二 !最终打字与印刷出来一样的三个会被剔除
二.set.has()是拓展对set数据结构中成员是不是留存的论断
三.删减set数据结构中成员
4set.clear()是举行消除全体成员,set实列也就此产生了1个空对象


今非昔比比较的例证,看看Object和Set多少个数据结构决断方式各异

        let obj={
            name : "ziksang",
            age : 22
        }
        let set = new Set(["name",22])
        if(obj.name){
            console.log("在对象里有name这个健值")
        }
        if(set.has("name")){
            console.log("set数据结构中有name这个成员")
        }

2.数组转Set

  创制Set实例的中心措施为:

let set = new Set(); //或者 new Set(null);
console.log(set);

  或然那样:

let set = new Set([1,2,3,4,4,4,4,4]);
console.log( Array.from(set) ); //输出:[ 1, 2, 3, 4 ]

  能够看出,以上海重机厂复的四,在set内部只保留了2个,
所以Set对象能够用来给数组去重;

  Set也能用来保存NaN和undefined, 借使有再一次的NaN,
Set会以为就二个NaN(实际上NaN!=NaN);

  实例Set今后的对象具备那几个质量和方法

    属性
    Set.prototype
    Set.prototype.size
    方法
    Set.prototype.add()
    Set.prototype.clear()
    Set.prototype.delete()
    Set.prototype.entries()
    Set.prototype.forEach()
    Set.prototype.has()
    Set.prototype.values()
    Set.prototype[@@iterator]()

  Set这种类型的数据结构其实我们能够一贯用数组模拟出来,
尽管无法和原生的比, 只可以模拟以上列表的片段方法属性(
还有局部意义无法落到实处的 , Set实例的[Symbol.species]本着本身,
但是chrome中从不[Symbol.species]本条家伙儿…. )

const setset = new Set([1, 2, 3, 4, 4]);

setset
>>Set(4) {1, 2, 3, 4}

setset.size  // set长度用size属性
>>4

[...setset] //使用扩展运算符 将set结构变数组结构
>> [1, 2, 3, 4]

提示

1.[阮一峰]用obj[somename]来判别是不是对象里有那几个健,打出来是undefined,以上纠正了一下
2.判定set数据结构中是否有某些成员,用set.has()来推断


别的再介绍一下另1种数组去重格局

Array.from()是es陆数组中新带的贰个格局

        function demo(array){
            return Array.from(new Set(array))
        }
        let result = demo([1,1,2,2,3])
        console.log(result)//1,2,3

Array.from是什么鬼未来具体讲到es陆数组小编给我们讲讲,作者今天只知其壹,不知其2,讲不彻底的就不给我们讲


遍历操作
Set结构的实例有多个遍历方法,能够用来遍历成员。

keys():重临键名的遍历器
values():重回键值的遍历器
entries():重回键值对的遍历器
forEach():使用回调函数遍历每一种成员
内需专门提出的是,Set的遍历顺序正是插入顺序。那几个特点有时13分有用,比如选取Set保存2个回调函数列表,调用时就能担保根据增多顺序调用。

keys方法、values方法、entries方法再次回到的都以遍历器对象,因为set未有健名只有健值
,所以健名和健值能够视为同三个值 ,keys和values重回的都以同二个值

       let set  = new Set([1,2,3,4])
       for(item of set.keys()){
           console.log(item) //1,2,3,4
       }
       for(item of set.values()){
           console.log(item) //1,2,3,4
       }
       for(item of set.entries()){
           console.log(item) //[1,1],[2,2],[3,3],[4,4]
           console.log(typeof item)//都是object对象
       }

一.keys,values,entries()重临的都以遍历器对象
二.entries回去的是健值对,因为为健和值都以同样的,所以中间多少个也同等,可是回到出来是是一个指标,本值
上是2个类数组对象


Set结构的实例默许可遍历,它的私下认可遍历器生成函数便是它的values方法。第2个张图笔者也打字与印刷出prototype原型上的主意和品质里,里面包车型客车symbol.iterator里是values()所以也足以一向for
of Set构造函数重临的实例

Set.prototype[Symbol.iterator] === Set.prototype.values
// true

       let set  = new Set([1,2,3,4])
       for(item of set){
           console.log(item) //1,2,3,4
       }

能够看看我们一直遍历SET实例和调用value()再次来到的遍历器对象是一律的


forEach()

Set结构的实例的forEach方法,用于对各样成员推行某种操作,未有重返值。

       let set  = new Set([1,2,3,4])
       set.forEach(function(value,key){
           console.log(value*key) //1,4,9,16
       })

地方代码表明了,对set实例里的健和值互乘,其实value和key都是三个值


数组的map和filter方法也能够用set上

       let set  = new Set([1,2,3])
       set = new Set([...set].map(item => item*2))
       console.log(set) //{2,4,6}
       set2 = new Set([...set].filter(item =>item>3))
       console.log(set2)//{4,6}

给大家解释一下用了那个主要办法
1[…set]把set实例进行转成数组再用map方法把线个值乘二给重临当作Set函数里的分子
二.filter方法也是同理,只是对数组 的值 实行筛选再回来


因而利用Set能够很轻易地贯彻并集(Union)、交集(Intersect)和差集(Difference)。
1.并集Union

        let a = new Set([1,2,3,4,5])
        let b = new Set([1,2,3,6,7])
        let set = new Set([...a,...b])
        console.log(set) //1,2,3,4,5,6,7

上边把a,b里遍历出来在放入数组,再用set的特征开始展览去重

2.交集

        let a = new Set([1,2,3,4,5])
        let b = new Set([1,2,3,6,7])
        let intersect = new Set([...a].filter(x => b.has(x)))
        console.log(intersect) //{1,2,3}

下边是把a进行中间转播成数组用filter进行过滤,过滤的回来结果是b里面有的值

差集

        let a = new Set([1,2,3,4,5])
        let b = new Set([1,2,3,6,7])
        let intersect = new Set([...a].filter(x => !b.has(x)))
        console.log(intersect) //{4,5}

3.行使Set给数组去重

  使用数组模拟二个Set构造器:

澳门葡京 3澳门葡京 4

<html>
<head>
    <meta charset="utf-8">
</head>
<body>
<script>
    "use strict";
    class Set {
        //对_set进行去重;
        static refresh () {
            let _this = this;
            let __set = []
            this._set.forEach(function(obj) {
                if( __set.indexOf(obj) === -1 && obj!=undefined) {
                    __set.push(obj);
                }
            });
            _this._set =__set;
            this.size = _this._set.length;
        }
        constructor(arg) {
            this.size = 0;
            this[Symbol.species] = this;
            this._set = Array.isArray(arg)&&arg||[];
            Set.refresh.call(this)
        }
        add (obj) {
            this._set.push(obj);
            Set.refresh.call(this)
            return this;
        }
        clear () {
            this._set.length = 0;
            return this;
        }
        delete (obj) {
            if( this._set.indexOf(obj)!=-1 ) {
                this._set[this._set.indexOf(obj)] = undefined;
            };
            Set.refresh.call(this);
            return this;
        }
        /**
         * @desc
         * @return Entries [[],[],[],[]]
         * */
                entries () {
            let result = [];
            this.forEach(function(key, value) {
                result.push([key,value]);
            });
            return result;
        }
        has () {
            if( this._set.indexOf(obj)!=-1 ) return true;
        }
        keys () {
            return this[Symbol.iterator]();
        }
        values () {
            return this[Symbol.iterator]();
        }
        //直接使用数组的forEach方便啊;
        forEach (fn, context) {
            let _this = this;
            this._set.forEach((value) => fn.call(context||value, value, value, _this) );
        }
        //必须支持生成器的写法;
    *[Symbol.iterator] (){
        let index = 0;
        let val = undefined;
        while(index<this.size) {
        val = this._set[index];
        yield  val;
        index++;
    }
    }
    }
    var set = new Set([0,0]);
    //对Set进行基本的操作;
    set.add(1).add(2).add(3).add({1:1})
    set.delete(1);
    set.add(1);
    //使用Set的forEach方法;
    set.forEach(function(key,value,s){console.log(key,value,s,"this")},{this:"this"})
    //检测生成器是否正常运行;
    for(let s of set) {
        console.log(s)
    }
    //因为这个对象有Symbol.iterator, 所以使用扩展符也是好使的;
    console.log([...set]);
</script>
</body>
</html>

View Code

Set 函数可以承受一个数组(比如上面例子中)(或许持有 iterable
接口的任何数据结构)作为参数,用来开头化。

上边是把a进行转账成数组用filter举办过滤,过滤的回来结果是b里面未有的值

假如想在遍历操作中,同步转移原来的Set结构,最近未曾一直的办法,但有三种变通方法。1种是应用原Set结构映射出二个新的组织,然后赋值给本来的Set结构;另1种是选择Array.from方法。

// 方法一
let set = new Set([1, 2, 3]);
set = new Set([...set].map(val => val * 2));
// set的值是2, 4, 6

// 方法二
let set = new Set([1, 2, 3]);
set = new Set(Array.from(set, val => val * 2));
// set的值是2, 4, 6

先是个艺术本质上是把set重新张开赋值,先把本来的set里面包车型地铁变成用[…set]化为数组再用map来开始展览再度操作再重临给set构造函数的分子

其次个措施等自身弄懂了再告知我们

那里作者超越3/6都是按着阮1锋先生的书籍来开始展览剖析,讲的好的自身就记录下来,再用更白的话跟大家讲,有个别不明了说的混淆
的地点也更领会的跟大家说后周楚了,接下去笔者会把阮壹锋先生
ES陆存有的知识点都给大家搞领悟,搞彻底

肆.Set实例的习性和办法

  Set实例的属性:

  size属性:size是指这一个Set的长度,和数组的length效果同样的”
  constructor属性: 那性格格指向Set构造函数 ,那几个代码就可以达成 (new
Set).constructor === Set //输出:true

 

const set = new Set(document.querySelectorAll('div'));

4.1支持for…of 和foreach循环

  Set实例的方法:

  add方法,往set添增多少;

<script>
    Array.from((new Set([1,2])).add(3)); // 输出:[1, 2, 3]
</script>

  

  clear方法,把set里面的多寡清空;

let set = (new Set([1,2,3,4]));
set.clear();
Array.from(set);

  delete方法,删除set里面包车型地铁钦定数量:

let set = (new Set([1,2,3,4]));
set.delete(1);
Array.from(set); //输出:[2, 3, 4]

  entries方法:

let set = (new Set([1,2,3,4]));
Array.from(set.entries());

  forEach方法:set的forEach有五个参数,
第三个参数为一个函数,第三个参数是非必须的,假若传了第二个参数,
那么该函数的光景文this便是大家传的第一个参数:

<script>
let set = (new Set([1,2,3,4]));
set.forEach(function() {
    console.log(arguments);
    console.log(this)
},"1111");
</script>

  输出:

  澳门葡京 5

  has方法, has是判别那一个set是或不是有钦定的值, 再次回到false或许true;

<script>
let set = (new Set([1,2,3,4]));
console.log(set.has(1)) //输出:true;
console.log(set.has(5)) //输出:false
</script>

  keys方法和values()方法, 那多个主意都以回到二个迭代器;

<script>
let set = new Set([1,2,3,4]);
console.log(set.keys());
console.log(set.values());

var keys = set.keys();
for(let key of keys) {
    console.log(key);
};
</script>

  @@iterator()方法, @iterator方法是set暗许的迭代器;

<script>
let set = new Set([1,2,3,4]);
let setIner = set[Symbol.iterator]();
console.log(setIner.next().value) //输出:1
console.log(setIner.next().value) //输出:2
console.log(setIner.next().value) //输出:3
console.log(setIner.next().value) //输出:4
</script>

  实际上大家能够重写set[Symbol.iterator],不过不会对set的keys和values方法发生影响;

  整个DEMO:

澳门葡京 6澳门葡京 7

var mySet = new Set();
//往mySet里面添加数据, 1 , 5
mySet.add(1);
mySet.add(5);
mySet.add("some text");
//添加对象
var o = {a: 1, b: 2};
mySet.add(o);

mySet.has(1); // 返回:true
mySet.has(3); // 返回:false
mySet.has(5);              // 返回:true
mySet.has(Math.sqrt(25));  // 返回:true
mySet.has("Some Text".toLowerCase()); // t返回:rue
mySet.has(o); // 返回:true

mySet.size; // 4

mySet.delete(5); // 从mySet里面删除5
mySet.has(5);    // 输出:false, 5 已经被删除了

mySet.size; // 现在的长度为:3

// 通过 for...or循环获取数据;
// 输出: 1, "some text"
for (let item of mySet) console.log(item);

// 输出: 1, "some text"
for (let item of mySet.keys()) console.log(item);

// 输出: 1, "some text"
for (let item of mySet.values()) console.log(item);

// 输出: 1, "some text", 对于Set来说:key和value是一样的
for (let [key, value] of mySet.entries()) console.log(key);

// 把迭代器转化为数组的第一种方式;
var myArr = [v for (v of mySet)]; // [1, "some text"]
// 把迭代器转化为数组的第二种方式;
var myArr = Array.from(mySet); // [1, "some text"]
// 也可以用next()方法,手动去获取每一个值;

View Code

  Set的莫过于用途:

  利用set能够一本万利的进行交集和并集:

  求并集, 大家得以给五个方案依旧越来越多:

var union = (setA, setB) => {
    //[...setA]这种方式目前只有babel才支持
    return new Seet([...setA,...setB]);
};
var union = (setA, setB) => {
    return new Set(Array.from(setA).concat(Array.from(setB)));
}

  那种获取交集的情势,和数组求交集差不离;

var intersect = (set1, set2) => {
    //return [x for (x of set1) if (set2.has(x))]; 这种写法完全不行嘛....
    var resultSet = new Set();
    for(let set of set1) {
        if(set2.has(set)) {
            resultSet.add(set);
        };
    };
    return resultSet;
};

  以下那种代码更加短,太酷了呀,
那些艺术来自:;

var intersect = (set1, set2) => {
    return new Set([...set1].filter(x => set2.has(x)));
}
console.log(intersect(new Set([1,2,3,4]), new Set([2,3,4,5]))); //输出:Set {2,3,4}

要点:

一、 set剖断七个值是或不是千篇壹律,使用的是===,并不会转化项目。

贰、set中不得不有二个NaN,他感觉四个NaN相等。

三、set中三个目的始终不等,尽管多个空对象,也是不一样的。

肆、日常用来数组去重:

// 去除数组的重复成员
[...new Set(array)]

 

5.和对象写法的周旋统一

  弱引用的WeakSet

  WeakSet目的是局地对象值的会合,
并且在那之中的各类对象值都只可以出现叁回,WeakSet只好存目的类型的元素,比如:Object,
Array, Function 等等;有了弱引用的WeakSet
就不要忧郁内部存款和储蓄器泄漏了,假使别的对象不引用该指标,
那个目的会被垃圾回收机制自动回收;

<script>
    console.log(new WeakSet([{},[],()=>({1:1})]));
</script>

  WeakSet对象的秘技唯有四个,而且WeakSet对象未有size属性;
    weakSet.add();
    weakSet.delete();
    weakSet.has();

  借使指标不设有引用,
那么WeakSet对象会把未有引用的靶子占用的内部存款和储蓄器回收,
下边那一个demo,你能够跑一下,
然后过1会儿(小编的chrome浏览器10S就看出功效了)再看调控台:

<script>
var ws = new WeakSet()
var obj = {}; ws.add(obj);
ws.add([])
setInterval(()=>{
    console.log(ws);
},1000)
</script>

  weakSet能够用来保存DOM节点, 当节点被删去,
weakSet个中的该节点假诺不存在其余引用的话, 一段时间内会被内部存款和储蓄器回收;

6.Set转数组

   参考:

  MDN:

澳门葡京,  ruanyifeng:

作者:
NONO

出处:http://www.cnblogs.com/diligenceday/
QQ:287101329
微信:18101055830 

7.数组的map 和filter 方法用于set数据结构

八.直接在遍历操作中更动原来的 Set 结构。

————————————-鸽——鸽—-鸽—————————————-

1.简约介绍

  • 类似于数组
    //差别:成员的值都以绝无仅有的,未有重新!以下代码评释:
  • Set自身是2个构造函数,用来生成set数据结构

const s = new Set();

[2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x));

for (let i of s) {
  console.log(i);
}
// 2 3 5 4

二.数组转Set(接受【数组】or【类似数组的靶子】参数)

Set函数尚可多少个数组(可能具备iterable接口的别样数据结构作为参数),用来开始化。
输出用[…name],Set数据结构有.size方法,相当于数组的length

澳门葡京 8

image.png

上海教室展现了参数是数组的动静,下边演示参数是指标的动静:

澳门葡京 9

image.png

三.数组去重

倾心一条
骨子里,利用Set数据结构不能容许重复值的特色,将数组转成set
在转成数组正是去重了。

澳门葡京 10

image.png

给数组去重的另1种情势

澳门葡京 11

image.png

  • 向 Set 到场值的时候,不会发出类型转变,所以5和”五”是三个例外的值。Set
    内部判定四个值是不是不相同,使用的算法叫做“Same-value
    equality”,它相仿于精确相等运算符(===),主要的界别是NaN等于小编,而标准相等运算符以为NaN不对等作者。
![](https://upload-images.jianshu.io/upload_images/7999981-09875f49c4b8b84c.png)

他认为NaN等于自身的图证!
  • BUT! 他认为三个对象永恒不对等。。
![](https://upload-images.jianshu.io/upload_images/7999981-21f0948040f959b1.png)

明明是两个相同的空对象

肆.Set实例的品质和办法

set结构的实例有以下属性

  • Set.prototype.constructure:构造函数,暗中认可是Set函数。
  • Set.prototype.size:重回set实例的分子总的数量

方法:

  • 操作方法
  • 遍历方法
    操作方法:
    — add(value):增添某些值,再次回到set结构自个儿。
    — delete(value):删除有个别值,再次来到八个bool值,表示是还是不是成功。
    — has(value):重临贰个布尔值,表示该值是不是为Set的成员。
    — clear():清除全数成员,没有重返值。
    遍历方法:4种
    –keys():重返键名
    –values():重回键值
    –entries():再次回到键值对
    –forEach():使用回调函数遍历每一个成员
    供给专门提议的是,Set的遍历顺序就是插入顺序。这些性格有时格外有用,比如采取Set 保存二个回调函数列表,调用时就能担保遵照增添顺序调用。
    (1)keys(),values(),entries()

keys方法、values方法、entries方法再次回到的都是遍历器对象(详见《Iterator
对象》1章)。由于 Set
结构未有键名,唯有键值(或然说键名和键值是同三个值),所以keys方法和values方法的行事完全一致。

let set = new Set(['red', 'green', 'blue']);

for (let item of set.keys()) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.values()) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.entries()) {
  console.log(item);
}
// ["red", "red"]
// ["green", "green"]
// ["blue", "blue"]

Set 结构的实例暗许同遍历,它的暗许遍历器生成函数正是它的values方法。

Set.prototype[Symbol.iterator] === Set.prototype.values
// true

4.1支持for… of和foreach循环

set = new Set([1, 4, 9]);
set.forEach((value, key) => console.log(key + ' : ' + value))
// 1 : 1
// 4 : 4
// 9 : 9

let set = new Set(['red', 'green', 'blue']);

for (let x of set) {
  console.log(x);
}
// red
// green
// blue

5.和对象写法的比较

// 对象的写法
const properties = {
  'width': 1,
  'height': 1
};

if (properties[someName]) {
  // do something
}

// Set的写法
const properties = new Set();

properties.add('width');
properties.add('height');

if (properties.has(someName)) {
  // do something
}

6.set转为数组

澳门葡京 12

set转数组

数组去重的另壹种艺术

澳门葡京 13

image.png

7.数组的map 和filter 方法用于set数据结构

let set = new Set([1, 2, 3]);
set = new Set([...set].map(x => x * 2));
// 返回Set结构:{2, 4, 6}

let set = new Set([1, 2, 3, 4, 5]);
set = new Set([...set].filter(x => (x % 2) == 0));
// 返回Set结构:{2, 4}

所以选用 Set
能够很轻松地完结并集(Union)、交集(Intersect)和差集(Difference)。

let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);

// 并集
let union = new Set([...a, ...b]);
// Set {1, 2, 3, 4}

// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
// set {2, 3}

// 差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1}

捌一贯在遍历操作中改动原来的 Set 结构。

设若想在遍历操作中,同步转移原先的 Set
结构,如今从未直接的方法,但有三种变通方法。壹种是应用原 Set
结构映射出三个新的结构,然后赋值给本来的 Set
结构;另壹种是选取Array.from方法。

// 方法一
let set = new Set([1, 2, 3]);
set = new Set([...set].map(val => val * 2));
// set的值是2, 4, 6

// 方法二
let set = new Set([1, 2, 3]);
set = new Set(Array.from(set, val => val * 2));
// set的值是2, 4, 6

9.WeakSet

  • 分子只可以是指标
  • 污源回收机制不思虑WeakSet的引用
  • ES六规定不得遍历

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website