读编程与类型系统笔记02_基本类型

1. 空类型

1.1. uninhabitable type

1.1.1. 声明从不返回的函数

1.2. 不能有任何值的类型，其可取值的集合是一个空集合

1.3. 函数不返回的原因

1.3.1. 函数在所有代码路径上都抛出异常

1.3.2. 函数可能执行无限循环

1.3.3. 导致程序崩溃

1.4. TypeScript提供了never作为空类型

1.5. 自制空类型

1.5.1. 定义一个枚举

1.5.1.1. 不在其中定义任何元素

1.5.2. 定义一个结构

1.5.2.1. 使其只有一个私有构造函数

2. 单元类型

2.1. void

2.2. 不存在有意义的值

2.3. 只有一个可能值的类型

2.3.1. 这个值是什么并不重要

2.3.2. 所有单元类型都是相等的

2.3.3. 一个单元类型转换为另一个单元类型没有意义

2.4. 当函数的结果没有意义时使用单元

2.5. 也叫作动作

2.6. 自制单元类型

2.6.1. 定义一个枚举

2.6.1.1. 只有一个元素

2.6.2. 定义一个没有状态的单例

2.6.2.1. 创建自己的单元类型

3. **void不返回有意思的值

空类型根本不返回**

4. 布尔类型

4.1. 乔治·布尔最早描述布尔代数

4.2. 只有两个值的类型

4.3. 布尔表达式

4.3.1. &&代表AND

4.3.2. ||代表OR

4.3.3. !代表NOT

4.3.4. Topic1

4.4. 短路计算

4.4.1. a AND b

4.4.1.1. if a then b else false

4.4.1.2. 第一个操作数为false，则无论第二个操作数是什么，整个表达式都是false

4.4.2. a OR b

4.4.2.1. if a then true else b

4.4.2.2. 第一个操作数为true，则无论第二个操作数是什么，整个表达式都是true

4.4.3. 短路操作可能不会计算右侧的表达式

4.4.4. 首选按照开销最小到开销最大的顺序来排列条件

5. 数值类型

5.1. 关键特征

5.1.1. 宽度

5.1.1.1. 表示一个值的位数

5.1.1.2. 1个字节=8位

5.1.1.3. 64位CPU有64位寄存器

5.1.1.3.1. 对64位值执行极快的操作

5.1.2. 编码

5.1.2.1. 无符号二进制

5.1.2.1.1. N位无符号整数

5.1.2.1.1.1. 最小取值（全部位都0）=0

5.1.2.1.1.2. Topic1

5.1.2.1.2. 只能表示正数

5.1.2.2. 二进制补码

5.1.2.2.1. 保留一位作为符号位

5.1.2.2.2. 正数的表示与前面一样

5.1.2.2.3. Topic1

5.1.2.3. IEEE 754

5.1.2.3.1. 美国电气和电子工程师协会（Institute of Electrical and Electronics Engineers）为表示浮点数（带小数部分的数字）制定的标准

5.2. 溢出

5.2.1. 算术上溢

5.2.1.1. 数字太大，无法用给定位数表示

5.2.2. 算术下溢

5.2.2.1. 数字太小，无法用给定位数表示

5.2.3. 处理方式

5.2.3.1. 环绕

5.2.3.1.1. 硬件通常采用

5.2.3.1.2. 简单地丢弃不合适的位

5.2.3.1.3. 处理溢出最高效的方式

5.2.3.1.4. 最危险的方式

5.2.3.2. 饱和

5.2.3.2.1. 物理世界非常对应

5.2.3.2.2. 运算结果超出了可以表示的最大值，就停止在最大值

5.2.3.2.2.1. 参考温度计

5.2.3.2.3. 算术运算不再始终具有结合性

5.2.3.2.3.1. 最大值是7

5.2.3.2.3.2. 7 + (2 – 2) = 7 + 0 = 7

5.2.3.2.3.3. (7 + 2) – 2= 7 – 2 = 5

5.2.3.3. 报错

5.2.3.3.1. 发生溢出时抛出错误

5.2.3.3.2. 最安全的方法

5.2.3.3.3. 缺点是需要检查每个算术运算

5.3. 浮点类型

5.3.1. 组成

5.3.1.1. 符号位

5.3.1.1.1. 一个位

5.3.1.1.2. 正数为0

5.3.1.1.3. 负数为1

5.3.1.2. 指数

5.3.1.3. 尾数

5.3.2. 特殊值

5.3.2.1. NaN

5.3.2.1.1. 非数字（not a number）

5.3.2.1.2. 表示无效操作（如除零）的结果

5.3.2.2. 正无穷和负无穷（Inf）

5.3.2.2.1. 当操作溢出时用作饱和值

5.3.3. 通过圆整和近似，才能使用相对少量的位数，表示很大范围中的小数

5.3.4. 比较浮点数

5.3.4.1. 确保它们的差在给定阈值内

5.3.4.2. 阈值=可能出现的最大圆整误差

5.3.4.2.1. machine epsilon

5.3.4.2.2. 随不同的编码变化

5.4. 精度值

5.4.1. Currency类型

5.4.1.1. 编码两个整数值，并且防范圆整问题

