Interested in developing embedded systems? Since they don’t tolerate inefficiency, these systems require a disciplined approach to programming. This easy-to-read guide helps you cultivate a host of good development practices, based on classic software design patterns and new patterns unique to embedded programming. Learn how to build system architecture for processors, not operating systems, and discover specific techniques for dealing with hardware difficulties and manufacturing requirements.Written by an expert who’s created embedded systems ranging from urban surveillance and DNA scanners to children’s toys, this book is ideal for intermediate and experienced programmers, no matter what platform you use.Optimize your system to reduce cost and increase performanceDevelop an architecture that makes your software robust in resource-constrained environmentsExplore sensors, motors, and other I/O devicesDo more with less: reduce RAM consumption, code space, processor cycles, and power consumptionLearn how to update embedded code directly in the processorDiscover how to implement complex mathematics on small processorsUnderstand what interviewers look for when you apply for an embedded systems job'Making Embedded Systems is the book for a C programmer who wants to enter the fun (and lucrative) world of embedded systems. It’s very well written—entertaining, even—and filled with clear illustrations.'—Jack Ganssle, author and embedded system expert.

lgli/Addy & Osmani - JavaScript设计模式（异步图书） (2013, 人民邮电出版社).azw3

zlib/no-category/Addy & Osmani/JavaScript设计模式（异步图书）_16520043.azw3

