docs(slice): slice parameter

Author: shipengqi

content/docs/basic/01_basic_type.md

@@ -68,7 +68,8 @@ type StringHeader struct {
 
 #### `+` 拼接字符串
 
-例如 `fmt.Println("hello" + s[5:])` 输出 `"hello, world"`。使用 `+` 来拼接两个字符串时，它会申请一块新的内存空间，大小是两个字符串的大小之和。拼接第三个字符串时，再申请一块新的内存空间，大小是三个字符串大小之和。这种方式每次运算都需要重新分配内存，会给内存分配和 GC 带来额外的负担，所以性能比较差。
+例如 `fmt.Println("hello" + s[5:])` 输出 `"hello, world"`。使用 `+` 来拼接两个字符串时，它会申请一块新的内存空间，大小是两个字符串的大小之和。
+拼接第三个字符串时，再申请一块新的内存空间，大小是三个字符串大小之和。**这种方式每次运算都需要重新分配内存，会给内存分配和 GC 带来额外的负担，所以性能较差**。
 
 #### fmt.Sprintf
 

content/docs/basic/03_slice.md

@@ -124,30 +124,38 @@ package main
 import "fmt"
 
 func appendFunc(s []int) {
-	s = append(s, 10, 20, 30)
+   s = append(s, 10, 20, 30)
 }
 
 func appendPtrFunc(s *[]int) {
    *s = append(*s, 10, 20, 30)
 }
 
 func main() {
-	sl := make([]int, 0, 10)
-
-	appendFunc(sl)
-	// appendFunc 修改的是 sl 的副本，len 和 cap 并没有被修改，下面的输出是 []
-	fmt.Println(sl) // []
-	// appendFunc，虽然没有修改 len 和 cap，但是底层数组是被修改了的，所以下面的输出会包含 10 20 30
-	fmt.Println(sl[:10]) // [10 20 30 0 0 0 0 0 0 0]
-	// 为什么 sl[:10] 和 sl[:] 的输出不同，是因为 go 的切片的一个优化
-	// slice[low:high] 中的 high，最大的取值范围对应着切片的容量（cap），不是单纯的长度（len）。
-	// sl[:10] 可以输出容量范围内的值，并且没有越界。
-	// sl[:] 由于 len 为 0，并且没有指定最大索引。high 则会取 len 的值，所以输出为 []
-	fmt.Println(sl[:]) // []
+   sl := make([]int, 0, 10)
+
+   appendFunc(sl)
+   // appendFunc 修改的是 sl 的副本
+   // 副本的 struct {
+   //    Data uintptr
+   //    Len  int
+   //    Cap  int
+   // }
+   // 副本的 len 和 cap 被修改了，但是不会影响外部 slice 的 len 和 cap，所以下面的输出是 []
+   fmt.Println(sl) // []
+   // appendFunc，虽然没有修改外部 slice 的 len 和 cap，
+   // 但是副本 `Data uintptr` 是一个指针的拷贝，和外部 slice 指向的是同一个底层数组
+   // 所以底层数组最终是被修改了的，所以下面的输出会包含 10 20 30
+   fmt.Println(sl[:10]) // [10 20 30 0 0 0 0 0 0 0]
+   // 为什么 sl[:10] 和 sl[:] 的输出不同，是因为 go 的切片的一个优化
+   // slice[low:high] 中的 high，最大的取值范围对应着切片的容量（cap），不只是单纯的长度（len）。
+   // sl[:10] 可以输出容量范围内的值，并且没有越界。
+   // sl[:] 由于 len 为 0，并且没有指定最大索引。high 则会取 len 的值，所以输出为 []
+   fmt.Println(sl[:]) // []
 
    slptr := make([]int, 0, 10)
    appendPtrFunc(&slptr)
-   // 这里传入的是切片的指针，会改变外层的 slptr
+   // 这里传入的是切片的指针，会改变外部的 slice slptr
    fmt.Println(slptr) // [10 20 30]
 }
 ```

content/docs/basic/05_function.md

@@ -10,7 +10,12 @@ weight: 5
 - 值传递：当传一个参数值到被调用的函数里面时，实际上是传了这个值的副本，被调用方和调用方两者持有不相关的两份数据。
 - 引用传递：当传一个参数值到被调用的函数里面时，实际是传了参数的指针，被调用方和调用方两者持有相同的数据，任意一方做出的修改都会影响另一方。
 
-Go 使用的是**值传递，不管参数是基本类型，结构体还是指针，都会对传递的参数进行拷贝，区别无非是拷贝的目标对象还是拷贝指针**。拷贝指针，也就是会同时出现两个指针指向原有的内存空间。
+Go 使用的是**值传递，不管参数是基本类型，结构体还是指针，都会对传递的参数进行拷贝，区别无非是拷贝的目标对象还是拷贝指针**。
+
+{{< callout type="info" >}}
+拷贝指针，也就是会同时出现两个指针指向原有的内存空间。
+{{< /callout >}}
+
 
 ```go
 package main

content/docs/practice/06_performance.md

@@ -171,7 +171,7 @@ func main() {
 
 编译器决定内存分配位置的方式，就称之为**逃逸分析**(escape analysis)。逃逸分析由编译器完成，作用于编译阶段。
 
-变量逃逸是指编译器将一个变量从栈上分配到对上的情况。
+变量逃逸是指编译器将一个变量从栈上分配到堆上的情况。
 
 在 Go 中，栈是跟函数绑定的，函数结束时栈被回收。如果一个变量分配在栈中，则函数执行结束可自动将内存回收。如果分配在堆中，则函数执行结束可交给 GC（垃圾回收）处理。
 

content/docs/project/16_casbin.md

@@ -683,7 +683,7 @@ m = r.sub == p.sub && ReverseMatch(r.obj, p.obj) && r.act == p.act
 
 ## Enforcer
 
-Casbin [Enforcer(https://casbin.org/zh/docs/enforcers) 执行器往内存中缓存策略数据时并**不是并发安全**的，
+Casbin [Enforcer](https://casbin.org/zh/docs/enforcers) （执行器）往内存中缓存策略数据时并**不是并发安全**的，
 所以 Casbin 还实现了多种 `Enforcer`，可以分为并发安全的 `SyncedEnforcer`，带缓存的 `CachedEnforcer` 等等。
 
 - `Enforcer`：基础的执行器，内存中的操作不是并发安全的。