国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

23年,我又學(xué)習(xí)了一次amd模塊化,模塊化思想

這篇具有很好參考價(jià)值的文章主要介紹了23年,我又學(xué)習(xí)了一次amd模塊化,模塊化思想。希望對大家有所幫助。如果存在錯(cuò)誤或未考慮完全的地方,請大家不吝賜教,您也可以點(diǎn)擊"舉報(bào)違法"按鈕提交疑問。

    項(xiàng)目目錄
      src
        view1
          index.html
          main.js
        view2
      plugins
        module.js
        jquery.js
        ......
      modules // amd模塊文件 
        a1.js
        b1.js
        c.js
        b2.js
        b21.js

src/view1/index.html

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    <body>
        <!-- 引入amd插件-->
        <!-- amd都有一個(gè)入口文件,我這里設(shè)計(jì)的方式是:自動(dòng)引入同級(jí)目錄下的main.js-->      
        <script src="/plugins/module.js"></script>
    </body>
    </html>

src/view1/main.js

module
.configs({
    baseUrl: '../modules'
})
.require(['a1','a2'], function(a2) {
    console.log('a2: ', a2)
})

plugins/module.js

    // 使用IIFE
    (function(win){
        function module(){
            this.context = {
                baseUrl: './',
                alias: {},
                entry: 'main.js',
                suffix: '.js',
            }
            this.deps = {};
            this.srcs = [];
            this.customEvt = new module.CustomEvt();
            this.ready();
        }

        var utils = module.utils = {
            each(arr, callback){
                var keys = Object.keys(arr);
                for(var i = 0; i < keys.length; i++) { 
                    if(callback.call(arr, arr[i], i) === false) {
                        break;
                    }
                }
            },
            // 只保留指定的keys
            inKeys(target, keys) {
                return Object.keys(target).reduce((newData, key) => {
                    if (keys.includes(key)) {
                        newData[key] = target[key];
                    }
                    return newData;
                }, {});
            },
            // 路徑拼接
            pathJoin(...paths){
                let path = '';
                for(let i = paths.length - 1; i > -1; i--) {
                    let pathItem = paths[i].replace(/\/+$/, '');
                    // 如果是絕對路徑
                    if(/^\//.test(pathItem)) {
                        path = pathItem + '/'+ path;
                        break;
                    }
                    // 如果是相對路徑
                    if(/^\.\//.test(pathItem)) {
                        pathItem = pathItem.slice(2)
                    }
                    // 如果是: ../../a/b/c
                    if(/^(\.{2}\/)+\S+/.test(pathItem) && paths[i-1]) {
                        let matches = null;
                        while(matches = /^\.{2}\/(\S+)/.exec(pathItem)) {
                            pathItem = matches[1];
                            let prevPath = paths[i-1].replace(/\/+$/, '');
                            if(prevPath) {
                                paths[i-1] = prevPath.slice(0, prevPath.lastIndexOf('/'))
                            }
                        }
                    }
                    path = pathItem + '/'+ path;
                }
                return path.replace(/\/+$/, '');
            },
            createScript(src) {
                var node = document.createElement('script');
                node.type = 'text/javascript';
                node.async = true;
                node.src = src;
                return node;
            },
            // 判斷所有依賴是否加載完成
            isDepsDone(options) {
                var { depsTree, entry = depsTree.entry, deps } = options;
                var deps = deps || depsTree[entry].deps;
                var done = true;
                utils.each(deps, function(moduleName) {
                    var dep = depsTree[moduleName];
                    if(dep) {
                        if(dep.deps.length > 0) {
                            done = utils.isDepsDone({
                                depsTree,
                                entry,
                                deps: dep.deps
                            });
                            if(!done) {
                                return false;
                            }
                        }
                    }else {
                        done = false;
                        return false;
                    }
                });
                return done;
            }
        }

        var CustomEvt = function(){
            this.subEvents = {};
        };

        CustomEvt.prototype = {
            constructor:CustomEvt
            ,$emit:function(event,data){
                event = this.subEvents[event];
                if(event){
                    for(let i = 0; i < event.length; i++){
                        event[i].apply(this, data);
                    }
                }
                return this;
            }
            ,$on:function(event,handle){
                let subEvents = this.subEvents;
                !(event in subEvents) && (subEvents[event] = [])
                subEvents[event].push(handle);
                return this;
            }
            ,$off:function(event,handle){
                let events = this.subEvents[event];
                if(!handle){
                    events && Reflect.deleteProperty(this.subEvents, event);
                }else{
                    if(typeof handle == 'function' && events){
                        for(let i = 0,len = events.length; i < len; i++){
                            let event = events[i];
                            if(event == handle){
                                return events.splice(i,1);
                            }
                        } 
                    }
                }
                return this;
            }
        }

        module.CustomEvt = CustomEvt;

        // // 主題對象
        // function Subject() {
        //     this.observers = [];
        // }
        // // 添加觀察者
        // Subject.prototype.addObserver = function(observer) {
        //    !this.observers.includes(observer) && this.addObserver.push(observer);
        // }
        // Subject.prototype.notify = function(message) {
        //     this.observers.forEach(observer => {
        //         observer.update(message);//觀察者接收消息的方法
        //     })
        // }
        // function Observer() {}
        // Observer.prototype.update = function(message) {
        // }

        Object.assign( module.prototype, {
            // 入口函數(shù)
            ready() {
                this.setCtxProxy();
                // 這里默認(rèn)加載同級(jí)目錄下的main.js,請確保main.js的存在
                var script = utils.createScript(this.getUrl('./', this.entry));
                document.body.appendChild(script);
            },
            // 設(shè)置context對象的屬性,通過代理訪問
            setCtxProxy(){
                var _self = this;
                var ctx = this.context;
                utils.each(Object.keys(ctx), function(key) {
                    Object.defineProperty(_self, key, {
                        get: function() {
                            return ctx[key];
                        },
                        set: function(value) {
                            if(ctx[key] !== value) {
                                ctx[key] = value;
                                return true;
                            }
                        }
                    })
                });
            },
            configs(options) {
                Object.assign(this.context, utils.inKeys(options, ['baseUrl', 'alias', 'entry']))
                return this;
            },
            getUrl(baseUrl, moduleName) {
                var path = utils.pathJoin(baseUrl, moduleName);
                return new RegExp('\\'+this.suffix+'$').test(path) ? path : path + this.suffix;
            },
            // 核心方法:define,收集依賴
            define(moduleName, deps, factory) {
                typeof deps == 'function' && (
                    factory = deps,
                    deps = []
                )
                if(!this.deps[moduleName]) {
                    this.deps[moduleName] = {
                        moduleName,
                        deps,
                        factory
                    };
                }
            },
            // 核心方法
            // 迭代收集每一個(gè)入口依賴
            traverseDeps(deps, callback){
                var _self = this;

                function buildDepsRelation(moduleName, depsTree) {
                    var oldDepsTree = depsTree;
                    var module = _self.deps[moduleName];
                    depsTree = depsTree || { entry: moduleName };
                    depsTree[moduleName] = module;
                    if(module.deps.length > 0) {
                        traverseScript(module.deps, depsTree);
                    }else {
                        // 所有依賴收集完,才返回
                        if(utils.isDepsDone({ depsTree })) {
                            typeof callback == 'function' && callback(depsTree);
                        }
                    }
                    // 表示是第一層的遞歸,只重置第一層的遞歸
                    if(!oldDepsTree) {
                        depsTree = null;
                    }
                }

                function traverseScript(deps, depsTree) {
                    utils.each(deps, function(moduleName, i) {
                        var curSrc = _self.getUrl(_self.baseUrl, moduleName);
                        var isExistSrc = _self.srcs.includes(curSrc);
                        // 判斷相同的依賴是否已經(jīng)加載過
                        if(!isExistSrc) {
                            _self.srcs.push(curSrc);
                            var script = utils.createScript(curSrc);
                            script.onload = function() {
                                _self.customEvt.$emit('scriptLoaded', [moduleName])
                                buildDepsRelation(moduleName, depsTree);
                            }
                            document.body.appendChild(script);
                        }else {
                            let curModuleName = moduleName;
                            // 1,依賴已加載完成
                            if(_self.deps[curModuleName]) {
                                buildDepsRelation(moduleName, depsTree);
                            }else {
                                // 2,scriptLoad加載完成后,this.deps才有值
                                _self.customEvt.$on('scriptLoaded', function(moduleName) {
                                    if(moduleName == curModuleName) {
                                        buildDepsRelation(moduleName, depsTree);
                                    }
                                });
                            }
                        }
                    })
                }

                traverseScript(deps)
            },
            // 一次收集全部依賴樹的依賴
            getAllDeps(initDeps, callback) {
                var _self = this;
                function traverseDeps(deps) {
                    utils.each(deps, function(moduleName) {
                        var curSrc = _self.getUrl(_self.baseUrl, moduleName);
                        var isExistSrc = _self.srcs.includes(curSrc);
                        // 判斷相同的依賴是否已經(jīng)加載過
                        if(!isExistSrc) {
                            _self.srcs.push(curSrc);
                            var script = utils.createScript(curSrc);
                            script.onload = function() {
                                var module = _self.deps[moduleName];
                                if(module.deps.length > 0) {
                                    traverseDeps(module.deps);
                                }else {
                                    // 所有依賴收集完,才返回
                                    var isDone = initDeps
                                    .map(entryDep => utils.isDepsDone({ depsTree: _self.deps, entry: entryDep }))
                                    .every(isDone => isDone === true);
                                    if(isDone){
                                        typeof callback == 'function' && callback(_self.deps);
                                    }
                                }
                            }
                            document.body.appendChild(script);
                        }else {
                            // 所有依賴收集完,才返回
                            var isDone = initDeps
                            .map(entryDep => utils.isDepsDone({ depsTree: _self.deps, entry: entryDep }))
                            .every(isDone => isDone === true);
                            if(isDone){
                                typeof callback == 'function' && callback(_self.deps);
                            }
                        }
                    })
                }
                traverseDeps(initDeps)
            },
            require(deps, factory) {
                typeof deps == 'string' && (deps = [deps]);
                // 迭代收集每一個(gè)入口依賴
                this.traverseDeps(deps, function(depsTree) {
                    console.log(depsTree);
                });

                // 一次性收集所有依賴
                // this.getAllDeps(deps, function(alldeps) {
                //     console.log(alldeps)
                // })
            }
        });
        win.module = new module();
    })(this);

