C/C++教程

代码整洁之道Clean Code笔记

本文主要是介绍代码整洁之道Clean Code笔记,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

@[TOC](代码整洁之道Clean Code笔记)

在线阅读:书栈网:https://www.bookstack.cn/read/Clean-Code-zh/spilt.8.docs-ch1.md

每个章节都会做一个自己的总结,并为这个章节打一个重要性的参考分数,满分五星(仅个人的角度)。

如果想尽快的了解一些代码的规范,最好看一下阿里代码规范,idea也可以安装阿里代码规范插件。

阿里开发手册是实践,这本书本身更多的是作者理念引导。理念的引导必然少不了佐证、和一些看似冗余的语句,但这都是我们站在如今开发环境上的结果论,因为所有技术性文章都是具有很强的时效性。

第 1 章 Clean Code 整洁代码(3星)

第一章主要介绍这本书的背景和意图,以及总结下整洁代码的理念

有的章节几节可以直接越过,但是看完的话既知所以然,又知其然

?为什么要整洁的代码

反证:糟糕代码的坏处

团队中各司其职,代码是代码人应有的责任,要主动维护,去说服那些阻碍我们优化的。。。

?什么叫做整洁代码

每个人对于整洁的定义都不同,这里只是作者代表的一些理念,要学会自我思考

  • 意图明确:只做一件事,提高表达力
  • 扩展性:提早构建小规模、简单抽象
  • 简洁:减少重复代码,包括尽量少的实体,比如类、方法、函数等
  • 正确性:能通过所有测试
  • 体现系统中的全部设计理念
  • 读与写花费时间的比例超过 10:1,代码阅读重要性,要对自己的读者负责
  • 整洁代码需要从点滴做起

成功的案例并不能让你成为成功者,只能分享给别人成功的过程,技巧

第 2 章 Meaningful Names 有意义的命名(3星)

语义明确,语境明确,不冗余

  • **语义明确:**最好通过变量名讲解变量的意义,而不是注释。例如:魔法值,就是不能明确意义的常量

  • **避免误导:**例如:缩写不明确;专有名词同名;命名类型不准确;相似命名放一起区分,明确注释;相似数字字母不明确

  • 有意义的区分,废话都是冗余。比如:Table 一词永远不应当出现在表名中

  • 使用可以读的出来的名称

  • **使用可以搜索的名字:**单字母名称和数字常量仅用在短方法中的本地变量,最好不要用

  • **避免思维映射:**不要你觉得,别人也会这样觉得

  • 类名和对象名应该是名词或名词短语,不应当是动词

  • 方法名应当是动词或动词短语

重载构造器时,使用描述了参数的静态工厂方法名。例如,

Complex fulcrumPoint = Complex.FromRealNumber(23.0);

通常好于

Complex fulcrumPoint = new Complex(23.0);

可以考虑将相应的构造器设置为 private,强制使用这种命名手段。

  • 别用双关语

  • 使用程序员熟悉的术语,或者所涉问题领域命名

  • **添加有意义的语境:**对字段进行补充说明

第 3 章 Functions 函数(3星)

本章所讲述的是有关编写良好函数的机制

  • 函数的第一规则是要短小

  • 函数应该只做好这一件事

  • 每个函数一个抽象层级

让代码读起来像是一系列自顶向下的 TO 起头段落是保持抽象层级协调一致的有效技巧

  • switch

利用多态来实现,确保每个 switch 都埋藏在较低的抽象层级,而且永远不重复

例子:所有的员工都有一样的流程,是否发薪日、计算薪水、发薪水,但是不同类型的员工具体流程动作不一样

public Money calculatePay(Employee e)
        throws InvalidEmployeeType {
    switch (e.type) {
        case COMMISSIONED:
            return calculateCommissionedPay(e);
        case HOURLY:
            return calculateHourlyPay(e);
        case SALARIED:
            return calculateSalariedPay(e);
        default:
            throw new InvalidEmployeeType(e.type);
    }
}

