Julia设计模式电子书

关于本书

序言

前言

本书的读者对象

本书结构

如何充分利用本书

下载示例代码

排版约定

作者简介

译者简介

审校者简介

第一部分 从设计模式开始

第1章 设计模式和相关原则

1.1 设计模式的历史

1.1.1 设计模式的兴起

1.1.2 关于GoF模式的更多思考

1.1.3 在本书中我们如何描述设计模式

1.2 软件设计原则

1.2.1 SOLID原则

1.2.2 DRY原则

1.2.3 KISS原则

1.2.4 POLA原则

1.2.5 YAGNI原则

1.2.6 POLP原则

1.3 软件质量目标

1.3.1 可重用性

1.3.2 性能

1.3.3 可维护性

1.3.4 安全性

1.4 小结

1.5 问题

第二部分 Julia基础

第2章 模块、包和数据类型

2.1 技术要求

2.2 程序开发中不断增长的痛点

2.2.1 数据科学项目

2.2.2 企业应用程序

2.2.3 适应增长

2.3 使用命名空间、模块和包

2.3.1 理解命名空间

2.3.2 创建模块和包

2.3.3 创建子模块

2.3.4 在模块中管理文件

2.4 管理包的依赖关系

2.4.1 理解语义版本控制方案

2.4.2 指定Julia包的依赖关系

2.4.3 避免循环依赖

2.5 设计抽象类型和具体类型

2.5.1 设计抽象类型

2.5.2 设计具体类型

2.5.3 使用类型运算符

2.5.4 抽象类型和具体类型的差异

2.6 使用参数化类型

2.6.1 使用参数化复合类型

2.6.2 使用参数化抽象类型

2.7 数据类型转换

2.7.1 执行简单的数据类型转换

2.7.2 注意有损转换

2.7.3 理解数字类型转换

2.7.4 重温自动转换规则

2.7.5 理解函数分派规则

2.8 小结

2.9 问题

第3章 设计函数和接口

3.1 技术要求

3.2 设计函数

3.2.1 用例——太空战争游戏

3.2.2 定义函数

3.2.3 注释函数参数

3.2.4 使用可选参数

3.2.5 使用关键字参数

3.2.6 接受可变数量的参数

3.2.7 splatting参数

3.2.8 第一类实体函数

3.2.9 开发匿名函数

3.2.10 使用do语法

3.3 理解多重分派

3.3.1 什么是分派

3.3.2 匹配最窄类型

3.3.3 分派多个参数

3.3.4 分派过程中可能存在的歧义

3.3.5 歧义检测

3.3.6 理解动态分派

3.4 利用参数化方法

3.4.1 使用类型参数

3.4.2 使用类型参数替换抽象类型

3.4.3 在使用参数时强制类型一致性

3.4.4 从方法签名中提取类型信息

3.5 使用接口

3.5.1 设计和开发接口

3.5.2 处理软契约

3.5.3 使用特质

3.6 小结

3.7 问题

第4章 宏和元编程

4.1 技术要求

4.2 理解元编程的需求

4.2.1 使用@time宏测量性能

4.2.2 循环展开

4.3 使用表达式

4.3.1 试用解析器

4.3.2 手动构造表达式对象

4.3.3 尝试更复杂的表达式

4.3.4 计算表达式

4.3.5 在表达式中插入变量

4.3.6 对符号使用QuoteNode

4.3.7 在嵌套表达式中插值

4.4 开发宏

4.4.1 什么是宏

4.4.2 编写第一个宏

4.4.3 传递字面量参数

4.4.4 传递表达式参数

4.4.5 理解宏扩展过程

4.4.6 操作表达式

4.4.7 理解卫生宏

4.4.8 开发非标准字符串字面量

4.5 使用生成函数

4.5.1 定义生成函数

4.5.2 检查生成函数参数

4.6 小结

4.7 问题

第三部分 实现设计模式

第5章 可重用模式

5.1 技术要求

5.2 委托模式

5.2.1 在银行用例中应用委托模式

5.2.2 现实生活中的例子

5.2.3 注意事项

5.3 Holy Traits模式

5.3.1 重温个人资产管理用例

5.3.2 实现Holy Traits模式

5.3.3 重温一些常见用法

5.3.4 使用SimpleTraits.jl包

5.4 参数化类型模式

5.4.1 在股票交易应用程序中使用删除文本参数化类型

5.4.2 现实生活中的例子

5.5 小结

5.6 问题

第6章 性能模式

6.1 技术要求

6.2 全局常量模式

6.2.1 使用全局变量对性能进行基准测试

6.2.2 享受全局常量的速度

6.2.3 使用类型信息注释变量

6.2.4 理解常量为何有助于性能

6.2.5 将全局变量作为函数参数传递

6.2.6 将变量隐藏在全局常量中

6.2.7 现实生活中的例子

6.2.8 注意事项

6.3 数组结构模式

6.3.1 使用业务领域模型

6.3.2 使用不同的数据布局提高性能

6.3.3 注意事项

6.4 共享数组模式

6.4.1 风险管理用例介绍

6.4.2 准备示例数据

6.4.3 高性能解决方案概述

6.4.4 在共享数组中填充数据

6.4.5 直接在共享数组上分析数据

6.4.6 理解并行处理的开销

6.4.7 配置共享内存使用情况

6.4.8 确保工作进程可以访问代码和数据

6.4.9 避免并行进程之间的竞态

6.4.10 使用共享数组的约束

6.5 记忆模式

6.5.1 斐波那契函数介绍

6.5.2 改善斐波那契函数的性能

6.5.3 自动化构造记忆缓存

6.5.4 理解泛型函数的约束

6.5.5 支持具有多个参数的函数

