代码之髓读后感——名字&做用域&类型

名字和做用域

为何要取名

看着代码中遍地都是的变量，函数，或多或少的咱们都应该想过，为何会有这些名字呢？

咱们知道，计算机将数据存储到对应的物理内存中去。咱们的操做就是基于数据的。咱们须要使用这些数据，因此一个问题就是如何寻找到这些数据。一个较为直接的方式就是为它起个名字。

联系现实生活中的，最典型的就是图书馆。一本本书，一块块数据。为了查找，咱们使用的是对各个数据地址进行编码。一一映射到一组惟一的数据上，以此便于查找的惟一替代彼不便于查找的惟一。

仔细想来，这种替代的方法彷佛和哈希函数的思想有思想却是有些接近。或许其中就是使用了呢？

实际上，每一个名字对应的都是实际内存中的地址。所以也必需要有一个表来存储映射关系。

因此在语言的发展过程当中，对照表的设计也是一个关键之处。

做用域的演变

在早期的程序设计语言中对照表是整个程序共有的。这样的设计，虽然必定程度上解决了映射的管理的问题，可是，这就至关于如今全局的做用域的概念，一处变，到处变，一次变，次次变。为了防止变量名的重复使用，防止名字的冲突，一种方法就是使用更长的变量名。在这种过程当中，各类命名法就出现了。固然，对于如今来讲，合理的命名对于程序的可读性，易扩展性也是有极大的帮助的。再有就是使用做用域的限定。

随着程序规模的扩大，为了更方便管理变量，将不一样层级的变量各自划分范围，将各个变量的有效范围进行约束，因而出现了做用域的概念。

正是因为原先的相似于全局做用域的设定，致使当前出现了做用范围太大，出现冲突的可能性太大，进而由此想出了解决办法——缩小做用域。

做用域随着后来的发展，出现了两种类型——动态与静态。

所谓的做用域就是指某段程序文本代码。一个声明起做用的那一段程序文本区域，则称为这个声明的做用域。静态做用域是指声明的做用域是根据程序正文在编译时就肯定的，有时也称为词法做用域。而在采用动态做用域的语言中，程序中某个变量所引用的对象是在程序运行时刻根据程序的控制流信息来肯定的。

从对照表的角度来分析一下静态做用域和动态做用域。

动态

动态做用域中的对照表能被所有代码读取

1. 最初全局对照表中记录了x与global的映射。

2. 进入函数a，准备新的全局可见的对照表。

3. 函数a写入变量x的值记录在新的对照表中。

4. 进入函数b，因为还未退出a，故其对照表仍有效。因此读取其中的x的值。（参照变量的时候，按照由近及远的顺序读取。如果访问该对照表中没有记录的变量时，就翻转到外层的对照表查找，这里是全局对照表）

5. 退出b。

6. 退出a时，做废新的对照表。

以下例子：

$x = "global";

sub a {
    local $x = "local";
    &b();
}

sub b {
    print "$x\n";
    # 输出“local”
}

&a();

把变量原来的值实现保存在函数入口处，在出口处写回变量中。这样一来，在程序中间的改写在退出函数的时候不会继续影响。可是这样就要要求，凡当函数退出时，全部地方就要毫无遗漏的加上返回值的代码。因而处于懒惰的心理，咱们总但愿让计算机去完成这样的工做。

1991年发布的Perl4开始，Perl语言就增长了这样的功能。它经过把变量声明为local，就能够长程序处理器去承担“把原来的值另存起来随后返回”的任务。
这样的做用域称为动态做用域。动态做用域中被改写的值会影响到被调用函数，所以在引用变量时是什么样的值，不看函数调用方是无从得知的。这就使得在代码规模庞大时，不便于把握。

静态（又叫字面做用域，词法域等等）

静态做用域按照函数区分对照表

1. 最初全局对照表中记录了x与global的映射。

2. 进入函数a，准备函数a专用的对照表。

3. 函数a写入变量x的值记录在专用的的对照表中。

4. 进入函数b，准备函数b专用的对照表。

5. 读取变量值，会先读取b专用表，没有结果则去读取全局变量的表。

6. 退出b，做废该张对照表。

7. 退出a，做废该张对照表。

以下例子：

$x = "global";

sub a {
    my $x = "my";
    &b();
}

sub b {
    print "$x\n";
    # 输出“global”
}

&a();