多态实现:更改之后再增加职员类型,每种职工只需要做自己的事情,不需要所有的类型当方法都更改,只需更改实现工厂实现类

public abstract class Employee {
    public abstract boolean isPayday();
    public abstract Money calculatePay();
    public abstract void deliverPay(Money pay);
}
-----------------
public interface EmployeeFactory {
    public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType;
}
-----------------
public class EmployeeFactoryImpl implements
        EmployeeFactory {
    public Employee makeEmployee(EmployeeRecord r) throws InvalidEmployeeType {
        switch (r.type) {
            case COMMISSIONED:
                return new CommissionedEmployee(r);
            case HOURLY:
                return new HourlyEmployee(r);
            case SALARIED:
                return new SalariedEmploye(r);
            default:
                throw new InvalidEmployeeType(r.type);
        }
    }
}
  • 使用描述性的名称

别害怕长名称、别害怕花时间取名字、命名方式要保持一致

  • 函数参数: 最理想的参数数量是零
  • **无副作用函数:**不要把相关性不强的逻辑放进来,强调复用性
  • **分隔指令与询问:**避免混乱
  • 使用异常替代返回错误码
if (deletePage(page) == E_OK) {    if (registry.deleteReference(page.name) == E_OK) {        if (configKeys.deleteKey(page.name.makeKey()) == E_OK) {            logger.log("page deleted");        } else {            logger.log("configKey not deleted");        }    } else {        logger.log("deleteReference from registry failed");    }} else {    logger.log("delete failed");    return E_ERROR;}

On the other hand, if you use exceptions instead of returned error codes, then the error processing code can be separated from the happy path code and can be simplified:

另一方面,如果使用异常替代返回错误码,错误处理代码就能从主路径代码中分离出来,得到简化:

 复制代码try {    deletePage(page);    registry.deleteReference(page.name);    configKeys.deleteKey(page.name.makeKey());} catch (Exception e) {    logger.log(e.getMessage());}
  • 重复可能是软件中一切邪恶的根源
  • 好的代码需要慢慢打磨,精简,优化(这正是我喜欢的过程,乐此不疲)

第 4 章 Comments 注释(2星)

作者毕竟站在英语母语的基础上,还是要考虑下我们自己的环境

  • 注释不能美化糟糕的代码,注释不能成为糟糕代码的发言人,代码才是核心
  • 别误导,别废话,适时整理TODO、注释的代码块

第 5 章 Formatting 格式 (1星)

几乎不用看

  • 垂直、横向格式:代码缩进

第 6 章 Objects and Data Structures 对象和数据结构(4星)

对象曝露行为,隐藏数据。便于添加新对象类型而无需修改既有行为,同时也难以在既有对象中添加新行为。

数据结构曝露数据,没有明显的行为。便于向既有数据结构添加新行为,同时也难以向既有函数添加新数据结构。

  • **数据抽象:**数据封装,隐藏具体行为
  • 数据、对象的反对称性

过程式代码(使用数据结构的代码)便于在不改动既有数据结构的前提下添加新函数。面向对象代码便于在不改动既有函数的前提下添加新类。

  • 得墨忒耳律

方法不应调用由任何函数返回的对象的方法

下列代码违反了得墨忒耳律(除了违反其他规则之外),因为它调用了 getOptions( )返回值的 getScratchDir( )函数,又调用了 getScratchDir( )返回值的 getAbsolutePath( )方法。

final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();

第 7 章 Error Handling 错误处理(4星)

在本章中,要列出编写既整洁又强固的代码——优雅地处理错误代码的一些技巧和思路

整洁代码是可读的,但也要强固。可读与强固并不冲突。如果将错误处理隔离看待,独立于主要逻辑之外,就能写出强固而整洁的代码

  • 使用异常而非返回码,用统一异常处理处理异常
  • 在编写可能抛出异常的代码时, 先写 Try-Catch-Finally 语句
  • 使用不可控异常,可控异常的代价就是违反开放/闭合原则
  • 给出异常发生的环境说明
  • 依调用者需要定义异常类

