### 注释

​ 注释不会被编译，每一个包应该有相关注释。

​ 单行注释是最常见的注释形式，你可以在任何地方使用以 `//` 开头的单行注释。多行注释也叫块注释，均已以 `/*` 开头，并以 `*/` 结尾。如：

```go
// 单行注释
/*
Author by 菜鸟教程
我是多行注释
*/
```

### 标识符

​ 标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母`(A~Z和a~z)`数字`(0~9)`、下划线`_`组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

## 关键字

下面列举了 Go 代码中会使用到的 25 个关键字或保留字：

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

除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：

|        |         |         |         |        |         |           |            |         |
| ------ | ------- | ------- | ------- | ------ | ------- | --------- | ---------- | ------- |
| append | bool    | byte    | cap     | close  | complex | complex64 | complex128 | uint16  |
| copy   | false   | float32 | float64 | imag   | int     | int8      | int16      | uint32  |
| int32  | int64   | iota    | len     | make   | new     | nil       | panic      | uint64  |
| print  | println | real    | recover | string | true    | uint      | uint8      | uintptr |

程序一般由关键字、常量、变量、运算符、类型和函数组成。

程序中可能会使用到这些分隔符：括号 ()，中括号 \[\] 和大括号 {}。

程序中可能会使用到这些标点符号：`.`、`,`、`;`、`:`

### 格式化字符串

### Go 语言中使用 fmt.Sprintf 或 fmt.Printf 格式化字符串并赋值给新串：

- **Sprintf** 根据格式化参数生成格式化的字符串并返回该字符串。

- **Printf** 根据格式化参数生成格式化的字符串并写入标准输出。

- ```go
    package main

    import (
            "fmt"
            "io"
            "os"
        )

    func main() {
            // go 中格式化字符串并赋值给新串，使用 fmt.Sprintf
            // %s 表示字符串
            var stockcode="000987"
            var enddate="2020-12-31"
            var url="Code=%s&endDate=%s"
            var target_url=fmt.Sprintf(url,stockcode,enddate)
            fmt.Println(target_url)

            // 另外一个实例，%d 表示整型
            const name, age = "Kim", 22
            s := fmt.Sprintf("%s is %d years old.\n", name, age)
            io.WriteString(os.Stdout, s) // 简单起见，忽略一些错误
        }
  ```

- ```go
        package main

        import (
            "fmt"
        )

        func main() {
           // %d 表示整型数字，%s 表示字符串
            var stockcode=123
            var enddate="2020-12-31"
            var url="Code=%d&endDate=%s"
            fmt.Printf(url,stockcode,enddate)
        }
  ```

| 格 式 | 描 述                                    |
| ----- | ---------------------------------------- |
| %v    | 按值的本来值输出                         |
| %+v   | 在 %v 基础上，对结构体字段名和值进行展开 |
| %#v   | 输出 Go 语言语法格式的类型和值           |
| %T    | 输出 Go 语言语法格式的类型               |
| %%    | 输出 % 本体                              |
| %b    | 整型以二进制方式显示                     |
| %o    | 整型以八进制方式显示                     |
| %d    | 整型以十进制方式显示                     |
| %x    | 整型以十六进制方式显示                   |
| %X    | 整型以十六进制、字母大写方式显示         |
| %U    | Unicode 字符                             |
| %f    | 浮点数                                   |
| %p    | 指针，十六进制方式显示                   |

```go
package main

import "fmt"

func main() {
    name := "John"
    age := 30
    height := 175.5

    result := fmt.Sprintf("Name: %s, Age: %d, Height: %.2f", name, age, height)
    fmt.Println(result)
}
```

以上实例中，格式化字符串 `"Name: %s, Age: %d, Height: %.2f"` 中的 `%s`、`%d` 和 `%.2f` 分别被 name、age 和 height 变量的值替换，其中 `%.2f` 表示保留两位小数的浮点数格式。

```go
package main

import (
    "fmt"
    "os"
)

type point struct {
    x, y int
}

func main() {

    p := point{1, 2}
    fmt.Printf("%v\n", p)

    fmt.Printf("%+v\n", p)

    fmt.Printf("%#v\n", p)

    fmt.Printf("%T\n", p)

    fmt.Printf("%t\n", true)

    fmt.Printf("%d\n", 123)

    fmt.Printf("%b\n", 14)

    fmt.Printf("%c\n", 33)

    fmt.Printf("%x\n", 456)

    fmt.Printf("%f\n", 78.9)

    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

    fmt.Printf("%s\n", "\"string\"")

    fmt.Printf("%q\n", "\"string\"")

    fmt.Printf("%x\n", "hex this")

    fmt.Printf("%p\n", &p)

    fmt.Printf("|%6d|%6d|\n", 12, 345)

    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

    fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)

    fmt.Printf("|%6s|%6s|\n", "foo", "b")

    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}
```

输出结果为：

```go
{1 2}
{x:1 y:2}
main.point{x:1, y:2}
main.point
true
123
1110
!
1c8
78.900000
1.234000e+08
1.234000E+08
"string"
"\"string\""
6865782074686973
0xc0000b4010
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error
```

### 对齐方式

通过在格式化字符串中使用宽度和对齐参数，可以控制生成的字符串的对齐方式。

常用的对齐参数有：

- `%s`：字符串格式，可以使用以下对齐参数：
  - `%s`：默认对齐方式，左对齐。
  - `%10s`：指定宽度为 10 的右对齐。
  - `%-10s`：指定宽度为 10 的左对齐。
- `%d`：整数格式，可以使用以下对齐参数：
  - `%d`：默认对齐方式，右对齐。
  - `%10d`：指定宽度为 10 的右对齐。
  - `%-10d`：指定宽度为 10 的左对齐。
- `%f`：浮点数格式，可以使用以下对齐参数：
  - `%f`：默认对齐方式，右对齐。
  - `%10f`：指定宽度为 10 的右对齐。
  - `%-10f`：指定宽度为 10 的左对齐。
- ```go
    package main

    import "fmt"

    func main() {
        str := "Hello"
        num := 42
        floatNum := 3.14159

        fmt.Printf("|%s|\n", str)
        fmt.Printf("|%10s|\n", str)
        fmt.Printf("|%-10s|\n", str)

        fmt.Printf("|%d|\n", num)
        fmt.Printf("|%10d|\n", num)
        fmt.Printf("|%-10d|\n", num)

        fmt.Printf("|%f|\n", floatNum)
        fmt.Printf("|%10f|\n", floatNum)
        fmt.Printf("|%-10f|\n", floatNum)
    }
  ```

- 输出结果为：
- ```go
    |Hello|
    |     Hello|
    |Hello     |
    |42|
    |        42|
    |42        |
    |3.141590|
    |  3.141590|
    |3.141590  |
  ```