5.5. 任意大数

5.5.1. 宽度扩展为表示任意值所需的位数

5.5.2. 通过固定宽度的数值类型来构造出任意大数值

5.5.3. 没有对应的硬件表示

5.5.3.1. 芯片总是操作固定位数

6. 字符串

6.1. 用于表示文本

6.2. Unicode标准

6.2.1. 字符（character）

6.2.1.1. 文本的计算机表示

6.2.1.1.1. 警官表情符号U+1F46E、零宽连接字符串U+200D、女性符号U+2640 U+FEOF

6.2.2. 书写位（grapheme）

6.2.2.1. 用户看到的符号

6.2.2.1.1. 女警官

6.2.3. 字形（glyph）

6.2.3.1. 一个字符的特定表示

6.2.3.2. 加粗

6.2.3.3. 斜体

6.2.3.4. 字符的两种不同的视觉呈现

6.2.4. 每个Unicode字符被定义为一个代码点

6.2.4.1. 0x0～0x10FFFF之间的一个值

6.2.4.2. 共有1 114 111个代码点

6.2.5. UTF-32

6.2.5.1. 32位整数可以表示0x0～0xFFFFFFFF之间的值

6.2.5.2. 十分低效，没有使用的位浪费了大量空间

6.2.6. 变长编码

6.2.6.1. 为较小的代码点使用较少的位，随着值增大，使用的位数也增加

6.2.6.2. UTF-16

6.2.6.2.1. 能够用16位表示的代码点（从0x0～0xFFFF）由一个16位整数表示

6.2.6.2.2. 需要16位以上的位数的代码点（从0x10000～0x10FFFF）由两个16位值表示

6.2.6.3. UTF-8

6.2.6.3.1. 最流行的编码

6.2.6.3.2. 一个单元是8位

6.2.6.3.3. 代码点由1个、2个、3个或4个8位值来表示

6.3. 常见错误

6.3.1. 在字符级别而不是书写位级别操纵编码文本

6.3.2. 在字节级别而不是字符级别操纵编码文本

6.3.2.1. 在不知道编码的情况下

6.3.3. 采用错误的编码来将一个字节序列解释为文本

6.3.4. 解决方法

6.3.4.1. 确保使用正确的编码解释字节序列

6.3.4.2. 要依赖字符串库

6.3.4.3. 在字符和书写位级别操纵字符串

7. 数组和引用类型

7.1. 期望的访问模式（读频率与写频率）

7.2. 数据密度（稀疏与稠密）

7.3. 固定大小数组

7.3.1. 一个连续的内存区域

7.3.2. 存储了相同类型的值

7.3.3. 访问其中任何一个值都是速度很快的操作

7.3.3.1. 具有极快的读取/更新能力

7.3.4. 如果数组开始于base位置，元素大小为M，则索引N位置的元素存储在base + N×M

7.3.5. 数组不能在原位置增长或缩减

7.3.6. 追加元素开销大

7.3.7. 轻松地表示稠密数据

7.4. 引用

7.4.1. 保存对象的指针

7.4.2. 引用类型的值=变量的位

7.4.2.1. 可以找到该对象的地址

7.4.3. 对于变长数据结构效果更好

7.4.4. 轻松地表示稀疏数据

7.5. 特点

7.5.1. 代表特定的内存布局和访问模型

7.5.2. 数据结构的基本模块

7.5.3. 选择其中一种，也可以结合使用二者来高效地实现任何数据结构

7.5.4. 较低级别的结构

7.6. 高效列表

7.6.1. 大部分库将列表实现为具有额外容量的数组

7.6.1.1. 数组容量会呈现指数级增长

7.6.1.2. 当数据结构达到最大容量时，写操作需要把全部元素移动到一个新数组中，效率低

7.7. 关联数组

7.7.1. 字典或哈希表

7.7.2. 常被实现为一个固定大小的列表数组

7.7.3. 哈希函数接受任意类型的一个键，返回该固定数组的一个索引

7.7.3.1. 多个键可以映射到同一个索引

7.7.3.2. 好的哈希函数会确保键平均分布到列表中，使得各个列表的长度相近

7.7.4. 高效的关联数组

7.7.4.1. 增加数组大小

7.7.4.2. 减小列表

7.7.4.3. 找到平衡点

7.7.5. 较高级别的抽象

7.8. 链表

7.8.1. 访问第N个元素需要我们从链表的头开始，沿着每个结点的next指针前进，直到找到第N个结点

7.8.2. 以追加结点，而不需要修改任何现有代码

7.8.3. 遍历列表的开销大

7.8.3.1. 线性时间或O(n)复杂度

7.9. 二叉树

7.9.1. 一个N级树

7.9.1.1. Topic1

7.9.2. 稀疏

7.9.2.1. 让元素引用其他元素，而不是将整个数据结构放到一个固定大小的数组中

7.9.3. 稠密

7.9.3.1. 固定大小数组

7.9.3.1.1. 不改变树的级别，在树中追加结点的效率也很高

7.9.3.1.2. 增加级别，那么不但需要复制整个树，还需要使数组的大小加倍，以便为所有可能追加的新结点留出空间