我们在应用程序中定义异常类时,最重要的考虑应该是它们如何被捕获,然后根据捕获规律去优化异常捕获

  • 别返回 null 值
  • 别传递 null 值

第 9 章 Unit Tests 单元测试(3星)

  • 保持测试整洁,测试代码和生产代码一样重要
  • 整洁的测试,最重要的要素是可读性
  • 每个测试一个断言
  • 测试应该有以下规则:快速、独立、可重复、自足验证、及时

第 10 章 Classes 类(5星)

代码组织的更高层面——Classes

  • 将系统的构造与使用分开
  • 类的组织

遵循标准的 Java 约定,类应该从一组变量列表开始。如果有公共静态常量,应该先出现。然后是私有静态变量,以及私有实体变量。很少会有公共变量。公共函数应跟在变量列表之后。封装

  • 类应该短小

对于函数,我们通过计算代码行数衡量大小。对于类,我们采用不同的衡量方法,计算权责(responsibility)。类的名称应当描述其权责,从命名开始规范。

**单一权责原则(SRP)**认为,类或模块应有且只有一条加以修改的理由。系统应该由许多短小的类而不是少量巨大的类组成。每个小类封装一个权责,只有一个修改的原因,并与少数其他类一起协同达成期望的系统行为。

**内聚:**类应该只有少量实体变量。类中的每个方法都应该操作一个或多个这种变量。通常而言,方法操作的变量越多,就越黏聚到类上。

**扩展性:**需求会改变,所以代码也会改变。具体类包含实现细节(代码),而抽象类则只呈现概念。依赖于具体细节的客户类,当细节改变时,就会有风险。我们可以借助接口和抽象类来隔离这些细节带来的影响。依赖倒置原则(Dependency Inversion Principle,DIP),DIP 认为类应当依赖于抽象而不是依赖于具体细节。

单一权责和内聚都是程度值,保证的他们平衡,逻辑内聚,权责解耦,这并不简单,SRP也充分考虑到了代码扩展性。

第 11 章 Systems 系统(5星)

本章将讨论如何在较高的抽象层级——系统层级——上保持整洁

无论是设计系统或单独的模块,别忘了使用大概可工作的最简单方案。

  • 将系统的构造与使用分开(编译和运行,java的环境中Spring通过依赖注入(Dependency Injection,DI),控制反转(Inversion of Control,IoC)已经帮我们把这件事做了)。延后初始化的好处:这种手段在 DI 中也有其作用。首先,多数 DI 容器在需要对象之前并不构造对象。其次,许多这类容器提供调用工厂或构造代理的机制,而这种机制可为延迟赋值或类似的优化处理所用。

  • **AOP: **在 AOP 中,被称为方面(aspect)的模块构造指明了系统中哪些点的行为会以某种一致的方式被修改,从而支持某种特定的场景。这种说明是用某种简洁的声明或编程机制来实现的。

  • **代理:**使用代理,代码量和复杂度是代理的两大弱点,创建整洁代码变得很难!另外,代理也没有提供在系统范围内指定执行点的机制,而那正是真正的 AOP 解决方案所必须的

  • **纯净的 Java AOP 框架:**Bean工厂内,每个 bean 就像是嵌套“俄罗斯套娃”中的一个,每个由数据存取器对象(DAO)代理(包装)的 Bank 都有个域对象,而 bean 本身又是由 JDBC 驱动程序数据源代理。通过XML/注解的方式减少对代码的入侵,只留下纯POJO。

  • AspectJ ASPECTS AspectJ 的方面:AspectJ 却提供了一套用以切分关注面的丰富而强有力的工具。

  • **测试驱动系统架构:**大设计(Big Design Up Front,BDUF)——系统架构。最佳的系统架构由模块化的关注面领域组成,每个关注面均用纯 Java(或其他语言)对象实现。不同的领域之间用最不具有侵害性的方面或类方面工具整合起来。这种架构能测试驱动,就像代码一样。

  • **优化决策:**模块化和关注面切分成就了分散化管理和决策。拥有模块化关注面的 POJO 系统提供的敏捷能力,允许我们基于最新的知识做出优化的、时机刚好的决策。决策的复杂性也降低了。

  • 选择合适的架构——标准

  • **系统需要领域特定语言:**领域特定语言(Domain-Specific Language,DSL)。DSL 是一种单独的小型脚本语言或以标准语言写就的 API,领域专家可以用它编写读起来像是组织严谨的散文一般的代码。领域特定语言允许所有抽象层级和应用程序中的所有领域,从高级策略到底层细节,使用 POJO 来表达。

