您的位置：首页 > 健康 > 美食 > 施工企业资质新标准2022年10月1日正式实施_网络怎么推广自己的产品_怎么推广一个网站_网店运营与管理

施工企业资质新标准2022年10月1日正式实施_网络怎么推广自己的产品_怎么推广一个网站_网店运营与管理

2025/2/24 23:59:55 来源：https://blog.csdn.net/weixin_40539956/article/details/143261009  浏览:  次   关键词：施工企业资质新标准2022年10月1日正式实施_网络怎么推广自己的产品_怎么推广一个网站_网店运营与管理
施工企业资质新标准2022年10月1日正式实施_网络怎么推广自己的产品_怎么推广一个网站_网店运营与管理

名词（术语）了解–Closure (闭包)

  1. 基本概念

    • 闭包是函数和其周围的词法环境的引用的组合
    • 它允许函数访问并操作函数外部的变量
    • 示例代码：
    function outer() {let count = 0;  // 外部变量return function() {  // 内部函数形成闭包return ++count;}
}
const counter = outer();
console.log(counter()); // 1
console.log(counter()); // 2

  2. 核心特性

    • 词法作用域：闭包会记住它被创建时的环境
    • 数据私有化：可以创建私有变量和方法
    • 状态保持：能够维持函数的内部状态

  3. 主要应用场景

    1. 数据私有化
    // 模块封装
const userModule = (function() {// 私有变量let userName = '';let password = '';return {// 公共方法setUser: function(name, pwd) {userName = name;password = pwd;},getUserName: function() {return userName;}};
})();

    私有化场景扩展介绍

    1. 模块封装场景
    // 实现一个用户信息管理模块
const userModule = (function() {// 私有变量，外部无法直接访问let userName = '';let password = '';let loginAttempts = 0;const MAX_LOGIN_ATTEMPTS = 3;// 私有方法function validatePassword(pwd) {return pwd.length >= 6;}// 返回公共接口return {// 公共方法可以访问私有变量和方法setUser: function(name, pwd) {if (!validatePassword(pwd)) {throw new Error('密码长度不足');}userName = name;password = pwd;},login: function(pwd) {if (loginAttempts >= MAX_LOGIN_ATTEMPTS) {throw new Error('登录尝试次数过多，账户已锁定');}if (pwd !== password) {loginAttempts++;return false;}loginAttempts = 0;return true;},getUserName: function() {return userName;}};
})();
    1. 构造函数私有属性场景
    function BankAccount(initialBalance) {// 私有变量let balance = initialBalance;// 公共方法this.deposit = function(amount) {if (amount > 0) {balance += amount;return `存款成功，当前余额: ${balance}`;}};this.withdraw = function(amount) {if (amount > balance) {return '余额不足';}balance -= amount;return `取款成功，当前余额: ${balance}`;};this.getBalance = function() {return balance;};
}const account = new BankAccount(1000);
console.log(account.getBalance()); // 1000
console.log(account.balance); // undefined，无法直接访问私有变量
    1. 计数器场景
    function createCounter() {let count = 0;  // 私有变量return {increment() {return ++count;},decrement() {return --count;},getCount() {return count;},reset() {count = 0;return count;}};
}const counter = createCounter();
console.log(counter.getCount()); // 0
counter.increment();
console.log(counter.getCount()); // 1
console.log(counter.count); // undefined，无法直接访问私有变量
    1. 缓存管理场景
    function createCache() {const cache = new Map();  // 私有缓存存储return {set(key, value, expireInSeconds = 3600) {cache.set(key, {value,expireAt: Date.now() + (expireInSeconds * 1000)});},get(key) {const data = cache.get(key);if (!data) return null;if (Date.now() > data.expireAt) {cache.delete(key);return null;}return data.value;},clear() {cache.clear();}};
}const cache = createCache();
cache.set('user', {name: 'John'}, 60); // 60秒后过期
console.log(cache.get('user')); // {name: 'John'}
    1. 配置管理场景
    const configManager = (function() {// 私有配置对象const config = {apiKey: null,endpoint: null,timeout: 5000};// 私有方法function validateApiKey(key) {return typeof key === 'string' && key.length > 0;}return {setApiKey(key) {if (!validateApiKey(key)) {throw new Error('Invalid API key');}config.apiKey = key;},setEndpoint(url) {config.endpoint = url;},setTimeout(ms) {config.timeout = ms;},getConfig() {return {...config}; // 返回配置的副本，防止外部修改}};
})();

    使用闭包实现数据私有化的优势：

    1. 安全性

      • 防止外部直接访问和修改内部状态
      • 确保数据只能通过预定义的接口进行操作
      • 避免全局命名空间污染

    2. 封装性

      • 实现了真正的私有属性和方法
      • 提供了清晰的公共接口
      • 隐藏了实现细节

    3. 状态管理

      • 可以维护内部状态
      • 确保状态的一致性
      • 提供受控的状态修改方式

    4. 模块化

      • 实现了模块的独立性
      • 提高了代码的可维护性
      • 便于测试和调试

    使用注意事项：

    1. 内存考虑
      • 闭包会保持对外部变量的引用
      • 需要注意内存泄漏问题
      • 在不需要时及时解除引用
    2. 性能影响
      • 创建闭包有一定的性能开销
      • 避免在循环中创建大量闭包
      • 合理使用闭包数量
    1. 函数工厂
    // 参数预设
