关于go:Go-快速入门指南-调试打印

一般打印

• 长处：内置函数，不须要引入额定的包，简略不便。
• 有余：无奈进行格式化打印，无奈残缺打印复合数据结构 (如数组, Map 等)。

println 函数

打印多个传入的参数，并主动加一个换行。

例子

package main

func main() {println(1024, "hello world", true)
}
// $ go run main.go
// 输入如下 
/**
    1024 hello world true
*/

print 函数

和 println 性能一样，然而不会主动加换行。

格式化打印

这里先介绍 2 个办法，别离是 fmt 包外面的 Println() 和 Printf(), 大多数场景下都实用。

fmt.Println()

性能上和 println 函数 相似，然而能够打印复合数据结构 (如数组, Map 等)。

例子

package main

import "fmt"

func main() {fmt.Println(1024, "hello world", true)
}

// $ go run main.go
// 输入如下 
/**
    1024 hello world true
*/

fmt.Printf()

最重要的格式化打印函数之一 ，能够针对不同数据类型和数据结构进行打印，十分弱小。

格式化规定

和 C 系列 编程语言的 printf() 格式化规定差不多。

通用

• %v 默认格局
• %+v 针对构造体，在 %v 的根底上输入构造体的键名
• %#v Go 语言语法格局的值
• %T Go 语言语法格局的类型和值
• %% 输入 %, 相当于本义

整型

• %b 二进制格局
• %c 对应的 Unicode 码
• %d 十进制
• %o 八进制
• %O 八进制，加上 0o 前缀
• %q Go 语言语法本义后的单引号字符 (很少应用) 例如 97 会输入 'a'
• %x 十六进制 (小写), 例如 0xaf
• %X 十六进制 (大写), 例如 0xAF
• %U Unicode 例如 "U+%04X"

Bool

• %t true 或 false

浮点型

• %b 指数为 2 的幂的无小数迷信计数法，例如 -123456p-78
• %e 迷信计数法, 例如 -1.234456e+78
• %E 迷信计数法, 例如 -1.234456E+78
• %f 惯例小数点表示法 (个别应用这个), 例如 123.456
• %F 和 %f 性能一样

字符串

• %s 字符串
• %q 将双引号 " 本义后的字符串
• %x 将字符串作为小写的十六进制
• %X 将字符串作为大写的十六进制

指针

• %p 地址的十六进制，前缀为 0x

例子

package main

import "fmt"

func main() {
    n := 1024
    fmt.Printf("n = %d\n", n) // 输入整型

    pi := 3.1415
    fmt.Printf("pi = %f\n", pi) // 输入浮点数

    str := "hello world"
    fmt.Printf("str = %s\n", str) // 输入字符串

    yes := true
    fmt.Printf("yes = %t\n", yes) // 输入布尔型

    x := 17
    fmt.Printf("yes = %b\n", x) // 输入二进制
}

// $ go run main.go
// 输入如下
/**
    n = 1024
    pi = 3.141500
    str = hello world
    yes = true
    x = 10001
*/

fmt.Printf() 技巧

在打印中，如果一个变量打印屡次，能够通过 [1] 来示意后续变量全副以第一个为准。

例子

package main

import ("fmt")

func main() {
    n := 1024
    fmt.Printf("%T %d %v\n", n, n, n)

    fmt.Printf("%T %[1]d %[1]v\n", n) // 能够应用 [1] 来示意援用第一个变量，这样只须要一个变量就能够了
}
// $ go run main.go
// 输入如下
/**
    int 1024 1024
    int 1024 1024
*/

备注

笔者倡议大家先记住 fmt 包里有这两个打印办法，具体的参数程序和格式化规定能够临时疏忽，
等前面学完了数组、构造体、Map 等复合数据结构当前，再依据具体场景回过头来查找对应的规定。

分割我