## 数组
语法是：
[CAP] Type
1. 初始化要指定长度（或者叫做容量）
2. 可以直接初始化
3. arr[i]的形式访问元素
4. len和cap操作用于获取数组长度
5. 使用for range 来循环




![image.png](/static/img/0bbfb90f75d56a99e3ad4e2db549a293.image.png)
## 切片
语法是： []type
1. 直接初始化
2. make初始化：make([]type,length,capacity)
3. arr[i]的形式访问元素
4. append追加元素
5. len获取元素数量
6. cap获取切片容量
7. 推荐写法: s1:=make([]type,0,capacity)
8. 使用for range来遍历


![image.png](/static/img/02255102c513e29b7236f209ce600689.image.png)

___
数组和切片的区别

![image.png](/static/img/5938606000d5ea17a737c6c81717b399.image.png)


:::info{title="如何理解切片？"}
最直观的对比：ArrayList，即基于数组的list的实现，切片的底层也是数组

跟Array的区别：
1. 切片操作是有限的，不支持随机增删（即没有add，delete方法，需要自己写代码）
2. 只有append操作
3. 切片支持子切片操作，和原本切片是共享底层数组
:::
### 子切片
数组和切片都可以通过[start:end]的形式来获取子切片：
1. arr[start:end]，获得[start,end)之间的元素
2. arr[:end],获得[0,end)之间的元素
3. arr[start:]，获得[start,len(arr))之间的元素。


![image.png](/static/img/f9bb5b1900fbe7ab81c4fd32a6f0a0f5.image.png)


:::warning{title="内存共享问题"}
核心：共享数组

子切片和切片究竟会不会互相影响，就抓住一点：他们是不是还共享数组？

什么意思？
1. 就是如果它们结构没有变化，那肯定是共享的；但是结构变化了，就可能不是共享了。

什么情况下结构会变化？ **扩容了**

所以，切片与子切片，切片作为参数传递到别的方法、结构体里面，任何情况下你要判断是否内存共享，那么就一点：**有没有扩容**
:::


![image.png](/static/img/cbce5b2277c5ffc8bc8de9e6eca2b4a4.image.png)


## map
map是go里面的内置类型之一，使用起来也很简单。
* 初始化
    * make方法：记得预估容量
    * 直接初始化元素

* 赋值：使用中括号


![image.png](/static/img/e912a21e160d7ad9e6979879de1eddf9.image.png)


读取元素：有两个返回值
* 第一个是值，第二个是这个元素是否存在
* 如果只有一个返回值，那么就是对应的元素；元素不存在，那么就是对应类型的零值


![image.png](/static/img/6ef8429b32ab3baa5a0d71e44af00576.image.png)

读取长度：len
* 遍历：for，第一个是key，第二个是value
* 删除：使用delete方法

注意：map的遍历是随机的，也就是你遍历两边，输出的结果都不一样。


![image.png](/static/img/f91dc44f5a44a22d4398b7ed350c4cc7.image.png)

### comparable概念
* 在Switch里面，值必须是可比较的
* 在map里面，key也必须是可比较的

所谓可比较的，在go里面就是指：GO在编译的时候、运行的时候能够判断出来元素是不相等的。

初学的时候，你就知道：
* 基本类型和string都是可比较的
* 如果元素是客比较的，那么该数据也是可比较的