function multiply(x) {return function(y) {return x * y;}
}
const multiplyByTwo = multiply(2);
console.log(multiplyByTwo(4)); // 8// 柯里化示例
function curry(fn) {return function curried(...args) {if (args.length >= fn.length) {return fn.apply(this, args);}return function(...args2) {return curried.apply(this, args.concat(args2));}};
}
    1. 回调与异步处理
    // 事件处理
function createButtonHandler(buttonId) {let clickCount = 0;return function() {clickCount++;console.log(`Button ${buttonId} clicked ${clickCount} times`);}
}const handleButton1 = createButtonHandler('btn1');
// 每次点击都会维护自己的 clickCount// Promise中的闭包
function fetchWithRetry(url, retryCount = 3) {return new Promise((resolve, reject) => {function attempt(remainingAttempts) {fetch(url).then(resolve).catch(err => {if (remainingAttempts > 1) {attempt(remainingAttempts - 1);} else {reject(err);}});}attempt(retryCount);});
}
    1. 状态管理
    // 计数器
function createCounter() {let count = 0;return {increment: () => ++count,decrement: () => --count,getCount: () => count};
}// 缓存机制（记忆化）
function memoize(fn) {const cache = {};return function(...args) {const key = JSON.stringify(args);if (!(key in cache)) {cache[key] = fn.apply(this, args);}return cache[key];}
}
    1. 装饰器模式
    // 防抖装饰器
function debounce(fn, delay) {let timer = null;return function(...args) {clearTimeout(timer);timer = setTimeout(() => {fn.apply(this, args);}, delay);}
}// 节流装饰器
function throttle(fn, limit) {let inThrottle = false;return function(...args) {if (!inThrottle) {fn.apply(this, args);inThrottle = true;setTimeout(() => inThrottle = false, limit);}}
}
    1. 迭代器模式
    // 自定义迭代器
function createIterator(array) {let index = 0;return {next: function() {return index < array.length ?{ value: array[index++], done: false } :{ done: true };}};
}// 生成器函数实现
function* numberGenerator() {let num = 1;while(true) {yield num++;}
}

    这些应用场景能体现闭包的强大功能：

    • 封装性：可以创建私有变量和方法
    • 状态保持：能够维护函数的内部状态
    • 灵活性：支持函数式编程范式
    • 模块化：有助于代码组织和维护
    • 性能优化：通过缓存机制提升性能

    使用闭包时需要注意：

    1. 内存管理：闭包会保持对外部变量的引用，注意及时释放
    2. 性能考虑：过度使用闭包可能导致内存占用增加
    3. 作用域链：理解闭包的作用域链，避免意外的变量访问
    4. 上下文绑定：注意this的绑定问题，特别是在回调函数中

  4. 常见应用场景

    • 函数工厂：生成定制化的函数
    function multiply(x) {return function(y) {return x * y;}
}
const multiplyByTwo = multiply(2);
console.log(multiplyByTwo(4)); // 8
    • 模块化：实现模块模式
    const module = (function() {let privateVar = 0;return {increment: function() { privateVar++; },getCount: function() { return privateVar; }};
})();
    • 事件处理和回调：保持对特定数据的访问

  5. 闭包在单例模式中的应用

    1. 单例模式中的应用
    // 1. 基础单例模式