如今说全局变量很差或者全局污染缘由即是在此。实际操做中尽可能减少做用范围，是一种明智的选择。

静态做用域的不足

以一开始就采用了静态做用域的python语言为例：

2000年发布的python2.0中，对照表有三个层次（做用域）。从大到小分别是内置的，全局的，局部的。简单而言，每一个程序都有一张总体对照表（内置），一张文件级别的对照表（全局），一张函数级别的对照表（局部）。

内置对照表，能够在程序的任何地方使用参照，全局对照表是针对每一个文件的，由于有的语言也称之为文件做用域，局部做用域则是针对每一个函数的对照表。

在实际使用中，主要出现如下问题：

嵌套函数的问题

python支持函数嵌套定义。

x = "global"
def a():
    x = "a"
    def b():
        print x
    b()
a()

在python2.0最初的设计中，如上函数嵌套时，当b中的局部做用域中找不到x，接下来去找的是全局做用域。

这样的设计引来不少误解，人们经常会觉得，从表面看，由于a中包含b，因此a的做用域也包含b的做用域，当b中找不到x时，参照相邻的外部a的做用域。

后来在2011年发布的python2.1中设计修改成了逐层往外寻找的策略。

外部做用域的再绑定问题

指的是采用静态做用域时，没法变动嵌套做用域外部的变量。当嵌套的内层函数变量赋值时，如果当前做用域没有该值时，就会在当前的做用域定义一个新的局部变量。对这个名字进行了一次再次绑定，为他关联了另外的值。可是，这并不会影响外部的做用域。即没法变动外部的变量。

为了解决这个小问题，2006年的python3.0提供了关键字nolocal，在函数开始时，声明变量为nolocal性质。即主动地声明是非本地的。

这个关键字的选取，主要考虑了对于过往代码的兼容性，他在过去的代码中，出现的频度是最低的。

这样的nolocal和global关键字有区别么？

对于和python很相似的ruby而言，则是使用了方法与代码段的区分。

函数发生嵌套，形式上有两种类型。方法套方法，方法套代码段。

以下两例：

# 方法在进行嵌套时做用于不嵌套
def foo()
    x = "outside"
    def bar() # 方法嵌套
        p x   # 会出错，由于没法访问外部的x
    end


# 方法中有代码段时，方法的局部做用域中有的名字，在代码段中视为方法的局部变量，除此之外被视为代码段的局部变量。
# 相同名字则为方法的，不一样的，则是本身的。
def foo()
    x = "old"
    lambda {x = "new"; y = "new"}.call
    # x -> foo(), y -> lambda的本地变量
    p x # new
    p y # lambda的本地变量，外部没法访问
end

做用域总结

虽然如今不多会使用动态做用域，但这一律念并非彻底没有用处。与静态做用域中做用域是源代码级别上的一块完整独立的范围不一样，在动态做用域中，做用域则是进入该做用域开始直至离开这一时间轴上的完整独立的范围。与此相同的特征也体如今其余好多地方。好比，在某处理进行期间，一时改变某变量的值随后将原值返回的代码编写方式就至关于建立了本身专属的动态做用域。又如，异常处理与动态做用域也很类似，函数抛出异常时的处理方式受到调用函数的 try/catch 语句的影响。
面向对象中像 private 声明这样的访问修饰符，在限制可访问范围的做用上和做用域是很是类似的。private 将可访问范围限制在类以内，而 protected 将此范围扩大到其继承类。这和函数调用处的变动会影响到调用里面的操做这一动态做用域表现是类似的，二者都具备这么一个缺点，这就是影响范围没有能限制在代码的某一个地方。
好比 Java 语言，它是静态做用域语言，它的类能够在源代码的任意处被访问。这意味着类是具备全局做用域的。可是类的名字具备层次而且只有导入后才能被使用，这避免了全局变量带来的无心的名字冲突。可是无论是全局变量仍是类的静态成员均可以在源代码的任意地方被变动。这提醒咱们，在享受使用上的便利的同时，要谨防滥用致使的代码难以理解的状况发生。
做用域是编写易于理解的代码的有力工具，不少地方都应用了这一律念。

---

类型

C，java，C++等语言中的int，void，double，float等等，这些是怎么出现的？如今又有了怎样的变化与发展？

类型是什么