6.5.6 处理参数中的可变数据类型

6.5.7 使用宏来记忆泛型函数

6.5.8 现实生活中的例子

6.5.9 注意事项

6.5.10 使用Caching.jl包

6.6 闸函数模式

6.6.1 识别类型不稳定的函数

6.6.2 理解性能影响

6.6.3 开发闸函数

6.6.4 处理类型不稳定的输出变量

6.6.5 使用@inferred宏

6.7 小结

6.8 问题

第7章 可维护性模式

7.1 技术要求

7.2 子模块模式

7.2.1 理解何时需要子模块

7.2.2 理解传入耦合与传出耦合

7.2.3 管理子模块

7.2.4 在模块和子模块之间引用符号和函数

7.2.5 删除双向耦合

7.2.6 考虑拆分为顶层模块

7.2.7 理解使用子模块的反论点

7.3 关键字定义模式

7.3.1 重温结构定义和构造函数

7.3.2 在构造函数中使用关键字参数

7.3.3 使用@kwdef宏简化代码

7.4 代码生成模式

7.4.1 文件日志记录器用例介绍

7.4.2 函数定义的代码生成

7.4.3 调试代码生成

7.4.4 考虑代码生成以外的选项

7.5 领域特定语言模式

7.5.1 L系统介绍

7.5.2 为L系统设计DSL

7.5.3 重温L系统核心逻辑

7.5.4 实现L系统的DSL

7.6 小结

7.7 问题

第8章 鲁棒性模式

8.1 技术要求

8.2 访问器模式

8.2.1 识别对象的隐式接口

8.2.2 实现getter函数

8.2.3 实现setter函数

8.2.4 禁止直接访问字段

8.3 属性模式

8.3.1 延迟文件加载器介绍

8.3.2 理解用于字段访问的点符号

8.3.3 实现读取访问和延迟加载

8.3.4 控制对对象字段的写入访问

8.3.5 报告可访问字段

8.4 let块模式

8.4.1 网络爬虫用例介绍

8.4.2 使用闭包将私有变量和函数隐藏起来

8.4.3 限制长脚本或函数的变量范围

8.5 异常处理模式

8.5.1 捕捉和处理异常

8.5.2 处理各种类型的异常

8.5.3 在顶层处理异常

8.5.4 跟随栈帧

8.5.5 理解异常处理对性能的影响

8.5.6 重试操作

8.5.7 异常时选用nothing

8.6 小结

8.7 问题

第9章 其他模式

9.1 技术要求

9.2 单例类型分派模式

9.2.1 开发命令处理器

9.2.2 理解单例类型

9.2.3 使用Val参数化数据类型

9.2.4 使用单例类型进行动态分派

9.2.5 理解分派的性能优势

9.3 打桩/模拟模式

9.3.1 什么是测试替身

9.3.2 信贷审批用例介绍

9.3.3 使用打桩执行状态验证

9.3.4 使用Mocking包实现打桩

9.3.5 将多个打桩应用于同一函数

9.3.6 使用模拟执行行为验证

9.4 函数管道模式

9.4.1 Hacker News分析用例介绍

9.4.2 理解函数管道

9.4.3 设计可组合函数

9.4.4 为平均得分函数开发函数管道

9.4.5 在函数管道中实现条件逻辑

9.4.6 沿函数管道进行广播

9.4.7 有关使用函数管道的注意事项

9.5 小结

9.6 问题

第10章 反模式

10.1 技术要求

10.2 海盗反模式

10.2.1 Ⅰ类海盗——重新定义函数

10.2.2 Ⅱ类海盗——不用自己的类型扩展

10.2.3 Ⅲ类海盗——用自己的类型扩展，但目的不同

10.3 窄参数类型反模式

10.3.1 考虑参数类型的多种选项

10.3.2 评估性能

10.4 非具体字段类型反模式

10.4.1 理解复合数据类型的内存布局

10.4.2 设计复合类型时要考虑具体类型

10.4.3 比较具体字段类型和非具体字段类型的性能

10.5 小结

10.6 问题

第11章 传统的面向对象模式

11.1 技术要求

11.2 创建型模式

11.2.1 工厂方法模式

11.2.2 抽象工厂模式

11.2.3 单例模式

11.2.4 建造者模式

11.2.5 原型模式

11.3 行为型模式

11.3.1 责任链模式

11.3.2 中介者模式

11.3.3 备忘录模式

11.3.4 观察者模式

11.3.5 状态模式

11.3.6 策略模式

11.3.7 模板方法模式

11.3.8 命令模式、解释器模式、迭代器模式和访问者模式

11.4 结构型模式

11.4.1 适配器模式

11.4.2 组合模式

11.4.3 享元模式

11.4.4 桥接模式、装饰器模式和外观模式

11.5 小结

11.6 问题

第四部分 进阶主题

第12章 继承与变体

12.1 技术要求

12.2 实现继承和行为子类型化

12.2.1 理解实现继承

12.2.2 理解行为子类型化

12.2.3 正方形–矩形问题

12.2.4 脆弱的基类问题

12.2.5 重温鸭子类型

12.3 协变、不变和逆变

12.3.1 理解不同种类的变体

12.3.2 参数化类型是不变的

12.3.3 方法参数是协变的

12.3.4 剖析函数类型

12.3.5 确定函数类型的变体

12.3.6 实现自己的函数类型分派

12.4 再谈参数化方法

12.4.1 指定类型变量

12.4.2 匹配类型变量

12.4.3 理解对角线规则

12.4.4 对角线规则的例外

12.4.5 类型变量的可用性

12.5 小结

12.6 问题

问题答案

第1章

第2章

第3章

第4章

第5章

第6章

第7章

第8章

第9章

第10章

第11章

第12章