码厩技术博客

#433 Golang：new 和 make

$ go doc builtin.new
package builtin // import "builtin"

func new(Type) *Type
    The new built-in function allocates memory. The first argument is a type,
    not a value, and the value returned is a pointer to a newly allocated zero
    value of that type.

$ go doc builtin.make
package builtin // import "builtin"

func make(t Type, size ...IntegerType) Type
    The make built-in function allocates and initializes an object of type
    slice, map, or chan (only). Like new, the first argument is a type, not a
    value. Unlike new, make's return type is the same as the type of its
    argument, not a pointer to it. The specification of the result depends on
    the type:

        Slice: The size specifies the length. The capacity of the slice is
        equal to its length. A second integer argument may be provided to
        specify a different capacity; it must be no smaller than the
        length. For example, make([]int, 0, 10) allocates an underlying array
        of size 10 and returns a slice of length 0 and capacity 10 that is
        backed by this underlying array.
        Map: An empty map is allocated with enough space to hold the
        specified number of elements. The size may be omitted, in which case
        a small starting size is allocated.
        Channel: The channel's buffer is initialized with the specified
        buffer capacity. If zero, or the size is omitted, the channel is
        unbuffered.

• func new(Type) *Type
• func make(t Type, size ...IntegerType) Type

new 和 make 的区别

1. new 没有类型限制，make 只能用来分配和初始化 slice，map，chan。
2. new 返回指针，make 返回引用（引用类型的值）。
3. new 会将分配的空间置零（对应类型的零值），make 则可以类型初始化，比如 slice 的长度和容量。

package main

import "fmt"

type User struct {
    Name string
}

type Addr struct{}

func main() {
    user1 := new(User)
    user2 := new(User)
    fmt.Printf("%#v (%p) %d\n", user1, user1, &user1)
    fmt.Printf("%#v (%p) %d\n", user2, user2, &user2)
    fmt.Printf("user1 == user2 : %#v\n", user1 == user2)

    addr1 := new(Addr)
    addr2 := new(Addr)
    fmt.Printf("%#v (%p) %d\n", addr1, addr1, &addr1)
    fmt.Printf("%#v (%p) %d\n", addr2, addr2, &addr2)
    fmt.Printf("addr1 == addr2 : %#v\n", addr1 == addr2)
}

&main.User{Name:""} (0xc00006a250) 824633745448
&main.User{Name:""} (0xc00006a260) 824633745456
user1 == user2 : false
&main.Addr{} (0xf61438) 824633745472
&main.Addr{} (0xf61438) 824633745480
addr1 == addr2 : true

注意上面这一点，空 struct 多次 new 出的指针完全相同。暂时没有想明白这样设计的好处。

#432 Go 关键字

25 个关键字

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

声明 (4)

1. var 变量
2. const 常量
3. type 类型
4. func 函数

并发相关 (3)

1. go 并发
2. chan 信道
3. select 分支

类型 (3)

1. interface 接口
2. map 映射
3. struct 结构体

流程控制 (3 + 4 + 6)

1. defer 延迟执行
2. goto 跳转
3. return 返回

循环 (4)

1. for
2. continue
3. break
4. range 用于读取 slice、map、channel 数据

分支 (6)

1. if
2. else
3. switch
4. case
5. default
6. fallthrough

包 (2)

1. package
2. import

39 个预定义标识符

Types:
    any bool byte comparable
    complex64 complex128 error float32 float64
    int int8 int16 int32 int64 rune string
    uint uint8 uint16 uint32 uint64 uintptr

Constants:
    true false iota

Zero value:
    nil

Functions:
    append cap close complex copy delete imag len
    make new panic print println real recover

值 (4)

1. true
2. false
3. iota
4. nil

类型 (20 + 2)

int (10)

1. int
2. int8
3. int16
4. int32
5. int64
6. uint
7. uint8
8. uint16
9. uint32
10. uint64

complex (2)

1. complex64
2. complex128

float (2)

1. float32
2. float64

字符与字符串 (3)

1. byte => uint8
2. rune => int32
3. string

泛型相关 (2) Go1.18+

1. any
2. comparable

其他 (3)

1. bool
2. uintptr 指针
3. error 一个内置的 interface

Builtin 函数 (15)

1. append
2. delete

3. close

4. cap

5. len

6. copy

7. make

8. new

9. panic

10. recover

11. print

12. println

13. real

14. imag
15. complex

#431 Go 模板

fmt.Sprintf 字符串格式化

tpl := `[%s] Your verify code is %s.`
s := fmt.Sprintf(tpl, "Markjour", "1234")
println(s)

os.Expand 变量替换

tpl := `[${sign}] Your verify code is ${code}.`
params := map[string]string{"sign": "Markjour", "code": "1234"}
println(os.Expand(tpl, func(k string) string { return params[k] }))

text/template 和 html/template

这两个就可以处理复杂的情况，嵌套模板，控制语句都支持。

package main

import (
    "os"
    "text/template"
)

func main() {
    tpl := `[{{.sign}}] Your verify code is {{.code}}.`
    t := template.New("just-a-name")
    t, _ = t.Parse(tpl)
    params := map[string]string{"sign": "Markjour", "code": "1234"}
    t.Execute(os.Stdout, params)
}

附：strings.Map / bytes.Map 提供单个字符的替换