类型是人们给数据附加的一种追加数据。计算机中保存的数据是由 on 和 off 或 0 和 1 的组合来表达的。至于 on 和 off 的组合（比特列）是如何表达各类数值的，哪一种比特列表示哪一种值，这些只不过是人们简单的约定事项而已。一样的比特列，当其被解释为的数据的类型不一样时，获得的数值是不一样的。为了不这一状况的发生，人们追加了关于数据的类型信息，这就是类型的起源。

计算机中的数值是整数、浮点数仍是其余类型的数，为了在计算机中管理这一信息，因而催生了类型。起初，类型中只加入了数值的种类信息，最后又有多种多样的信息加入进来。好比，能在这个数值上施加的操做、此函数可能抛出的异常等信息都被加入到类型中来了。如今，像静态类型和动态类型那样连内存地址和使用时间都不同的事物也被称为类型，这使得类型这种东西变得愈来愈难以捉摸。什么样的信息放在什么地方，在什么样的时间被使用，从这个视角来看反而更容易理解。

表达数字的思考

如何在电子计算机中表达数值呢？如前所述，在计算机中全部的数值都用 on 和 off 或 0 和 1 的组合来表达。为了更形象地说明，咱们换个角度来思考，该如何用灯泡的点亮与熄灭来表达数值呢？为了充分利用资源，只能是用最少的技术标量来表示最多的数。

彻底按个数(n个计数标量) 
        -> 数位(阿拉伯数字)(10个计数标量) 
                    -> 七段数码管(7个计数标量) 
                                    -> 算盘(最少的5个，上一下四)
                                                -> 从十进制到二进制(9也只须要4个，1001)

把二进制中某几个字符组合在一块儿用一个字符来表示，使之变得更容易读，这种表达方式就是八进制或十六进制。

如何表达实数

实数的复杂之处在于在正整数的基础上添加了小数和负数。因此针对这两种状况进行设计。

定点数——小数点位置肯定

一种方法是肯定小数点的的位置。好比，约定好把整数的小数点向左移动四位，最低四位就是小数部分。这样一来，1 变成 0.0001，100 变成 0.0100 即 0.01.这种方法有个问题，它没法表达比 0.0001 小的数，好比没法表达 0.00001。固然只要把约定改成把整数的小数点向左移动五位获得小数部分就能够，但这样针对每个新的小数都要记一句新的约定很困难，并且还容易出错。那该怎么办呢？

浮点数(floating point number)——数值自己包含小数部分何处开始的信息

之前关于浮点数有各类不一样的约定，如今都标准化为 IEEE 75415。15官方名称为“IEEE Standard for Floating-Point Arithmetic (ANSI/IEEE Std 754-2008)"。IEEE 754 最先制定于 1985 年，后于 2008 年进行了修订。另外，在此标准规定有 5 种标准类型，这里仅仅说明了其中的单精度二进制浮点数。

左边那盏灯（最高比特位）,也能够称之为 MSB（most significant bit），最高有效位 表明了数的符号。该位为 0 时表示正数，为 1 时表示负数,在标准中，零区分为正的零和负的零。

接下来的 8 盏灯是表示位数的指数部分。指数部分做为整数理解的话能够表达 0~255 之间的数，减去 127 获得范围－127~128。－127 和 128 分别表明了零和无限大，剩下的－126~127 表明了小数点的位置。－126 是指小数点向左移动 126 位，127 是指小数点向右移动 127 位。

其他的 23 盏灯是尾数部分，表示了小数点如下的部分。尾数部最左边的灯泡表示 1/2（二进制中的 0.1），接下来是 1/4（二进制中的 0.01）。请看图中的 1.75 这个数，它等于 1+1/2+1/4，用二进制来表示就是 1.11。因此，1/2 位的灯泡和 1/4 位的灯泡都点亮。指数部分为 127（要减去 127 就是范围中的 0），这表示小数点的位置移动 0 位。这两点组合起来就是 1.75。

准确来说，尾数是在二进制表达中为使得整数部分变成 1 而移动小数点获得的小数部分。

接下来的数 3.5，用二进制来表示是 11.1。小数点向左移动一位就获得 1.11。因此它的尾数部分和 1.75 同样，1/2 位和 1/4 位点亮。指数部分变成 128（减去 127 就是范围中的 1）。3.5（二进制中的 11.1）其实就是 1.75（二进制中的 1.11）的小数点向右移动一位获得的数 19。而 7.0 则是由指数部分继续加 1 获得。