第 12 章 Emergence 迭进

本章中写到的实践来自于本书作者数十年经验的精练总结。遵循简单设计的实践手段,开发者不必经年学习就能掌握好的原则和模式。

提升内聚性,降低耦合度,切分关注面,模块化系统性关注面,缩小函数和类的尺寸,选用更好的名称,如此等等。这也是应用简单设计后三条规则的地方:消除重复,保证表达力,尽可能减少类和方法的数量。

通过迭进设计达到整洁目的,Kent Beck 关于简单设计的四条规则,据 Kent 所述,只要遵循以下规则,设计就能变得“简单”,以下规则按其重要程度降序排列:

  • 运行所有测试;
  • 不可重复;
  • 表达了程序员的意图;
  • 尽可能减少类和方法的数量;

第 13 章 Concurrency 并发编程(5星)

“对象是过程的抽象。线程是调度的抽象。” ——James O

这个章节主要讲述了并发编程的来源、优势和劣势,以及如何避免、解决并发错误的方法和方向

? 为什么要并发

  • 并发是一种解耦策略。

  • 解耦目的与时机能明显地改进应用程序的吞吐量和结构。

  • 并发会在性能和编写额外代码上增加一些开销;

  • 正确的并发是复杂的,即便对于简单的问题也是如此;

  • 并发缺陷并非总能重现,所以常被看做偶发事件而忽略,未被当做真的缺陷看待;

  • 并发常常需要对设计策略的根本性修改。

并发防御原则

  • 单一权责原则

单一权责原则(SRP)认为,方法/类/组件应当只有一个修改的理由。并发设计自身足够复杂到成为修改的理由,所以也该从其他代码中分离出来。不幸的是,并发实现细节常常直接嵌入到其他生产代码中。

需要考虑的问题:

并发相关代码有自己的开发、修改和调优生命周期;

开发相关代码有自己要对付的挑战,和非并发相关代码不同,而且往往更为困难;

即便没有周边应用程序增加的负担,写得不好的并发代码可能的出错方式数量也已经足具挑战性。

建议:分离并发相关代码与其他代码。

  • 限制数据作用域

两个线程修改共享对象的同一字段时,可能互相干扰,导致未预期的行为。解决方案之一是采用 synchronized 关键字在代码中保护一块使用共享对象的临界区(critical section)。限制临界区的数量很重要。更新共享数据的地方越多,就越可能:

谨记数据封装;严格限制对可能被共享的数据的访问。

避免共享数据的好方法之一就是一开始就避免共享数据。

线程应尽可能地独立,让每个线程在自己的世界中存在,不与其他线程共享数据。

了解 Java 库

学习类库,了解基本算法。理解类库提供的与基础算法类似的解决问题的特性。

了解执行模型

学习这些基础算法,理解其解决方案。

  • Producer-Consumer 生产者-消费者模型
  • Readers-Writers 读者-作者模型
  • Dining Philosophers 哲学家用餐模式

警惕同步方法之间的依赖

  • 避免使用一个共享对象的多个方法
  • 有时必须使用一个共享对象的多个方法,有 3 种应对手段:
  • 基于客户端的锁定——客户端代码在调用第一个方法前锁定服务端,确保锁的范围覆盖了调用最后一个方法的代码;
  • 基于服务端的锁定——在服务端内创建锁定服务端的方法,调用所有方法,然后解锁。让客户端代码调用新方法;
  • 适配服务端——创建执行锁定的中间层。这是一种基于服务端的锁定的例子,但不修改原始服务端代码。