func Map(mapping func(rune) rune, s string) string

package main

import (
    "fmt"
    "strings"
)

const A = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ \n"
const B = "N'|&4:@ j{BI+Y!H/Q_iR\\FM}$moLe?#X\"WCE3S,8(r1f%T.;6DbaG]y`q~ltJxu-k2gA\nvhnd=)*s7Z5p^OK[V0z>9<UcwP"

func main() {
    encrypt := func(r rune) rune {
        if !strings.ContainsRune(A, r) {
            return 0
        }
        return rune(B[strings.IndexRune(A, r)])
    }
    decrypt := func(r rune) rune {
        if !strings.ContainsRune(B, r) {
            return 0
        }
        return rune(A[strings.IndexRune(B, r)])
    }

    raw := "Life was like a box of chocolate, you never know what you're gonna get."
    fmt.Println(raw)

    encrypted := strings.Map(encrypt, raw)
    fmt.Println(encrypted)
    // 3j:4wFN_wIjB4wNw'!Mw!:w| !|!INi4dw}!RwY4\4QwBY!FwF Niw}!RAQ4w@!YYNw@4i)

    decrypted := strings.Map(decrypt, encrypted)
    fmt.Println(decrypted)
}

参考资料与拓展阅读

• CSDN, cheniie, Go 字符串模板替换

#430 转载：Python 异步编程与数据库

这是大神 zzzeek 2015 年发表的一篇文章，详细介绍了关于 SQLAlchemy 与异步编程的一些事情。解答了我关于如何实现异步编程的一些疑惑。
我曾反复阅读这篇文章好多遍，以求能够更加准确地领会到大佬阐述的意思。我认为每个 Python 的使用者都应该阅读阅读。

#429 Golang: cannot assign to struct field xxx in map

package main

import (
    "fmt"
)

type Person struct {
    FirstName string
    LastName  string
}

func main() {
    // 准备 =========================
    people := make(map[int]Person)
    person := Person{
        FirstName: "John",
        LastName:  "Doe",
    }
    people[1] = person

    // 报错：cannot assign to struct field people[1].FirstName in map
    // people[1].FirstName = "Jim"

    // 方式 1
    p := people[1]
    p.FirstName = "Alice"
    people[1] = p
    fmt.Println(people)
    // map[1:{Alice Doe}]
    fmt.Println(people[1])
    // {Alice Doe}

    // if p, ok := people[1]; ok {
    //  p.Field = 5
    //  people[1] = p
    // }

    // 方式 2
    people2 := make(map[int]*Person)
    people2[1] = &person
    people2[1].FirstName = "Adam"
    fmt.Println(people2)
    // map[1:0xc000060020]
    fmt.Println(people2[1])
    // &{Adam Doe}
}

总之，不能直接通过 key 找到 value（struct），然后修改其中的一个字段。

#428 Java 现状

谷歌 Java 趋势

Oracle Java SE Support Roadmap

PS：Java 9 开始引入了新的模块机制，标准库结构。

PS: 2021 年 Java 17 发布时，Oracle 宣布以后每两年一个 LTS 版本，也就是说下一个 LTS 版本是 21 而非 23。

参考资料与拓展阅读

• Oracle, https://www.oracle.com/java/technologies/java-se-support-roadmap.html
• 维基百科(en), Java version history

#427 BOM 头的研究

BOM 是 Byte Order Mark 的缩写，代表一个 Unicode 字符 FEFF。
Windows 系统下的很多软件就用 BOM 字符作为 Magic Number, 用来确认文件的字符编码和字节顺序。

#426 字符编码

从原理上来讲，我们的计算机其实只认识数字（要不然为什么叫做计算机），确切的说是 0 和 1，我们的文字信息存放在计算机中也是以数字形式存在。
所谓字符编码就是字符和数字之间的对应关系和转换规则。

#425 “锟斤拷” 到底是个啥？

手持两把锟斤拷，
口中疾呼烫烫烫。
脚踏千朵屯屯屯，
笑看万物锘锘锘。

开发者经常这样调侃编码问题：手持两把锟斤拷，口中疾呼烫烫烫。

程序员都知道字符编码，比如 ASCII，GBK，UTF-8，那肯定能理解这些神奇的 “乱码” 出现的原因，肯定是某些地方没有正确处理编码。

那为什么总是能看见 锟斤拷，烫烫烫呢？其背后隐藏更深的原因是啥？

#424 Golang 数据类型

基础类型：

• Boolean types (bool)
• Numeric types
• String types (string)

复合类型：

• Array types ([len]Type)
• Slice types ([]Type)
• Struct types (struct)
• Map types (map[KeyType]ValueType{})

特殊类型：

• Pointer types (*Type) 指针
• Function types (func) 函数
• Interface types (interface) 接口
• Channel types (chan) 通道

引用类型

基础类型 + Array + Struct 不是引用类型，其他几种（Slice + Map + Pointer + Function + Interface + Channel）都是引用类型，函数传参的时候需要记住这一点。

数值

uint8       the set of all unsigned  8-bit integers (0 to 255)
uint16      the set of all unsigned 16-bit integers (0 to 65535)
uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

byte        alias for uint8
rune        alias for int32

// 实现相关：
uint     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

声明

var foo int

var foo int = 1

foo := 1

const foo = 1

const foo int = 1

注意：只有基础类型可以声明为常量。