参考这里的[详细说明](https://go.dev/ref/spec#Comparison_operators)

面试也基本不可能面到这个内容，你有一个概念就行。


### 代码演示
1. go是强类型语言，能不能设计一个方法，可以计算任意数字类型切片的和的方法？
    * func SumInt64([]int64)只能用于int64
    * func SumInt32([]int32)只能用于int32
    * ……
3. 获得map的所有key、所有value
## channel：这个后面讲并发的时候再讲

05 内置类型：数组与切片

## 方法声明

* 四个部分
```
    * 关键字func
    * 方法名字：首字母是否大写决定了作用域
    * 参数列表：[<name type>]
    * 返回列表: [<name type>]
```    
    


名字+参数列表+返回值，也叫做方法签名（signatrue）
    
   
![image.png](/static/img/9665bf0ae39d06b926b1bafd9376751b.image.png)
    

## 方法声明：返回值

Go的方法和别的语言比起来，有一个很大的不同：

 * 可以有很多个返回值，并且返回值可以有名字

带名字的返回值，就相当于你声明了一个作用域在整个方法的局部变量。
    
用不用带名字的返回值纯粹是个人风格，你看自己喜好。

    
![image.png](/static/img/1e86f1d8e492ae2158810d49c960f555.image.png)
    
## 方法调用
方法调用只需要用足够的参数去接受返回值，并且传入了调用参数就可以。
    
有多个返回值的时候，如果你忽略一些返回值，可以使用 _
    
> 记住一条核心原则：同一个作用域内，如果左边出现了新的变量，那么就需要使用:=来接受返回值。
    
    
![image.png](/static/img/8d7318ad19624be8a3fc50f18e9b0ad8.image.png)


## 方法调用：递归

一个方法内部可以调用它自己，这就是所谓的递归

递归要小心，如果递归嵌套太深的话，可能会出现栈溢出错误。
* 治标的话，栈溢出可以考虑通过增加栈大小来解决
* 治本的话，还是要找到对应的递归代码，进行修改。


![image.png](/static/img/0cff9dd3549d8a986c06fd120f6de0d0.image.png)

    

## 函数式编程入门：方法做为变量

方法本身就可以赋值给某个变量，而这个变量就可以直接发起调用。

下图中的myFunc3本质上是一个变量，只不过这个变量等于Func3


![image.png](/static/img/a9af2d27583644263dcb36e243f77806.image.png)


## 函数式编程入门：局部方法
可以在方法内部声明一个局部方法，它的作用域就在本方法内


![image.png](/static/img/7f3da622e3903900bcda6a8fdf6792bb.image.png)
    

## 函数式编程入门：方法作为返回值
方法可以作为返回值

注意，不是方法的返回值，是方法本身就可以作为返回值

后面你们经常会看到我的这种用法，它本身也是闭包的一种应用

右图中的sayhello就是返回来的那个方法，所以可以直接调用


![image.png](/static/img/9ec0902ee4c2d8de9c0d762498621414.image.png)


## 函数式编程入门：匿名方法发起调用

在前面你已经见过声明一个匿名方法，然后赋值给一个变量

那么你也可以声明一个匿名方法，而后可以立刻发起调用

右图中hello就是匿名函数直接发起调用之后返回的数据

这种用法在defer中用的多。


![image.png](/static/img/9e77029fdf9f11f829149c2f97b53a5e.image.png)
    



## 函数式编程入门：闭包

闭包，方法+它绑定的运行上下文

图返回的是闭包，它由两部分构成：
* 方法
* 运行时上下文：它只引用啦name这一个变量

闭包也是一个面试redden，所以你至少需要记住闭包的定义。

闭包如果使用不当可能会引起内存泄漏的问题。即一个对象被闭包引用的话，它是不会被垃圾回收的。

记住这个结论，后面面试用得上。


![image.png](/static/img/50a0e522ca3e131039b4a37bf4324f10.image.png)


## 不定参数

GO支持不定参数。不定参数是指最后一个参数，可以传入任意多个值

注意必须是最后一个参数才可以声明为不定参数

不定参数在方法内部可以被当成切片来使用。

Option模式大量应用来不定参数。


![image.png](/static/img/bcd659bdd972ab9b691e0ddbf5af8485.image.png)

## defer
Go里面有一个机制，允许你从方法返回的前一刻，执行一段逻辑

这个也就是defer，也叫做延迟调用

defer类似栈，也就是后进先出。也就是，先定义的后执行；后定义的先执行。

图中我们利用匿名函数定义了两个defer

![image.png](/static/img/e1203297898cc6fa6097b3309d9300f8.image.png)

图中的这种写法：叫做匿名函数的立刻发现调用。

![image.png](/static/img/669c018d7fd5884d92aaa71829461ab0.image.png)


## defer 与闭包

我们通常都用闭包来写defer，所以就会涉及到一个问题，就是defer执行的时候怎么确定里面的值？

![image.png](/static/img/c0039578cc9477502e7a418cbde8fc7d.image.png)
输出：1

确定值的原则：
* 作为参数传入的：定义defer的时候就确定来。
* 作为闭包引入的：执行defer对应的方法时候才确定


![image.png](/static/img/51e0a0ec6bbf989ca1fcc78787c8c141.image.png)


## defer修改返回值

如果是带名字的返回值，那么可以修改这个返回值，否则不能修改。

![image.png](/static/img/77801b735ce7ad44d611c8cdc27416ba.image.png)

![image.png](/static/img/4123f84046ed307f7fa0836e90c39c19.image.png)
注意：最右边的并没有修改a，而是修改a指向的结构体

03 基础语法：方法声明与调用

## What does a typical microservice architecture look like?

![image.png](/static/img/617c84ab0bca1e58cc8880a6e8c1bbaf.image.webp)



以下是一个典型的微服务架构示意图。

* 负载均衡器：这将传入流量分发给多个后端服务。
* CDN（内容分发网络）：CDN是一组地理分布的服务器，保存静态内容以实现更快的交付。客户端首先在CDN中查找内容，然后转向后端服务。
* API 网关：这处理传入请求并将其路由到相关服务。它与身份提供者和服务发现进行通信。
* 身份提供者：这处理用户的身份验证和授权。
* 服务注册与发现：微服务的注册和发现发生在这个组件中，API 网关在这个组件中查找相关服务进行通信。
* 管理：这个组件负责监控服务。
* 微服务：微服务被设计并部署在不同的领域。每个领域都有自己的数据库。API 网关通过REST API或其他协议与微服务通信，同一领域内的微服务使用RPC（远程过程调用）相互通信。

微服务的好处：

* 它们可以快速设计、部署和水平扩展。
* 每个领域可以由专门的团队独立维护。
* 由于如此，每个领域的业务需求可以进行定制并得到更好的支持。


## Microservice Best Practices
A picture is worth a thousand words: 9 best practices for developing microservices.

![image.png](/static/img/9abac607bf96528e0704f6f7fb302135.image.webp)

当我们开发微服务时，我们需要遵循以下最佳实践：

1. 为每个微服务使用单独的数据存储
2. 保持代码在相似的成熟水平
3. 为每个微服务分别构建
4. 将每个微服务分配给单一的职责
5. 部署到容器中
6. 设计无状态服务
7. 采用领域驱动设计
8. 设计微前端
9. 编排微服务
## What tech stack is commonly used for microservices?
Below you will find a diagram showing the microservice tech stack, both for the development phase and for production.


![image.png](/static/img/f9d99399348b362b0bb2885d80000619.image.webp)

▶️ 𝐏𝐫𝐞-𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧

* 定义 API - 这为前端和后端之间建立了合同。我们可以使用 Postman 或 OpenAPI 来实现这一点。
* 开发 - Node.js 或 React 在前端开发中很受欢迎，而 Java/Python/Go 则常用于后端开发。此外，我们需要根据 API 定义在 API 网关中更改配置。
* 持续集成 - 使用 JUnit 和 Jenkins 进行自动化测试。代码被打包成 Docker 镜像，并作为微服务进行部署。

▶️ 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧

* NGinx 是负载均衡器的常见选择。Cloudflare 提供 CDN（内容传送网络）。
* API 网关 - 我们可以使用 Spring Boot 来构建网关，并使用 Eureka/Zookeeper 进行服务发现。
* 微服务部署在云上。我们可以选择 AWS、Microsoft Azure 或 Google GCP。缓存和全文搜索 - Redis 是缓存键值对的常见选择。Elasticsearch 用于全文搜索。
* 通信 - 为了让服务相互通信，我们可以使用消息基础设施 Kafka 或 RPC。
* 持久化 - 我们可以使用 MySQL 或 PostgreSQL 作为关系型数据库，使用 Amazon S3 作为对象存储。如果需要，我们还可以使用 Cassandra 作为宽列存储。
* 管理与监控 - 为了管理如此多的微服务，常见的运维工具包括 Prometheus、Elastic Stack 和 Kubernetes。
## why is Kafka fast?
There are many design decisions that contributed to Kafka’s performance. In this post, we’ll focus on two. We think these two carried the most weight.

![image.png](/static/img/09f9ede91f1c708ea6dc191fd2251760.image.webp)

第一个是Kafka对顺序I/O的依赖。

赋予Kafka性能优势的第二个设计选择是其对效率的关注：零拷贝原则。
该图说明了数据如何在生产者和消费者之间传输，以及什么是零拷贝。

步骤1.1 - 1.3：生产者将数据写入磁盘

步骤2：消费者在不使用零拷贝的情况下读取数据

2.1 数据从磁盘加载到操作系统缓存

2.2 数据从操作系统缓存复制到Kafka应用程序

2.3 Kafka应用程序将数据复制到套接字缓冲区

2.4 数据从套接字缓冲区复制到网卡

2.5 网卡将数据发送给消费者

步骤3：消费者使用零拷贝读取数据

3.1：数据从磁盘加载到操作系统缓存

3.2 操作系统缓存通过sendfile()命令直接将数据复制到网卡

3.3 网卡将数据发送给消费者

零拷贝是一种捷径，用于节省应用程序上下文和内核上下文之间的多次数据拷贝。

06 Microservice architecture

## Data is cached everywhere



![image.png](/static/img/0d463181a8771e3507d67f5754cc3bab.image.webp)

流程中存在多个层次。

1. 客户端应用：HTTP响应可以被浏览器缓存。首次通过HTTP请求数据时，返回的数据带有HTTP头中的过期策略；再次请求数据时，客户端应用会先尝试从浏览器缓存中检索数据。
2. CDN：CDN缓存静态网络资源。客户端可以从附近的CDN节点检索数据。
3. 负载均衡器：负载均衡器也可以缓存资源。
4. 消息基础设施：消息代理首先将消息存储在磁盘上，然后消费者以自己的速度检索它们。根据保留策略，数据在Kafka集群中被缓存一段时间。
5. 服务：服务中存在多层缓存。如果数据未缓存在CPU缓存中，服务将尝试从内存中检索数据。有时服务还有第二级缓存，用于在磁盘上存储数据。
6. 分布式缓存：像Redis这样的分布式缓存在内存中保存多个服务的键值对。它提供比数据库更好的读/写性能。
7. 全文搜索：我们有时需要使用全文搜索，如Elasticsearch进行文档搜索或日志搜索。数据的副本也被索引到搜索引擎中。
8. 数据库：即使在数据库中，我们也有不同级别的缓存：
9. WAL（预写式日志）：在构建B树索引之前，数据首先被写入WAL。
10. 缓冲池：用于缓存查询结果的内存区域。
11. 物化视图：预先计算查询结果，并将其存储在数据库表中，以提高查询性能。
12. 事务日志：记录所有事务和数据库更新。
13. 复制日志：用于记录数据库集群中的复制状态。
## Why is Redis so fast?
There are 3 main reasons as shown in the diagram below.

![image.png](/static/img/e9fdaadbd9571c6161e097bc291df263.image.webp)

* Redis是基于RAM的数据存储。RAM访问速度至少比随机磁盘访问快1000倍。
* Redis利用IO多路复用和单线程执行循环来提高执行效率。
* Redis利用了几种高效的低层数据结构。
> Question: Another popular in-memory store is Memcached. Do you know the differences between Redis and Memcached?

> You might have noticed the style of this diagram is different from my previous posts. Please let me know which one you prefer.

Redis和Memcached都是流行的内存键值数据存储，但它们有一些区别：

数据类型：Redis支持更复杂的数据类型，如字符串、列表、集合、有序集合、哈希、位图和地理空间索引，而Memcached只支持简单的键值对。

持久性：Redis通过将数据写入磁盘提供持久性，而Memcached没有内置的持久性特性。

数据驱逐策略：Redis允许更复杂的数据驱逐策略，而Memcached使用简单的LRU（最近最少使用）算法进行数据驱逐。

复制：Redis支持主从复制和自动分区，而Memcached没有内置的复制支持。

内置数据操作：Redis内置支持排序、排名和范围查询等操作，而这些功能在Memcached中不可用。
## How can Redis be used?

![image.png](/static/img/e6fc3c5eca4ac07c3e5e4bb731e26753.image.webp)

Redis不仅仅是用于缓存。

如图所示，Redis可以在各种场景下使用。

1. 会话：我们可以使用Redis在不同服务之间共享用户会话数据。
2. 缓存：我们可以使用Redis缓存对象或页面，特别是对于热点数据。
3. 分布式锁：我们可以使用Redis字符串在分布式服务之间获取锁。
4. 计数器：我们可以统计文章的点赞次数或阅读次数。
5. 速率限制器：我们可以为特定用户IP应用速率限制器。
6. 全局ID生成器：我们可以使用Redis Int作为全局ID。
7. 购物车：我们可以使用Redis Hash来表示购物车中的键值对。
8. 计算用户留存：我们可以使用Bitmap表示用户每日登录情况并计算用户留存。
9. 消息队列：我们可以使用List作为消息队列。
10. 排名：我们可以使用ZSet对文章进行排序。


## Top caching strategies
Designing large-scale systems usually requires careful consideration of caching. Below are five caching strategies that are frequently utilized.

![image.png](/static/img/da9a95d8d18c3a1e2e0ff32f1137b8f0.image.webp)

05 Cache

## A nice cheat sheet of different databases in cloud services
云服务中不同数据库的便捷速查表



![image.png](/static/img/3305fd5890ba906dbe27ed266d4e7a7e.image.webp)

为您的项目选择合适的数据库是一项复杂的任务。许多数据库选项，每个都适合不同的用例，可能会迅速导致决策疲劳。

我们希望这个速查表能为您提供高层次的指导，以确定符合您项目需求的正确服务，并避免潜在的陷阱。

注意：谷歌对其数据库用例的文档有限。尽管我们尽力查看了可用内容并得出了最佳选项，但某些条目可能需要更准确。

## 8 Data Structures That Power Your Databases
数据库索引格式的选择取决于您的具体使用场景。数据可以在内存中或在磁盘上进行索引。同样，数据格式也各不相同，例如数字、字符串、地理坐标等。系统可能是写操作密集型或读操作密集型。所有这些因素都会影响您对数据库索引格式的选择。

![image.png](/static/img/eb83b8cde5e563bc80905c4c8a03e707.image.webp)
以下是一些用于索引数据的最流行的数据结构：

* 跳跃表：一种常见的内存中索引类型。在Redis中使用
* 哈希索引：“映射”数据结构（或“集合”）的一种非常常见的实现
* SSTable：不可变的磁盘上“映射”实现
* LSM树：跳跃表+SSTable。高写入吞吐量
* B树：基于磁盘的解决方案。一致的读写性能
* 倒排索引：用于文档索引。在Lucene中使用
* 后缀树：用于字符串模式搜索
* R树：多维搜索，例如查找最近邻居

## How is an SQL statement executed in the database?
下面这张图展示了这个过程。请注意，不同数据库的架构是不同的，这张图展示了一些常见的设计。

![image.png](/static/img/bd0944cba7266890c39d53d952ff9b4a.image.webp)

第一步 - 通过传输层协议（例如TCP）将SQL语句发送到数据库。

第二步 - SQL语句被发送到命令解析器，在那里它经过语法和语义分析，然后生成查询树。

第三步 - 查询树被发送到优化器。优化器创建执行计划。

第四步 - 执行计划被发送到执行器。执行器从执行中检索数据。

第五步 - 访问方法提供执行所需的数据获取逻辑，从存储引擎检索数据。

第六步 - 访问方法决定SQL语句是否是只读的。如果查询是只读的（SELECT语句），它将被传递给缓冲区管理器进行进一步处理。缓冲区管理器在缓存或数据文件中查找数据。

第七步 - 如果语句是UPDATE或INSERT，它将被传递给事务管理器进行进一步处理。

第八步 - 在事务期间，数据处于锁定模式。这是由锁管理器保证的。它还确保事务的ACID属性。

## CAP theorem
CAP定理是计算机科学中最著名的术语之一，但我敢打赌不同的开发者有不同的理解。让我们来探讨一下它是什么以及为什么它可能会令人困惑。

![image.png](/static/img/3122a2c7053d29c0a2f428b36209cd55.image.webp)

CAP定理指出，一个分布式系统不能同时提供以下三个保证中的两个以上。

* 一致性：一致性意味着所有客户端在任何时间点都能看到相同的数据，无论它们连接到哪个节点。
* 可用性：可用性意味着任何请求数据的客户端都会得到响应，即使某些节点宕机。
* 分区容错性：分区表示两个节点之间的通信中断。分区容错性意味着系统在网络分区的情况下继续运行。

“三选二”的表述可能是有用的，但这种简化可能会产生误导。

1. 选择一个数据库并不容易。仅仅基于CAP定理来证明我们的选择是不够的。例如，公司不会仅仅因为Cassandra是一个AP系统就选择它用于聊天应用。有一系列良好的特性使得Cassandra成为存储聊天消息的理想选择。我们需要更深入地挖掘。

2. “CAP只禁止了设计空间的一小部分：在存在分区的情况下实现完美的可用性和一致性，这种情况很少见。”引自论文：CAP十二年后：规则如何改变。

3. 该定理关注的是100%的可用性和一致性。一个更现实的讨论应该是在没有网络分区的情况下，延迟和一致性之间的权衡。更多细节请参见PACELC定理。

> CAP定理真的有用吗？

我认为它仍然有用，因为它为我们打开了一系列权衡讨论的思路，但它只是故事的一部分。在选择正确的数据库时，我们需要更深入地挖掘。
## Types of Memory and Storage

![image.png](/static/img/7460a79564520312d26b7022744f7227.image.webp)

## Visualizing a SQL query

![image.png](/static/img/22facac2fe64779c929cdeb84917e2f0.image.webp)

SQL语句的执行涉及多个步骤，包括：

1. 解析SQL语句并检查其有效性；
2. 将SQL转换为内部表示形式，如关系代数；
3. 优化内部表示并创建利用索引信息的执行计划；
4. 执行计划并返回结果。

SQL的执行非常复杂，涉及许多考虑因素，例如：

1. 索引和缓存的使用；
2. 表连接的顺序；
3. 并发控制；
4. 事务管理。
## SQL language
在1986年，SQL（结构化查询语言）成为了一个标准。在接下来的40年里，它成为了关系数据库管理系统的主导语言。阅读最新的标准（ANSI SQL 2016）可能会很耗时。我该如何学习它？
![image.png](/static/img/f01faa58f4c165c9d0a8f175e3610db2.image.webp)


SQL语言有5个组成部分：

1. DDL：数据定义语言，如CREATE、ALTER、DROP
2. DQL：数据查询语言，如SELECT
3. DML：数据操作语言，如INSERT、UPDATE、DELETE
4. DCL：数据控制语言，如GRANT、REVOKE
5. TCL：事务控制语言，如COMMIT、ROLLBACK

作为一个后端工程师，你可能需要了解其中的大部分。作为一个数据分析师，你可能需要对DQL有很好的理解。选择与你最相关的主题进行学习。