尽可能减小同步区域

尽早考虑关闭问题,尽早令其工作正常。

测试线程代码

编写有潜力曝露问题的测试,在不同的编程配置、系统配置和负载条件下频繁运行。如果测试失败,跟踪错误。别因为后来测试通过了后来的运行就忽略失败。

有一大堆问题要考虑。下面是一些精练的建议:

  • **将伪失败看作可能的线程问题,**不要将系统错误归咎于偶发事件
  • 先使非线程代码可工作, 不要同时追踪非线程缺陷和线程缺陷。确保代码在线程之外可工作。
  • **编写可插拔的线程代码,**这样就能在不同的配置环境下运行。
  • **编写可调整的线程代码,**要获得良好的线程平衡,常常需要试错。一开始,在不同的配置环境下监测系统性能。要允许线程数量可调整。在系统运行时允许线程发生变动。允许线程依据吞吐量和系统使用率自我调整。
  • **运行多于处理器数量的线程,**系统在切换任务时会发生一些事。为了促使任务交换的发生,运行多于处理器或处理器核心数量的线程。任务交换越频繁,越有可能找到错过临界区或导致死锁的代码。
  • 在不同平台上运行
  • **装置试错代码,并强迫错误发生:**有两种装置代码的方法:硬编码、自动化

第 15 章 JUnit Internals JUnit 内幕(2星)

本章介绍了JUnit的一些简单的模块

第 16 章 重构 SerialDate(4星)

本章详解对 org.jfree.date库中的SerialDate日期类进行重构,简化的过程。增加了测试覆盖率,修复了一些错误,澄清并缩小了代码。

第 17 章 味道与启发(3星)

本章又列举了作者之前列出过的,一些不好的习惯,并把这些比作难闻的气味

干净的代码不是通过遵循一组规则来编写的。

附录 A 并发编程 II(4星)

并发编程的一些扩充信息,多了很多的示例讲解

在本章中,我们谈到并发更新,还有清理及避免同步的规程。我们谈到线程如何提升与 I/O 有关的系统的吞吐量,展示了获得这种提升的整洁技术。我们谈到死锁及干净地避免死锁的规程。最后,我们谈到通过装置代码暴露并发问题的策略。

  • 死锁

死锁的发生需要 4 个条件:

**互斥:**无法在同一时间为多个线程所用;数量上有限制

这种资源的常见例子是数据库连接、打开后用于写入的文件、记录锁或是信号量。

上锁及等待:当某个线程获取一个资源,在获取到其他全部所需资源并完成其工作之前,不会释放这个资源。

无抢先机制:线程无法从其他线程处夺取资源。一个线程持有资源时,其他线程获得这个资源的唯一手段就是等待该线程释放资源。

循环等待:这也被称为“死命拥抱”。想象两个线程,T1 和 T2,还有两个资源,R1 和 R2。T1 拥有 R1,T2 拥有 R2。T1 需要 R2,T2 需要 R1。

这 4 种条件都是死锁所必需的。只要其中一个不满足,死锁就不会发生。

避免死锁的一种策略是规避互斥条件。你可以:

  • 使用允许同时使用的资源;
  • 增加资源数量,使其等于或大于竞争线程的数量;
  • 在获取资源之前,检查是否可用。
  • 不上锁及等待
  • 满足抢先机制
  • 不做循环等待

将解决方案中与线程相关的部分分隔出来,再加以调整和试验,是获得判断最佳策略所需的洞见的正道。

总结

干净有经验值,也有固定分,不是通过遵循一组规则来编写的,需要的是迭进,不需要钻牛角尖。

读英文原文的时候突然想到:英语大多是结果论,喜欢陈述事实,就好像罪犯的对白

这篇关于代码整洁之道Clean Code笔记的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!