源碼鏈接:?https://gitee.com/littleboyck/front/tree/master/front-module


聯(lián)系方式:QQ: 1187253007文章來源地址http://www.zghlxwxcb.cn/news/detail-465997.html

到了這里,關(guān)于23年,我又學(xué)習(xí)了一次amd模塊化,模塊化思想的文章就介紹完了。如果您還想了解更多內(nèi)容,請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章,希望大家以后多多支持TOY模板網(wǎng)!

本文來自互聯(lián)網(wǎng)用戶投稿,該文觀點(diǎn)僅代表作者本人,不代表本站立場。本站僅提供信息存儲(chǔ)空間服務(wù),不擁有所有權(quán),不承擔(dān)相關(guān)法律責(zé)任。如若轉(zhuǎn)載,請注明出處: 如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實(shí)不符,請點(diǎn)擊違法舉報(bào)進(jìn)行投訴反饋,一經(jīng)查實(shí),立即刪除!

領(lǐng)支付寶紅包贊助服務(wù)器費(fèi)用

相關(guān)文章

  • 【Node.js學(xué)習(xí) day4——模塊化】

    【Node.js學(xué)習(xí) day4——模塊化】

    什么是模塊化與模塊? 將一個(gè)復(fù)雜的程序文件依據(jù)一定規(guī)則(規(guī)范)拆分成多個(gè)文件的過程稱之為 模塊化 其中拆分的 每個(gè)文件就是一個(gè)模塊 ,模塊的內(nèi)部數(shù)據(jù)是私有的,不過模塊可以暴露內(nèi)部數(shù)據(jù)以便其他模塊使用。 什么是模塊化項(xiàng)目? 編碼時(shí)是按照模塊一個(gè)一個(gè)編碼的

    2024年01月16日
    瀏覽(50)
  • Android學(xué)習(xí)之路(22) 從模塊化到組件化

    Android學(xué)習(xí)之路(22) 從模塊化到組件化

    Android 應(yīng)用項(xiàng)目 , 都存在一個(gè)應(yīng)用模塊 ( Application Module ) , 在 build.gradle 構(gòu)建腳本中 , 第一個(gè)插件配置 com.android.application , 表明 該 Module 編譯打包后的輸出是 APK 安裝包 ; 該項(xiàng)目可以直接運(yùn)行 ; 如果在 build.gradle 配置的是 com.android.library 插件 , 那么 編譯 Module 打包后輸出的是 a

    2024年01月22日
    瀏覽(24)
  • Node.js 學(xué)習(xí)筆記 fs、path、http模塊;模塊化;包;npm

    Node.js 學(xué)習(xí)筆記 fs、path、http模塊;模塊化;包;npm

    教學(xué)視頻 BV1MN411y7pw , P83-97的筆記 Node.js是一個(gè)跨平臺(tái)JavaScript運(yùn)行環(huán)境,使開發(fā)者可以搭建服務(wù)器端的JavaScript應(yīng)用程序。 作用:使用 Node.js 編寫服務(wù)器端程序 ? 編寫數(shù)據(jù)接口,提供網(wǎng)頁資源瀏覽功能等等 ? 前端工程化:為后續(xù)學(xué)習(xí) Vue 和 React 等框架做鋪墊 1.前端工程化 前

    2024年04月08日
    瀏覽(25)
  • ros2 基礎(chǔ)學(xué)習(xí)16 - RQT:模塊化可視化工具

    ros2 基礎(chǔ)學(xué)習(xí)16 - RQT:模塊化可視化工具

    ROS中的Rviz功能已經(jīng)很強(qiáng)大了,不過有些場景下,我們可能更需要一些簡單的模塊化的可視化工具,比如只顯示一個(gè)攝像頭的圖像,使用Rviz的話,難免會(huì)覺得操作有點(diǎn)麻煩。 此時(shí),我們就會(huì)用到ROS提供的另外一種模塊化可視化工具——rqt。 正如RQT的命名,它和Rviz一樣,也是

    2024年01月21日
    瀏覽(29)
  • 【微信小程序開發(fā)】學(xué)習(xí)小程序的模塊化開發(fā)(自定義組件和分包加載)

    【微信小程序開發(fā)】學(xué)習(xí)小程序的模塊化開發(fā)(自定義組件和分包加載)

    模塊化開發(fā)是一種將復(fù)雜的應(yīng)用程序分解為一系列獨(dú)立的模塊,每個(gè)模塊負(fù)責(zé)完成特定的功能的開發(fā)方式。模塊化開發(fā)可以提高代碼的可維護(hù)性和可復(fù)用性,使開發(fā)過程更加高效和靈活。 模塊化開發(fā)在軟件開發(fā)領(lǐng)域中被廣泛應(yīng)用,其重要性和優(yōu)勢不言而喻。 首先,模塊化開

    2024年02月05日
    瀏覽(75)
  • 前端框架前置課Node.js學(xué)習(xí)(1) fs,path,模塊化,CommonJS標(biāo)準(zhǔn),ECMAScript標(biāo)準(zhǔn),包

    前端框架前置課Node.js學(xué)習(xí)(1) fs,path,模塊化,CommonJS標(biāo)準(zhǔn),ECMAScript標(biāo)準(zhǔn),包

    目錄 什么是Node.js 定義 作用: 什么是前端工程化 Node.js為何能執(zhí)行Js fs模塊-讀寫文件 模塊 語法: 1.加載fs模塊對象 2.寫入文件內(nèi)容 3.讀取文件內(nèi)容 Path模塊-路徑處理 為什么要使用path模塊 語法 URL中的端口號(hào) http模塊-創(chuàng)建Web服務(wù) 需求 步驟: 案例:瀏覽時(shí)鐘 步驟: 什么是模塊化 定

    2024年01月16日
    瀏覽(54)
  • 什么是模塊化?為什么要進(jìn)行模塊化開發(fā)?

    模塊化是一種軟件開發(fā)的設(shè)計(jì)模式,它將一個(gè)大型的軟件系統(tǒng)劃分成多個(gè)獨(dú)立的模塊,每個(gè)模塊都有自己的功能和接口,并且能夠與其他模塊獨(dú)立地工作。 ?先來一段八股文 模塊化開發(fā)可以帶來以下好處: 提高代碼的復(fù)用性:模塊化可以將代碼劃分成可重用的部分,降低代

    2023年04月12日
    瀏覽(32)
  • 【前端模塊化】JS模塊化思想以及相關(guān)規(guī)范(CommonJS、ES module)

    1.模塊化概念 隨著前端應(yīng)用日趨復(fù)雜,項(xiàng)目代碼也大量膨脹,模塊化就是一種最主流的代碼組織方式, 一個(gè)模塊就是一個(gè)實(shí)現(xiàn)特定功能的文件 ,它通過把我們的復(fù)雜代碼按照功能的不同,劃分為不同的模塊單獨(dú)維護(hù)的這種方式,去提高我們的開發(fā)效率,降低維護(hù)成本。要用

    2024年02月01日
    瀏覽(42)
  • 前端進(jìn)階之——模塊化

    前端進(jìn)階之——模塊化

    ? ? ? ? 在做項(xiàng)目的時(shí)候越來越發(fā)現(xiàn)模塊化的重要性,做好模塊化開發(fā)不僅給后期的維護(hù)帶來不少好處而且大大提升項(xiàng)目開發(fā)效率,接下來整理一下模塊化相關(guān)知識(shí)吧。 封裝方法、提高代碼的復(fù)用性、可維護(hù)性和可讀性 隔離作用域,避免污染全局作用域 避免變量沖突 立即執(zhí)

    2024年02月10日
    瀏覽(93)
  • OpenHarmony模塊化編譯

    OpenHarmony模塊化編譯

    OpenHarmony版本:OpenHarmony 4.0 Release 編譯環(huán)境:WSL2 Ubuntu 18.04 平臺(tái)設(shè)備:RK3568 OpenHarmony 代碼構(gòu)建有build.sh和hb兩種方式: 下拉的4.0代碼無法直接使用hb命令 可參考搭建開發(fā)環(huán)境-安裝編譯工具 進(jìn)行hb安裝和環(huán)境配置。 在源碼目錄執(zhí)行\(zhòng)\\"hb help\\\",界面打印以下信息即表示安裝成功。 注

    2024年02月03日
    瀏覽(61)

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請作者喝杯咖啡吧~博客贊助

支付寶掃一掃領(lǐng)取紅包,優(yōu)惠每天領(lǐng)

二維碼1

領(lǐng)取紅包

二維碼2

領(lǐng)紅包