const Singleton = (function() {// 私有变量保存唯一实例let instance;// 私有构造函数function init() {// 私有方法和属性let privateVar = 0;function privateMethod() {return privateVar;}// 公共接口return {publicMethod() {privateVar++;return privateMethod();},getPrivateVar() {return privateVar;}};}// 控制实例化的公共接口return {getInstance() {if (!instance) {instance = init();}return instance;}};
})();// 2. 配置管理器示例
const ConfigManager = (function() {let instance;function createInstance() {// 私有配置对象const config = {apiUrl: '',timeout: 5000,debug: false};return {setConfig(key, value) {if (key in config) {config[key] = value;}},getConfig(key) {return config[key];},getAllConfig() {return {...config};}};}return {getInstance() {if (!instance) {instance = createInstance();}return instance;}};
})();
    1. 模块模式中的应用
    // 1. 基础模块模式
const MyModule = (function() {// 私有变量和方法let privateVar = 'I am private';const privateMethod = function() {return privateVar;};// 公共接口return {publicVar: 'I am public',publicMethod() {return privateMethod();},modifyPrivate(newValue) {privateVar = newValue;}};
})();// 2. 带依赖注入的模块模式
const AdvancedModule = (function($, _) {// 私有变量let data = [];// 私有方法function processData(items) {return _.map(items, item => ({...item, processed: true}));}// 公共接口return {init(initialData) {data = processData(initialData);$(document).trigger('data-ready');},getData() {return [...data];}};
})(jQuery, _);// 3. 可扩展的模块模式
const ExtensibleModule = (function() {// 基础模块const module = {data: [],add(item) {this.data.push(item);},get(id) {return this.data.find(item => item.id === id);}};// 扩展方法return {// 核心模块core: module,// 扩展模块extend(extensions) {Object.assign(module, extensions);}};
})();
    1. 实际应用场景
    // 1. 日志管理器（单例模式）
const Logger = (function() {let instance;function createLogger() {const logs = [];return {log(message) {const timestamp = new Date().toISOString();logs.push({ timestamp, message });console.log(`${timestamp}: ${message}`);},getLogs() {return [...logs];},clearLogs() {logs.length = 0;}};}return {getInstance() {if (!instance) {instance = createLogger();}return instance;}};
})();// 2. API封装（模块模式）
const UserAPI = (function() {// 私有配置const BASE_URL = 'https://api.example.com';const API_KEY = 'your-api-key';// 私有方法async function fetchWithAuth(endpoint, options = {}) {const response = await fetch(`${BASE_URL}${endpoint}`, {...options,headers: {'Authorization': `Bearer ${API_KEY}`,'Content-Type': 'application/json',...options.headers}});return response.json();}// 公共接口return {async getUser(id) {return fetchWithAuth(`/users/${id}`);},async updateUser(id, data) {return fetchWithAuth(`/users/${id}`, {method: 'PUT',body: JSON.stringify(data)});}};
})();// 3. 状态管理（单例 + 模块模式结合）
const Store = (function() {let instance;function createStore(initialState = {}) {let state = {...initialState};const listeners = new Set();function notifyListeners() {listeners.forEach(listener => listener(state));}return {getState() {return {...state};},setState(newState) {state = {...state, ...newState};notifyListeners();},subscribe(listener) {listeners.add(listener);return () => listeners.delete(listener);}};}return {getInstance(initialState) {if (!instance) {instance = createStore(initialState);}return instance;}};
})();
    1. 最佳实践和注意事项
    • 内存管理
    // 正确的内存管理示例
const ModuleWithCleanup = (function() {let heavyResource = null;return {init() {heavyResource = new Array(1000000);},cleanup() {heavyResource = null; // 释放内存}};
})();
    • 模块依赖管理
    // 使用依赖注入管理模块依赖
const MyModule = (function(dependency1, dependency2) {// 使用依赖return {// 模块功能};
})(Dependency1, Dependency2);
    • 错误处理
    const SafeModule = (function() {try {// 模块初始化代码} catch (error) {console.error('Module initialization failed:', error);// 提供降级功能return {isError: true,// 基本功能};}
})();

    这些模式的使用让我们能够：

    1. 实现真正的私有变量和方法
    2. 提供清晰的公共接口
    3. 控制实例的创建和访问
    4. 管理模块的依赖关系
    5. 实现代码的模块化和可维护性

  6. 其他介绍

    1. 闭包实现数据封装和隐藏
    // 基本的数据封装示例
function createCounter() {// 私有变量let count = 0;// 返回包含特权方法的对象return {increment() {return ++count;},decrement() {return --count;},getCount() {return count;}};
}// 使用示例
const counter = createCounter();
console.log(counter.getCount()); // 0
counter.increment();
console.log(counter.getCount()); // 1
// count变量完全被封装，外部无法直接访问
    1. 避免内存泄漏的策略
    // 1. 及时解除引用
function createHeavyObject() {let heavyData = new Array(1000000);return {processData() {// 使用heavyData},cleanup() {heavyData = null; // 手动解除引用}};
}// 2. 避免循环引用
function avoidCircularReference() {let element = document.getElementById('myButton');let heavyData = new Array(1000000);function handleClick() {// 处理点击事件}element.addEventListener('click', handleClick);// 提供清理方法return {cleanup() {element.removeEventListener('click', handleClick);element = null;heavyData = null;}};
}// 3. 使用WeakMap避免内存泄漏
const cache = new WeakMap();function createCacheableObject(key) {if (cache.has(key)) {return cache.get(key);}const obj = {// 对象属性};cache.set(key, obj);return obj;
}
    1. 单例模式实现及优缺点分析
    // 单例模式实现
const Singleton = (function() {let instance;let heavyResource;function init() {// 私有方法和变量heavyResource = new Array(1000000);function privateMethod() {return 'private';}return {publicMethod() {return privateMethod();},getResource() {return heavyResource;},cleanup() {heavyResource = null;}};}return {getInstance() {if (!instance) {instance = init();}return instance;},resetInstance() {if (instance) {instance.cleanup();}instance = null;}};
})();/*
优点：
1. 保证实例唯一性
2. 实现懒加载
3. 提供全局访问点缺点：
1. 常驻内存
2. 单元测试困难
3. 可能隐藏程序依赖
*/
    1. 模块模式实现及优缺点分析
    // 模块模式实现
const Module = (function() {// 私有变量和方法let privateData = [];function privateMethod() {return 'private';}// 缓存DOM查询const elements = {button: document.querySelector('#myButton'),container: document.querySelector('#container')};// 事件处理function handleClick() {// 处理点击}// 初始化模块function init() {elements.button.addEventListener('click', handleClick);}// 清理方法function cleanup() {elements.button.removeEventListener('click', handleClick);privateData = [];Object.keys(elements).forEach(key => {elements[key] = null;});}// 公共APIreturn {init,cleanup,addData(item) {privateData.push(item);},getData() {return [...privateData];}};
})();/*
优点：
1. 良好的命名空间管理
2. 封装私有数据和方法
3. 模块依赖清晰缺点：
1. 扩展性受限
2. 私有成员难以测试
3. 调试相对复杂
*/
    1. 最佳实践和改进建议
    // 1. 使用Symbol实现私有属性
const Module = (function() {const _private = Symbol('private');class ModuleClass {constructor() {this[_private] = {data: []};}getData() {return [...this[_private].data];}}return new ModuleClass();
})();// 2. 使用ES6模块系统
// module.js
const privateData = new WeakMap();export class Module {constructor() {privateData.set(this, {data: []});}getData() {return [...privateData.get(this).data];}
}// 3. 结合装饰器模式
function readonly(target, key, descriptor) {descriptor.writable = false;return descriptor;
}class ModuleWithDecorator {@readonlygetData() {return this._privateData;}
}
    1. 内存管理最佳实践
    // 1. 资源管理器模式
const ResourceManager = (function() {const resources = new WeakMap();return {acquire(key, creator) {if (!resources.has(key)) {resources.set(key, creator());}return resources.get(key);},release(key) {resources.delete(key);}};
})();// 2. 自动清理的计时器管理
const TimerManager = (function() {const timers = new Set();return {setTimeout(callback, delay) {const timer = setTimeout(() => {callback();this.clearTimer(timer);}, delay);timers.add(timer);return timer;},clearTimer(timer) {clearTimeout(timer);timers.delete(timer);},clearAll() {timers.forEach(timer => {clearTimeout(timer);});timers.clear();}};
})();

    总结建议：

    1. 数据封装与隐藏：

      • 使用闭包创建私有作用域
      • 只暴露必要的公共接口
      • 使用WeakMap或Symbol增强私有性

    2. 内存泄漏防护：

      • 及时清理不用的引用
      • 使用弱引用（WeakMap/WeakSet）
      • 提供显式的清理方法
      • 避免循环引用

    3. 模式选择：

      • 单例模式适用于全局状态管理
      • 模块模式适用于功能封装
      • 考虑使用ES6模块系统替代传统模式

    4. 测试与维护：

      • 为私有方法提供测试接口
      • 使用依赖注入提高可测试性
      • 保持良好的文档和注释

  7. 注意事项

    • 要注意内存管理，避免内存泄漏
    • 闭包会占用比普通函数更多的内存
    • 在不需要时，应该解除对闭包的引用

  8. 最佳实践

    // 好的实践：明确的用途
function createLogger(prefix) {return function(msg) {console.log(`${prefix}: ${msg}`);}
}
const errorLogger = createLogger('ERROR');
errorLogger('Something went wrong');// 避免：创建不必要的闭包
for(var i = 0; i < 10; i++) {setTimeout(function() {console.log(i);}, 100);
}

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

最新新闻

热搜词

C/C++后端开发面经 若依护理计划和项目模块思考 泛型的上界通配符和下界通配符 gitLab 2025. 02. 22 CW 模拟赛 D. 送快递 软件架构安全性和保密性设计（3）

声明：本站所有新闻及新闻图片来源于其他网站，如有侵权，请及时联系我们！

客户服务 | 关于我们 | 版权声明

版权所有：

Copyright 2024 尧图网 All Rights Reserved.QQ:809451989