19在二进制中，小数点移动一位进位不是 10 倍而是 2 倍。指数部分加 1，变成 2 倍，减 1 变成 1/2。

浮点数的问题

现今你们接触到的语言中，实数大多用浮点数 IEEE 754 表达。从实用角度来看，大部分状况下这没有任何问题。可是，这种方法要表达 3 除以 10 的答案时，十进制中能够确切表达出来的 0.3 在二进制中却变成了 0.0100110011001100110011……这样的无限循环小数，不管怎么写都有偏差存在。正由于如此，会出现对0.3作十次加法并舍去某些位数后获得2这样的现象。银行和外汇交易等涉及资金操做的场合尤为不欢迎这种系统行为，因此这些场合使用的是定点数或者加三码（excess-3）这样的十进制计算方式。

为何出现类型

在内存中记录的数值是整数仍是浮点数，单靠人的记忆很难避免错误。有没有更为简易的方法呢？

• 一种方法是用肯定的规则来表示变量名所表达的内容。好比，早期的 FORTRAN 语言使用了一系列规则，指定以 I~N 开头的变量名表示整数，除此之外的表示浮点数。

• 另外一种更好的方法是告诉处理器某某变量是整数，让计算机而不是人去记忆这一信息。这就是变量的类型的声明产生的缘由。好比 C 语言中，声明 int x; 表示名字为 x 的变量指向的内存被解释为整数，声明 float y; 表示名字为 y 的变量指向的内存被解释为浮点数。这样经过提供关于类型的信息，处理器在进行运算时，就能自动判断该作整数相加运算仍是浮点数相加运算，而不须要人们逐个去指定。

  • 整数之间、浮点数之间的运算计算机参照数据的类型来决定怎样执行。若是 x 和 y 同为整数，就作整数之间的加法运算。若是 x 和 y 同为浮点数，就作浮点数之间的加法运算。

  • 整数与浮点数之间的计算，则依据语言不一样采用了不一样的方法。有显示使用转换函数(如早期的 FORTRAN 语言)，也有隐式自动转换的(如C)。

    • C 语言中采用的设计方法是由计算对象的类型来决定是否舍去小数部分。这一方法在很长时间内被不少语言使用，以致于不少程序员都很是习惯，认为理所固然。然而，这个不是恒久不变的物理法则，只不过是人们确立的设计方法而已。所以并非全部的语言都采用这种设计。

    • 一些语言使用特定的运算符来处理是否保留小数的状况。

      • 1973 年问世的 ML 语言中，整数的除法运算就表达为 x div y， 而浮点数的除法运算表达为 x / y。

      • OCaml 中也用 x / y 和 x /. y 来区分整数的除法运算和浮点数的除法运算。

      • 1991 年问世的 Python 语言起初使用的是混杂着 C 语言风格的除法运算方式。

      • 2008 年发布的 Python 3.0 中，把 x / y 做为与 x 和 y 类型无关不作舍去的除法运算，带舍去的除法运算用 x // y 来表示。

类型的发展

1. 使用语言中自带的基本数据类型经过组合定义新的类型的这一功能被发明出来。这被称为用户定义型。

• 如 C 语言中的结构体。

• 在 C 语言以前的 COBOL 语言中，能够用基本的类型组合起来定义一种带有层次结构的记录类型。

• PL/I 语言也有能组合基本类型并建立新的类型的语句 DEFINE STRUCTURE。(结构体（structure）这个术语应该就是从那时候开始使用)的。

其实，不只限于整数这样的数据，函数这样决定数据如何被处理的对象也被糅合到类型中来了。C++ 语言的设计者本贾尼·斯特劳斯特卢普把用户能自定义的类型看成构造程序的基本要素，把这种类型冠名为类。

1. 后来出现了类型既是功能的观念。这种观念认为，构成结构体和类的类型不该该是所有公开而是最小限度地公开，类型是否一致这个交由编译器来检查，用类型来表达功能，与功能是否一致也是由编译器来检查。所以，只须要将与外部有交互的部分做为类型公开，而实现的细节则隐藏起来。这样类型就被区分为公开部分和非公开部分了。

2. 出现了不包含有具体的实现细节的类型（Java 语言中的接口等）。

3. 另外把函数是否抛出异常这一信息也看成类型。

