- 
                
塑料小白
                
                
                0星
             
            - 
                
一指青铜
                
                
                100星
             
            - 
                
二指白银
                
                
                200星
             
            - 
                
十指黄金
                
                
                300星
             
            - 
                
流云蓝珀
                
                
                400星
             
            - 
                
幻影钻石
                
                
                500星
             
            - 
                
键影星耀
                
                
                800星
             
            - 
                
神速大师
                
                
                1000星
             
            - 
                
键舞王者
                
                
                200CPM
             
            - 
                
星河宗师
                
                
                400CPM
             
        
     
    
  
    
    
        闯关失败!💔
        你打错了太多字,再接再厉吧!
        
            
        
     
   
        
                
            
                        
                
                
                rust ˈkləʊʒər
                rust闭包,可捕获周围环境变量的匿名函数
             
                     
                
            
                        
                
                
                ˈkləʊʒər
                闭包,能够捕获上下文环境的函数对象
             
                     
                
                
            
                        
                
                
                moʊv ˈkləʊʒər
                移动闭包,获取环境变量所有权
             
                     
                
            
                        
                
                                        
                        b 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        w 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        g 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈbaːrəʊɪŋ ˈkləʊʒər
                借用闭包,借用环境变量引用
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        m 
                    
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        b 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        w 
                    
                                     
                
                ɪmˈmjuːtəbl ˈbaːrəʊɪŋ
                不可变借用,只读访问环境变量
             
                     
                
            
                        
                
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        b 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        w 
                    
                                     
                
                ˈmjuːtəbl ˈbaːrəʊɪŋ
                可变借用,可修改环境变量
             
                     
                
            
                        
                
                
                ˈkləʊʒər treɪt
                闭包trait,定义闭包行为的特征
             
                     
                
                
            
                        
                
                
                ef en mjuːt
                可变闭包,可修改捕获的变量
             
                     
                
            
                        
                
                
                ef en ˈaɪtəm
                函数项,普通函数区别于闭包
             
                     
                
                
            
                        
                
                                        
                        v 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        a 
                    
                                        
                        b 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈveəriəbl ˈkæptʃər
                变量捕获,闭包捕获周围变量
             
                     
                
            
                        
                
                
                baɪ ˈvæljuː
                按值捕获,获取变量的所有权
             
                     
                
            
                        
                
                
                baɪ ˈrefrəns
                按引用捕获,借用变量的引用
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        v 
                    
                                        
                        i 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        t 
                    
                                     
                
                ˈkləʊʒər ɪnˈvaɪrənmənt
                闭包环境,被捕获的周围变量集合
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        y 
                    
                                        
                        p 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        f 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                     
                
                ˈkləʊʒər taɪp ɪnˈfɜːrəns
                闭包类型推断,编译器自动推导闭包类型
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        a 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                     
                
                ˈkləʊʒər æz pəˈræmɪtər
                闭包作为参数,将闭包传递给函数
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        n 
                    
                                     
                
                ˈkləʊʒər æz rɪˈtɜːrn
                闭包作为返回值,函数返回闭包
             
                     
                
            
                        
                
                                        
                        h 
                    
                                        
                        i 
                    
                                        
                        g 
                    
                                        
                        h 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        d 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈhaɪərə ˈɔːdə ˈkləʊʒər
                高阶闭包,接收或返回其他闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        p 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        f 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        m 
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        e 
                    
                                     
                
                ˈkləʊʒər pəˈfɔːməns
                闭包性能,闭包调用的效率特性
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈɪnlʌɪn ˈkləʊʒər
                内联闭包,编译器优化的简单闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        t 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        g 
                    
                                     
                
                ˈkləʊʒər ˈkæptʃərɪŋ
                闭包捕获行为,变量捕获的具体方式
             
                     
                
            
                        
                
                
                moʊv ˈkiːwɜːrd
                move关键字,强制闭包获取所有权
             
                     
                
            
                        
                
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        c 
                    
                                        
                          
                    
                                        
                        l 
                    
                                        
                        i 
                    
                                        
                        f 
                    
                                        
                        e 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                     
                
                ˈstætɪk ˈlaɪftaɪm
                静态生命周期,'static闭包的生命周期
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                ˈkləʊʒər ænd ˌɪtəˈreɪʃn
                闭包与迭代,闭包在迭代器适配器中的应用
             
                     
                
            
                        
                
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        a 
                    
                                        
                        p 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                     
                
                ˈɪtəreɪtər əˈdæptər
                迭代器适配器,使用闭包转换迭代器
             
                     
                
            
                        
                
                
                mæp ˈkləʊʒər
                map闭包,转换迭代器元素的闭包
             
                     
                
            
                        
                
                                        
                        f 
                    
                                        
                        i 
                    
                                        
                        l 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈfɪltər ˈkləʊʒər
                filter闭包,过滤迭代器元素的闭包
             
                     
                
            
                        
                
                
                foʊld ˈkləʊʒər
                fold闭包,归约迭代器元素的闭包
             
                     
                
            
                        
                
                
                ˈæsɪŋk ˈkləʊʒər
                异步闭包,用于异步操作的闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                        s 
                    
                                     
                
                ˈkləʊʒər ænd θriːdz
                闭包与线程,跨线程传递闭包
             
                     
                
            
                        
                
                                        
                        t 
                    
                                        
                        h 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        a 
                    
                                        
                        d 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                θriːd ˈkləʊʒər
                线程闭包,在线程中执行的闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        s 
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        u 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        s 
                    
                                     
                
                ˈkləʊʒər ɪn ˈstrʌktz
                结构体中的闭包,结构体字段存储闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                          
                    
                                        
                        g 
                    
                                        
                        e 
                    
                                        
                        n 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        i 
                    
                                        
                        c 
                    
                                        
                        s 
                    
                                     
                
                ˈkləʊʒər ænd ˈdʒenərɪks
                泛型闭包,带有泛型参数的闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        a 
                    
                                        
                        n 
                    
                                        
                        d 
                    
                                        
                          
                    
                                        
                        t 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        s 
                    
                                     
                
                ˈkləʊʒər ænd treɪts
                trait闭包,实现trait的闭包类型
             
                     
                
            
                        
                
                
                bɒkst ˈkləʊʒər
                装箱闭包,堆分配的闭包
             
                     
                
            
                        
                
                                        
                        f 
                    
                                        
                        u 
                    
                                        
                        n 
                    
                                        
                        c 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        v 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈfʌŋkʃn vɜːs ˈkləʊʒər
                函数与闭包,函数和闭包的区别
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        e 
                    
                                        
                        m 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        y 
                    
                                     
                
                ˈkləʊʒər ˈmeməri
                闭包内存,闭包的内存布局和分配
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        o 
                    
                                        
                        p 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        m 
                    
                                        
                        i 
                    
                                        
                        z 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        i 
                    
                                        
                        o 
                    
                                        
                        n 
                    
                                     
                
                ˈkləʊʒər ˌɒptɪmaɪˈzeɪʃn
                闭包优化,编译器对闭包的优化策略
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                        s 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                          
                    
                                        
                        i 
                    
                                        
                        t 
                    
                                        
                        e 
                    
                                        
                        r 
                    
                                        
                        a 
                    
                                        
                        t 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        s 
                    
                                     
                
                ˈkləʊʒərz ɪn ˈɪtəreɪtərz
                迭代器中的闭包,常用迭代器适配器闭包
             
                     
                
                
            
                        
                
                                        
                        m 
                    
                                        
                        u 
                    
                                        
                        t 
                    
                                        
                        a 
                    
                                        
                        b 
                    
                                        
                        l 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                     
                
                ˈmjuːtəbl ˈkləʊʒər
                可变闭包,可修改捕获变量的闭包
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        b 
                    
                                        
                        o 
                    
                                        
                        r 
                    
                                        
                        r 
                    
                                        
                        o 
                    
                                        
                        w 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        g 
                    
                                     
                
                ˈkləʊʒər ˈbaːrəʊɪŋ
                闭包借用,闭包借用环境变量
             
                     
                
            
                        
                
                                        
                        c 
                    
                                        
                        l 
                    
                                        
                        o 
                    
                                        
                        s 
                    
                                        
                        u 
                    
                                        
                        r 
                    
                                        
                        e 
                    
                                        
                          
                    
                                        
                        m 
                    
                                        
                        o 
                    
                                        
                        v 
                    
                                        
                        i 
                    
                                        
                        n 
                    
                                        
                        g 
                    
                                     
                
                ˈkləʊʒər ˈmuːvɪŋ
                闭包移动,闭包获取环境变量所有权
             
                     
                
            
                        
                
                
                stændəd θriːd
                标准库线程模块,用于创建和管理线程
             
                     
                
            
                        
                
                
                stændəd sɪŋk
                标准库同步模块,提供线程同步原语
             
                     
                
                
            
                        
                
                
                ˈkləʊʒər æz ef en
                闭包作为函数指针