Learning JavaScript design patterns : [a JavaScript and jQuery developer's guide

Making Embedded Systems : Design Patterns for Great Software

Writing maintainable JavaScript(Chinese Edition)

Bian xie ke wei hu de JavaScript

JavaScript she ji mo shi

编写可维护的JavaScript

Nicholas C. Zakas; 李晶; 郭凯; 张散集

Ao si ma ni, xu tao

(美)NicholasC·Zakas

White, Elecia

Elecia White

Osmani, Addy

(美)奥斯马尼著

扎卡斯

O'Reilly Media, Incorporated Ingram Publisher Services [distributor

The People's Posts and Telecommunications Publishing House

Ren min you dian chu ban she

United States, United States of America

O'Reilly Media, Sebastopol, CA, 2012

Cambridge : LaVergne, Nov. 2011

China, People's Republic, China

1st ed, Sebastopol, CA, 2012

第1版, Bei jing, 2013

1st edition, 2011

August 27, 2012

Beijing, 2011

1, FR, 2011

Bookmarks: p1 (p1): 第一部分 编程风格
p1-1 (p4): 第1章 基本的格式化
p1-1-1 (p4): 1.1 缩进层级
p1-1-2 (p7): 1.2 语句结尾
p1-1-3 (p8): 1.3 行的长度
p1-1-4 (p9): 1.4 换行
p1-1-5 (p10): 1.5 空行
p1-1-6 (p11): 1.6 命名
p1-1-6-1 (p12): 1.6.1 变量和函数
p1-1-6-2 (p13): 1.6.2 常量
p1-1-6-3 (p14): 1.6.3 构造函数
p1-1-7 (p15): 1.7 直接量
p1-1-7-1 (p15): 1.7.1 字符串
p1-1-7-2 (p16): 1.7.2 数字
p1-1-7-3 (p17): 1.7.3 null
p1-1-7-4 (p18): 1.7.4 undefined
p1-1-7-5 (p19): 1.7.5 对象直接量
p1-1-7-6 (p20): 1.7.6 数组直接量
p1-2 (p21): 第2章 注释
p1-2-1 (p21): 2.1 单行注释
p1-2-2 (p23): 2.2 多行注释
p1-2-3 (p24): 2.3 使用注释
p1-2-3-1 (p25): 2.3.1 难于理解的代码
p1-2-3-2 (p26): 2.3.2 能被误认为错误的代码
p1-2-3-3 (p26): 2.3.3 浏览器特性hack
p1-2-4 (p27): 2.4 文档注释
p1-3 (p30): 第3章 语句和表达式
p1-3-1 (p31): 3.1 花括号的对齐方式
p1-3-2 (p32): 3.2 块语句间隔
p1-3-3 (p33): 3.3 switch语句
p1-3-3-1 (p33): 3.3.1 缩进
p1-3-3-2 (p35): 3.3.2 case语句的“连续执行”
p1-3-3-3 (p36): 3.3.3 default
p1-3-4 (p37): 3.4 with语句
p1-3-5 (p37): 3.5 for循环
p1-3-6 (p39): 3.6 for-in循环
p1-4 (p41): 第4章 变量、函数和运算符
p1-4-1 (p41): 4.1 变量声明
p1-4-2 (p44): 4.2 函数声明
p1-4-3 (p45): 4.3 函数调用间隔
p1-4-4 (p46): 4.4 立即调用的函数
p1-4-5 (p47): 4.5 严格模式
p1-4-6 (p49): 4.6 相等
p1-4-6-1 (p51): 4.6.1 eval（）
p1-4-6-2 (p52): 4.6.2 原始包装类型
p2 (p54): 第二部分 编程实践
p2-1 (p55): 第5章 UI层的松耦合
p2-1-1 (p56): 5.1 什么是松耦合
p2-1-2 (p57): 5.2 将JavaScript从CSS中抽离
p2-1-3 (p58): 5.3 将CSS从JavaScript中抽离
p2-1-4 (p60): 5.4 将JavaScript从HTML中抽离
p2-1-5 (p62): 5.5 将HTML从JavaScript中抽离
p2-1-5-1 (p63): 5.5.1 方法1：从服务器加载
p2-1-5-2 (p64): 5.5.2 方法2：简单客户端模板
p2-1-5-3 (p67): 5.5.3 方法3：复杂客户端模板
p2-2 (p70): 第6章 避免使用全局变量
p2-2-1 (p70): 6.1 全局变量带来的问题
p2-2-1-1 (p71): 6.1.1 命名冲突
p2-2-1-2 (p71): 6.1.2 代码的脆弱性
p2-2-1-3 (p72): 6.1.3 难以测试
p2-2-2 (p72): 6.2 意外的全局变量
p2-2-2-1 (p73): 避免意外的全局变量
p2-2-3 (p74): 6.3 单全局变量方式
p2-2-3-1 (p76): 6.3.1 命名空间
p2-2-3-2 (p78): 6.3.2 模块
p2-2-4 (p81): 6.4 零全局变量
p2-3 (p83): 第7章 事件处理
p2-3-1 (p83): 7.1 典型用法
p2-3-2 (p84): 7.2 规则1：隔离应用逻辑
p2-3-3 (p85): 7.3 规则2：不要分发事件对象
p2-4 (p88): 第8章 避免“空比较”
p2-4-1 (p88): 8.1 检测原始值
p2-4-2 (p90): 8.2 检测引用值
p2-4-2-1 (p92): 8.2.1 检测函数
p2-4-2-2 (p94): 8.2.2 检测数组
p2-4-3 (p95): 8.3 检测属性
p2-5 (p98): 第9章 将配置数据从代码中分离出来
p2-5-1 (p98): 9.1 什么是配置数据
p2-5-2 (p99): 9.2 抽离配置数据
p2-5-3 (p100): 9.3 保存配置数据
p2-6 (p103): 第10章 抛出自定义错误
p2-6-1 (p103): 10.1 错误的本质
p2-6-2 (p104): 10.2 在JavaScript中抛出错误
p2-6-3 (p105): 10.3 抛出错误的好处
p2-6-4 (p106): 10.4 何时抛出错误
p2-6-5 (p107): 10.5 try-catch语句
p2-6-6 (p109): 10.6 错误类型
p2-7 (p112): 第11章 不是你的对象不要动
p2-7-1 (p112): 11.1 什么是你的
p2-7-2 (p113): 11.2 原则
p2-7-2-1 (p113): 11.2.1 不覆盖方法
p2-7-2-2 (p114): 11.2.2 不新增方法
p2-7-2-3 (p116): 11.2.3 不删除方法
p2-7-3 (p117): 11.3 更好的途径
p2-7-3-1 (p118): 11.3.1 基于对象的继承
p2-7-3-2 (p119): 11.3.2 基于类型的继承
p2-7-3-3 (p120): 11.3.3 门面模式
p2-7-4 (p121): 11.4 关于Polyfill的注解
p2-7-5 (p122): 11.5 阻止修改
p2-8 (p125): 第12章 浏览器嗅探
p2-8-1 (p125): 12.1 User-Agent检测
p2-8-2 (p127): 12.2 特性检测
p2-8-3 (p129): 12.3 避免特性推断
p2-8-4 (p130): 12.4 避免浏览器推断
p2-8-5 (p134): 12.5 应当如何取舍
p3 (p135): 第三部分 自动化
p3-1 (p137): 第13章 文件和目录结构
p3-1-1 (p137): 13.1 最佳实践
p3-1-2 (p138): 13.2 基本结构
p3-2 (p143): 第14章 Ant
p3-2-1 (p143): 14.1 安装
p3-2-2 (p143): 14.2 配置文件
p3-2-3 (p145): 14.3 执行构建
p3-2-4 (p145): 14.4 目标操作的依赖
p3-2-5 (p146): 14.5 属性
p3-2-6 (p148): 14.6 Buildr项目
p3-3 (p149): 第15章 校验
p3-3-1 (p149): 15.1 查找文件
p3-3-2 (p150): 15.2 任务
p3-3-3 (p152): 15.3 增强的目标操作
p3-3-4 (p153): 15.4 其他方面的改进
p3-3-5 (p154): 15.5 Buildr任务
p3-4 (p156): 第16章 文件合并和加工
p3-4-1 (p156): 16.1 任务
p3-4-2 (p157): 16.2 行尾结束符
p3-4-3 (p158): 16.3 文件头和文件尾
p3-4-4 (p159): 16.4 加工文件
p3-5 (p163): 第17章 文件精简和压缩
p3-5-1 (p163): 17.1 文件精简
p3-5-1-1 (p165): 17.1.1 使用YUI Compressor精简代码
p3-5-1-2 (p167): 17.1.2 用Closure Compiler精简
p3-5-1-3 (p169): 17.1.3 使用UglifyJS精简
p3-5-2 (p170): 17.2 压缩
p3-5-2-1 (p171): 17.2.1 运行时压缩
p3-5-2-2 (p171): 17.2.2 构建时压缩
p3-6 (p175): 第18章 文档化
p3-6-1 (p175): 18.1 JSDoc Toolkit
p3-6-2 (p177): 18.2 YUI Doc
p3-7 (p180): 第19章 自动化测试
p3-7-1 (p180): 19.1 YUI Test Selenium引擎
p3-7-1-1 (p181): 19.1.1 配置一台Selenium服务器
p3-7-1-2 (p181): 19.1.2 配置YUI Test Selenium引擎
p3-7-1-3 (p181): 19.1.3 使用YUI Test Selenium引擎
p3-7-1-4 (p183): 19.1.4 Ant的配置写法
p3-7-2 (p184): 19.2 Yeti
p3-7-3 (p186): 19.3 PhantomJS
p3-7-3-1 (p186): 19.3.1 安装及使用
p3-7-3-2 (p187): 19.3.2 Ant的配置写法
p3-7-4 (p188): 19.4 JsTestDriver
p3-7-4-1 (p188): 19.4.1 安装及使用
p3-7-4-2 (p189): 19.4.2 Ant的配置写法
p3-8 (p191): 第20章 组装到一起
p3-8-1 (p191): 20.1 被忽略的细节
p3-8-2 (p192): 20.2 编制打包计划
p3-8-2-1 (p193): 20.2.1 开发版本的构建
p3-8-2-2 (p194): 20.2.2 集成版本的构建
p3-8-2-3 (p195): 20.2.3 发布版本的构建
p3-8-3 (p196): 20.3 使用CI系统
p3-8-3-1 (p196): 20.3.1 Jenkins
p3-8-3-2 (p199): 20.3.2 其他CI系统
p4 (p200): 附录A JavaScript编码风格指南
p5 (p223): 附录B JavaScript工具集

Bookmarks: p1 (p1): 第1章 介绍
p2 (p3): 第2章 什么是模式
p2-1 (p4): 我们每天都在使用模式
p3 (p6): 第3章 模式状态测试、Proto模式及三法则
p4 (p8): 第4章 设计模式的结构
p5 (p11): 第5章 编写设计模式
p6 (p13): 第6章 反模式
p7 (p15): 第7章 设计模式类别
p8 (p17): 第8章 设计模式分类
p8-1 (p17): 有关类（Class）的要点
p9 (p20): 第9章 JavaScript设计模式
p9-1 (p21): 9.1 Constructor（构造器）模式
p9-1-1 (p21): 9.1.1 对象创建
p9-1-2 (p23): 9.1.2 基本Constructor（构造器）
p9-1-3 (p24): 9.1.3 带原型的Constructor（构造器）
p9-2 (p25): 9.2 Module（模块）模式
p9-2-1 (p25): 9.2.1 对象字面量
p9-2-2 (p27): 9.2.2 Module（模块）模式
p9-2-3 (p31): 9.2.3 Module模式变化
p9-3 (p36): 9.3 RevealingModule（揭示模块）模式
p9-3-1 (p38): 9.3.1 优点
p9-3-2 (p38): 9.3.2 缺点
p9-4 (p38): 9.4 Singleton（单例）模式
p9-5 (p42): 9.5 Observer（观察者）模式
p9-5-1 (p47): 9.5.1 Observer（观察者）模式和Publish/Subscribe（发布／订阅）模式的区别
p9-5-2 (p49): 9.5.2 优点
p9-5-3 (p49): 9.5.3 缺点
p9-5-4 (p49): 9.5.4 Publish/Subscribe实现
p9-6 (p59): 9.6 Mediator（中介者）模式
p9-6-1 (p60): 9.6.1 基本实现
p9-6-2 (p61): 9.6.2 高级实现
p9-6-3 (p67): 9.6.3 示例
p9-6-4 (p68): 9.6.4 优点和缺点
p9-6-5 (p69): 9.6.5 中介者（Mediator）与观察者（Observer）
p9-6-6 (p69): 9.6.6 中介者（Mediator）与外观（Facade）
p9-7 (p70): 9.7 Prototype（原型）模式
p9-8 (p73): 9.8 Command（命令）模式
p9-9 (p75): 9.9 Facade（外观）模式
p9-9-1 (p78): 有关抽象的要点
p9-10 (p78): 9.10 Factory（工厂）模式
p9-10-1 (p81): 9.10.1 何时使用Factory模式
p9-10-2 (p81): 9.10.2 何时不应使用Factory模式
p9-10-3 (p81): 9.10.3 Abstract Factory（抽象工厂）
p9-11 (p82): 9.11 Mixin模式
p9-11-1 (p83): 9.11.1 子类化
p9-11-2 (p84): 9.11.2 Mixin（混入）
p9-12 (p88): 9.12 Decorator（装饰者）模式
p9-12-1 (p91): 9.12.1 伪经典Decorator（装饰者）
p9-12-2 (p96): 9.12.2 使用jQuery的装饰者
p9-12-3 (p97): 9.12.3 优点和缺点
p9-13 (p98): 9.13 Flyweight（享元）模式
p9-13-1 (p98): 9.13.1 使用Flyweight模式
p9-13-2 (p99): 9.13.2 Flyweight和共享数据
p9-13-3 (p99): 9.13.3 实现经典Flyweight（享元）
p9-13-4 (p103): 9.13.4 转换代码以使用Flyweight（享元）模式
p9-13-5 (p105): 9.13.5 基本工厂
p9-13-6 (p106): 9.13.6 管理外部状态
p9-13-7 (p107): 9.13.7 Flyweight（享元）模式和DOM
p10 (p112): 第10章 JavaScript MV＊模式
p10-1 (p112): 10.1 MVC
p10-1-1 (p113): Smalltalk-80 MVC
p10-2 (p114): 10.2 为JavaScript开发人员提供的MVC
p10-2-1 (p114): 10.2.1 Model（模型）
p10-2-2 (p116): 10.2.2 View（视图）
p10-2-3 (p119): 10.2.3 Controller（控制器）
p10-2-4 (p120): 10.2.4 Spine.js与Backbone.js
p10-3 (p122): 10.3 MVC为我们提供了什么
p10-4 (p122): 10.4 JavaScript中的Smalltalk-80 MVC
p10-4-1 (p123): 10.4.1 深入挖掘
p10-4-2 (p123): 10.4.2 总结
p10-5 (p124): 10.5 MVP
p10-5-1 (p124): 10.5.1 Model、View和Presenter
p10-5-2 (p125): 10.5.2 MVP或MVC？
p10-5-3 (p126): 10.5.3 MVC、MVP和Backbone.js
p10-6 (p128): 10.6 MVVM
p10-6-1 (p129): 10.6.1 历史
p10-6-2 (p129): 10.6.2 Model
p10-6-3 (p130): 10.6.3 View
p10-6-4 (p133): 10.6.4 ViewModel
p10-6-5 (p135): 10.6.5 小结：View和ViewModel
p10-6-6 (p135): 10.6.6 小结：ViewModel和Model
p10-7 (p135): 10.7 利与弊
p10-7-1 (p135): 10.7.1 优点
p10-7-2 (p136): 10.7.2 缺点
p10-8 (p136): 10.8 使用更松散数据绑定的MVVM
p10-9 (p141): 10.9 MVC、MVP与MVVM
p10-9-1 (p142): 10.10 Backbone.js与KnockoutJS
p11 (p144): 第11章 模块化的JavaScript设计模式
p11-1 (p145): 11.1 脚本加载器要点
p11-2 (p145): 11.2 AMD
p11-2-1 (p146): 11.2.1 模块入门
p11-2-2 (p150): 11.2.2 使用Dojo的AMD模块
p11-2-3 (p151): 11.2.3 AMD模块设计模式（Dojo）
p11-2-4 (p152): 11.2.4 使用jQuery的AMD模块
p11-2-5 (p155): 11.2.5 AMD总结
p11-3 (p155): 11.3 CommonJS
p11-3-1 (p156): 11.3.1 入门指南
p11-3-2 (p157): 11.3.2 使用多个依赖
p11-3-3 (p158): 11.3.3 支持CommonJS的加载器和框架
p11-3-4 (p158): 11.3.4 CommonJS适用于浏览器吗？
p11-3-5 (p159): 11.3.5 延伸阅读
p11-4 (p159): 11.4 AMD和CommonJS：互相竞争，标准同效
p11-4-1 (p160): UMD：用于插件的AMD和CommonJS兼容模块
p11-5 (p165): 11.5 ES Harmony
p11-5-1 (p166): 11.5.1 具有Imports和Exports的模块
p11-5-2 (p167): 11.5.2 从远程数据源加载的模块
p11-5-3 (p167): 11.5.3 模块加载器API
p11-5-4 (p168): 11.5.4 用于服务器的类CommonJS模块
p11-5-5 (p168): 11.5.5 具有构造函数、getter和setter的类
p11-5-6 (p169): 11.5.6 ES Harmony总结
p11-5-7 (p170): 11.5.7 延伸阅读
p11-6 (p170): 11.6 总结
p12 (p171): 第12章 jQuery中的设计模式
p12-1 (p171): 12.1 Composite（组合）模式
p12-2 (p173): 12.2 Adapter（适配器）模式
p12-3 (p174): 12.3 Facade（外观）模式
p12-4 (p177): 12.4 Observer（观察者）模式
p12-5 (p180): 12.5 Iterator（迭代器）模式
p12-6 (p181): 12.6 延迟初始化
p12-7 (p183): 12.7 Proxy（代理）模式
p12-8 (p184): 12.8 Builder（生成器）模式
p13 (p187): 第13章 jQuery插件设计模式
p13-1 (p188): 13.1 模式
p13-2 (p189): 13.2 Lightweight Start模式
p13-2-1 (p191): 延伸阅读
p13-3 (p191): 13.3 完整的Widget Factory模式
p13-3-1 (p194): 延伸阅读
p13-4 (p194): 13.4 嵌套命名空间插件模式
p13-4-1 (p196): 延伸阅读
p13-5 (p196): 13.5 自定义事件插件模式（使用Widget Factory）
p13-5-1 (p198): 延伸阅读
p13-6 (p198): 13.6 使用DOM-to-Object Bridge模式的原型继承
p13-6-1 (p200): 延伸阅读
p13-7 (p200): 13.7 jQueryUI Widget Factory Bridge模式
p13-7-1 (p203): 延伸阅读
p13-8 (p203): 13.8 使用Widget Factory的jQuery Mobile Widget
p13-9 (p206): 13.9 RequireJS和jQuery UI WidgetFactory
p13-9-1 (p208): 13.9.1 用法
p13-9-2 (p209): 13.9.2 延伸阅读
p13-10 (p209): 13.10 全局选项和单次调用可重写选项（最佳选项模式）
p13-10-1 (p211): 延伸阅读
p13-11 (p211): 13.11 高可配和高可变的插件模式
p13-11-1 (p213): 延伸阅读
p13-12 (p213): 13.12 是什么使插件超越模式
p13-12-1 (p214): 13.12.1 质量
p13-12-2 (p214): 13.12.2 代码风格
p13-12-3 (p214): 13.12.3 兼容性
p13-12-4 (p214): 13.12.4 可靠性
p13-12-5 (p214): 13.12.5 性能
p13-12-6 (p215): 13.12.6 文档
p13-12-7 (p215): 13.12.7 维护的可能性
p13-13 (p215): 13.13 总结
p13-14 (p215): 13.14 命名空间模式
p13-15 (p216): 13.15 命名空间基础
p13-15-1 (p216): 13.15.1 单一全局变量
p13-15-2 (p217): 13.15.2 命名空间前缀
p13-15-3 (p217): 13.15.3 对象字面量表示法
p13-15-4 (p221): 13.15.4 嵌套命名空间
p13-15-5 (p222): 13.15.5 立即调用的函数表达式（IIFE）
p13-15-6 (p224): 13.15.6 命名空间注入
p13-16 (p226): 13.16 高级命名空间模式
p13-16-1 (p227): 13.16.1 自动嵌套的命名空间
p13-16-2 (p229): 13.16.2 依赖声明模式
p13-16-3 (p229): 13.16.3 深度对象扩展
p13-16-4 (p232): 13.16.4 推荐
p14 (p233): 第14章 总结
p15 (p235): 附录 参考文献

Interested in developing embedded systems? Since they don’t tolerate inefficiency, these systems require a disciplined approach to programming. This easy-to-read guide helps you cultivate a host of good development practices, based on classic software design patterns and new patterns unique to embedded programming. Learn how to build system architecture for processors, not operating systems, and discover specific techniques for dealing with hardware difficulties and manufacturing requirements. Written by an expert who’s created embedded systems ranging from urban surveillance and DNA scanners to children’s toys, this book is ideal for intermediate and experienced programmers, no matter what platform you use. * Optimize your system to reduce cost and increase performance * Develop an architecture that makes your software robust in resource-constrained environments * Explore sensors, motors, and other I/O devices * Do more with less: reduce RAM consumption, code space, processor cycles, and power consumption * Learn how to update embedded code directly in the processor * Discover how to implement complex mathematics on small processors * Understand what interviewers look for when you apply for an embedded systems job "Making Embedded Systems is the book for a C programmer who wants to enter the fun (and lucrative) world of embedded systems. It’s very well written—entertaining, even—and filled with clear illustrations." —Jack Ganssle, author and embedded system expert.

Annotation Interested in developing embedded systems? Since they dont tolerate inefficiency, these systems require a disciplined approach to programming. This easy-to-read guide helps you cultivate a host of good development practices, based on classic software design patterns and new patterns unique to embedded programming. Learn how to build system architecture for processors, not operating systems, and discover specific techniques for dealing with hardware difficulties and manufacturing requirements. Written by an expert whos created embedded systems ranging from urban surveillance and DNA scanners to childrens toys, this book is ideal for intermediate and experienced programmers, no matter what platform you use. Optimize your system to reduce cost and increase performanceDevelop an architecture that makes your software robust in resource-constrained environmentsExplore sensors, motors, and other I/O devicesDo more with less: reduce RAM consumption, code space, processor cycles, and power consumptionLearn how to update embedded code directly in the processorDiscover how to implement complex mathematics on small processorsUnderstand what interviewers look for when you apply for an embedded systems job"Making Embedded Systems is the book for a C programmer who wants to enter the fun (and lucrative) world of embedded systems. Its very well writtenentertaining, evenand filled with clear illustrations."Jack Ganssle, author and embedded system expert

With Learning JavaScript Design Patterns, you’ll learn how to write beautiful, structured, and maintainable JavaScript by applying classical and modern design patterns to the language. If you want to keep your code efficient, more manageable, and up-to-date with the latest best practices, this book is for you.Explore many popular design patterns, including Modules, Observers, Facades, and Mediators. Learn how modern architectural patterns—such as MVC, MVP, and MVVM—are useful from the perspective of a modern web application developer. This book also walks experienced JavaScript developers through modern module formats, how to namespace code effectively, and other essential topics.Learn the structure of design patterns and how they are writtenUnderstand different pattern categories, including creational, structural, and behavioralWalk through more than 20 classical and modern design patterns in JavaScriptUse several options for writing modular code—including the Module pattern, Asyncronous Module Definition (AMD), and CommonJSDiscover design patterns implemented in the jQuery libraryLearn popular design patterns for writing maintainable jQuery plug-ins'This book should be in every JavaScript developer’s hands. It’s the go-to book on JavaScript patterns that will be read and referenced many times in the future.'—Andrée Hansson, Lead Front-End Developer, presis!

With Learning JavaScript Design Patterns, you'll learn how to write beautiful, structured, and maintainable JavaScript by applying classical and modern design patterns to the language. If you want to keep your code efficient, more manageable, and up-to-date with the latest best practices, this book is for you.Explore many popular design patterns, including Modules, Observers, Facades, and Mediators. Learn how modern architectural patterns—such as MVC, MVP, and MVVM—are useful from the perspective of a modern web application developer. This book also walks experienced JavaScript developers through modern module formats, how to namespace code effectively, and other essential topics.Learn the structure of design patterns and how they are writtenUnderstand different pattern categories, including creational, structural, and behavioralWalk through more than 20 classical and modern design patterns in JavaScriptUse several options for writing modular code—including the Module pattern, Asyncronous Module Definition (AMD), and CommonJSDiscover design patterns implemented in the jQuery libraryLearn popular design patterns for writing maintainable jQuery plug-ins'This book should be in every JavaScript developer's hands. It's the go-to book on JavaScript patterns that will be read and referenced many times in the future.'—Andrée Hansson, Lead Front-End Developer, presis!

"Explore many popular design patterns, including Modules, Observers, Facades, and Mediators. Learn how modern architectural patterns--such as MVC, MVP, and MVVM--are useful from the perspective of a modern web application developer. This book also walks you through modern module formats, how to namespace code effectively, and other essential topics: Learn the structure of design patterns and how they are written; Understand different pattern categories, including creational, structural, and behavioral; Walk through more than 20 classical and modern design patterns in JavaScript; Use several options for writing modular code--including the Module pattern, Asyncronous Module Definition (AMD), and CommonJS; Discover design patterns implemented in the jQuery library; Learn popular design patterns for writing maintainable jQuery plug-ins."--Publisher description

Ben shu fen wei 14 zhang. Shou xian jie shao le shen me shi mo shi, Mo shi de jie gou, Lei bie, Mo shi de fen lei, Ru he bian xie mo shi deng deng;Ran hou, Ji zhong jie shao le hen duo liu xing de she ji mo shi zai JavaScript zhong de ying yong, Bao kuo Module(mo kuai)Mo shi, Observer(guan cha zhe)Mo shi, Facade(wai guan)Mo shi he Mediator(zhong jie zhe)Mo shi;Zui hou, Hai tan tao le mo kuai hua de JavaScript mo shi, jQuery ji qi cha jian zhong de she ji mo shi.

If you want to write beautiful, structured, and maintainable JavaScript code, this guide shows you how to apply both classical and modern design patterns to the language. You'll explore several popular design patterns in plain JavaScript as well as jQuery and other abstracted libraries.

本书分为14章.首先介绍了什么是模式,模式的结构,类别,模式的分类,如何编写模式等等;然后,集中介绍了很多流行的设计模式在JavaScript中的应用,包括Module(模块)模式,Observer(观察者)模式,Facade(外观)模式和Mediator(中介者)模式;最后,还探讨了模块化的JavaScript模式,jQuery及其插件中的设计模式

本书阐述了如何在团队开发中编写具备高可维护性的JavaScript代码,书中详细说明了作为团队一分子,应该怎么写JavaScript.书中内容涵盖了编码风格,编程技巧,自动化,测试等几方面,既包括具体风格和原则的介绍,也包括示例和技巧说明,最后还介绍了如何通过自动化的工具和方法来实现一致的编程风格

2021-06-27