类型便是功能的方法获得了愈来愈普遍地应用，但遗憾的是，用类型来实现全部功能的想法却尚未成功。若是它能成功，就很理想了：只要类型一致就不用关心内部的实现细节，功能与类型的不一致交由编译器来检查，编译经过意味着没有 bug。然而，仍有很多类型没法表达的信息，如输入这个数据须要多少处理时间，这个处理过程须要多少内存，线程中是否能够进行这种操做等。至今，这些问题也只能经过人为地读取文档和源代码来判断。

总称型、泛型和模板

经过将不一样类型进行组合获得复杂的类型后，使用中会出现想更改其中一部分却又不想所有从新定义的再利用需求。

所以出现了构成要素部分可变的类型，即总称型。想要表现不一样的状况时，出现了以类型为参数建立类型的函数(C++ 语言中的模板、Java 语言中的泛型以及 Haskell 语言中的类型构造器能够说就是这种建立类型的机制)。

动态静态类型

到目前为止，咱们介绍的类型的机制中，处理器把变量名、保存数值的内存地址、内存里的内容的类型三者做为一个总体来看待。把类型的信息和数值看做总体的方式叫动态类型。做为其反义词，到目前为止介绍的类型机制都叫静态类型。如今大多数的脚本语言都采用了动态类型。

动态类型如何实现的呢？

是由于在内存上使用了同等类型对待的设计方法。好比 Python 语言中，无论是整数仍是浮点数仍是字符串，所有都做为 PyObject 对待，开始部分都是同样的。另外在 PyObject 类型的结构中还预留了保存值的类型信息的地方。这一点在其它的脚本语言中也是一样的状况，好比在 Ruby 语言中，任何数值都是 VALUE 类型的。

※ 使用次数是指在内存管理中记录这个数值有几处被参照引用的数值（引用计数）。
※ 字符串的散列值是散列函数的计算结果（详见第 9 章），状态是表示该字符串是否记录在 Internpool 里（处理器是否把该字符串进行惟一处理的标志）。

动态类型的优点与不足

使用这种数值类型处理方法，能实现从来静态类型语言不能实现的灵活处理。运行时肯定类型和改变类型成为可能。然而，它也有一些不足。静态类型语言在编译时肯定类型，同时编译时也检查了类型的一致性。有了这种类型检查，在实际执行前，便能发现一部分bug。这一点动态类型语言是没法作到的。

类型推断

既不放弃编译时的类型检查，也想尽可能减小麻烦的类型声明，要实现这一要求就要用到计算机自动推论肯定类型的方法。

一样是使用类型推断这一术语，在不一样的语言中，如何作类型推断以及类型推断的能力如何，状况是不同的。咱们来比较一下 Haskell 语言和 Scala 语言。

GHCi
> :type identity identity
identity identity :: t -> t
> identity identity 1
1

Scala 语言中类型推断的行为和 Haskell 语言是不同的。它会首先来定义 identify 函数。

Scala的对话终端
scala> def identity = x => x
<console>:7: error: missing parameter type
       def identity = x => x
                      ^

scala> def identity[T] = (x : T) => x
identity: [T]=> T => T

scala> identity(identity)
res0: Nothing => Nothing = <function1>
scala> identity(identity)(1)
<console>:9: error: type mismatch;
 found   : Int(1)
 required: Nothing
              identity(identity)(1)
                                 ^

因而可知，一样是使用类型推断的表达方法，不一样语言指示的具体内容是不同的。刚刚展现了 Scala 语言推论失败的一个例子，即便推论成功了，在实用价值上有没有优点这个问题上，你们也是有意见分歧的。即便认可它的优点而对类型推断的机制进行修改，在由此带来的做业代价与推论失败的代价之间作权衡以后，再决定否应该作改进和变动将是一个更加困难的问题。

强类型下是否能够作到程序没有bug

类型推断与理论推论之间有对应关系。因而有些语言发出挑战，试图经过使用比 C 语言和 Java 语言更强力的类型系统来证实程序中没有任何 bug。从此在改善类型系统的表现力和类型推断规则方面应该会开展各类研究。

好比，在一个接受 X 型参数返回 Y 型返回值的函数中传递一个 X 型的数值，会获得 Y 型的返回值。这一关于类型的描述与“X 为真在若是 X 则 Y 的状况下，Y 就为真”这一逻辑的描述是相对应的，被称为 Curry-Howard 对应。