Golang字符串格式化与打印输出方法-Golang-PHP中文网

Golang中常用的打印函数有fmt.Print、fmt.Println和fmt.Printf，主要区别在于输出格式：Print不添加空格和换行，Println在参数间加空格并末尾换行，Printf支持格式化字符串并通过动词精确控制输出。

golang字符串格式化与打印输出方法

Golang在处理字符串格式化和打印输出方面，主要依赖于标准库中的

fmt

登录后复制

包。这个包提供了一系列功能强大且灵活的函数，无论是直接将内容输出到标准输出（控制台），还是格式化成字符串供其他地方使用，抑或是写入到特定的

io.Writer

登录后复制

接口，都能轻松应对。其核心机制在于通过格式化动词（verbs）来精确控制不同数据类型的显示方式，这使得开发者可以根据需求，以高度定制化的形式展现数据。

解决方案

在Golang中，

fmt

登录后复制

包是进行字符串格式化和打印输出的核心。它提供了一组函数，可以满足从最简单的文本输出到复杂数据结构格式化的各种需求。

```
fmt.Print
```
登录后复制
系列：
- ```
fmt.Print(a ...interface{}) (n int, err error)
```
  登录后复制
  ：将所有参数以默认格式输出，参数之间不加空格，不换行。
- ```
fmt.Println(a ...interface{}) (n int, err error)
```
  登录后复制
  ：与
```
Print
```
  登录后复制
  类似，但会在参数之间添加空格，并在末尾添加换行符。
- ```
fmt.Printf(format string, a ...interface{}) (n int, err error)
```
  登录后复制
  ：这是最常用的格式化输出函数，它接受一个格式字符串和可变参数，根据格式字符串中的动词（verbs）来格式化输出。
```
fmt.Sprint
```
登录后复制
系列：

立即学习“go语言免费学习笔记（深入）”；
- ```
fmt.Sprint(a ...interface{}) string
```
  登录后复制
  ：将参数格式化成字符串并返回，参数之间不加空格。
- ```
fmt.Sprintln(a ...interface{}) string
```
  登录后复制
  ：与
```
Sprint
```
  登录后复制
  类似，但会在参数之间添加空格，并在末尾添加换行符。
- ```
fmt.Sprintf(format string, a ...interface{}) string
```
  登录后复制
  ：与
```
Printf
```
  登录后复制
  类似，但它不会直接打印，而是返回一个格式化后的字符串。这在需要构建字符串而不直接输出时非常有用，比如构建日志消息或错误信息。
```
fmt.Fprint
```
登录后复制
系列：
- ```
fmt.Fprint(w io.Writer, a ...interface{}) (n int, err error)
```
  登录后复制
  ：将参数格式化并写入到指定的
```
io.Writer
```
  登录后复制
  接口中，例如文件、网络连接等。
- ```
fmt.Fprintln(w io.Writer, a ...interface{}) (n int, err error)
```
  登录后复制
  ：与
```
Fprint
```
  登录后复制
  类似，但会在参数之间添加空格，并在末尾添加换行符。
- ```
fmt.Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
```
  登录后复制
  ：与
```
Printf
```
  登录后复制
  类似，但输出目标是
```
io.Writer
```
  登录后复制
  。
```
fmt.Errorf
```
登录后复制
：
- ```
fmt.Errorf(format string, a ...interface{}) error
```
  登录后复制
  ：这是一个非常重要的函数，用于创建格式化的错误对象。它内部会调用
```
Sprintf
```
  登录后复制
  来构建错误消息，并返回一个实现了
```
error
```
  登录后复制
  接口的新对象。在Go 1.13+中，它还支持使用
```
%w
```
  登录后复制
  动词来包装底层错误，实现错误链。

这些函数构成了Go语言中灵活、强大的输出和字符串处理能力的基础。理解它们各自的用途和细微差别，对于编写清晰、可维护的Go代码至关重要。

Golang中常用的打印函数有哪些，它们之间有什么区别？

说实话，刚接触Go的时候，我也被

Print

登录后复制

、

Println

登录后复制

和

Printf

登录后复制

这三兄弟搞得有点懵。但用久了就发现，它们各自有明确的适用场景，理解了这些，用起来就顺手多了。

最基础的当然是

fmt.Print

登录后复制

。它就像个不爱说话的工匠，你给它什么，它就原样输出什么，参数之间连个空格都没有，输出完也不换行。比如：

package main

import "fmt"

func main() {
    name := "Alice"
    age := 30
    fmt.Print("Name:", name, "Age:", age, "\n") // 输出: Name:AliceAge:30
}

登录后复制

你看，

Name:

登录后复制

和

Alice

登录后复制

之间没有空格，

Alice

登录后复制

和

Age:

登录后复制

之间也没有。如果你想手动控制格式，包括空格和换行，用它就对了。不过，大多数时候，我们可能希望输出更“人性化”一点。

这时候，

fmt.Println

登录后复制

就登场了。它简直是调试代码时的利器！它会自动在每个参数之间加个空格，并且最重要的是，它会在输出的末尾自动加一个换行符。这对于快速查看变量值，或者在控制台输出一些简单的状态信息简直是完美。

package main

import "fmt"

func main() {
    name := "Bob"
    age := 25
    fmt.Println("Name:", name, "Age:", age) // 输出: Name: Bob Age: 25
}

登录后复制

是不是舒服多了？一行一个输出，清清楚楚。我个人在快速调试时，

Println

登录后复制

的使用频率是最高的。

而真正的“格式化大师”非

fmt.Printf

登录后复制

莫属。它提供了C语言风格的格式化字符串能力，通过各种格式化动词（verbs）来精确控制输出的类型、宽度、精度等。如果你需要输出结构化的数据，或者希望输出的内容有固定的布局，那么

Printf

登录后复制

是你的不二选择。

package main

import "fmt"

func main() {
    pi := 3.14159
    count := 123
    fmt.Printf("Pi is approximately %.2f and count is %d.\n", pi, count)
    // 输出: Pi is approximately 3.14 and count is 123.
}

登录后复制

这里

%.2f

登录后复制

表示浮点数保留两位小数，

%d

登录后复制

表示整数。它的强大之处在于，你可以用一个格式字符串来定义整个输出的模板，然后把变量按顺序填进去。这在生成报告、日志或者任何需要统一格式输出的场景下都非常有用。

总结一下，它们的主要区别在于：

Android数据格式解析对象JSON用法 WORD版

本文档主要讲述的是Android数据格式解析对象JSON用法；JSON可以将Java对象转成json格式的字符串，可以将json字符串转换成Java。比XML更轻量级，Json使用起来比较轻便和简单。JSON数据格式，在Android中被广泛运用于客户端和服务器通信，在网络数据传输与解析时非常方便。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看

查看详情

Print
登录后复制
：最原始，不加空格，不换行。
Println
登录后复制
：自动加空格，自动换行，适合快速调试。
Printf
登录后复制
：提供格式化字符串能力，通过动词精确控制输出，适合结构化和定制化输出。

选择哪个，就看你具体想要什么样的输出效果了。

如何利用格式化动词（verbs）在Golang中精确控制输出格式？

要说

fmt

登录后复制

包的精髓，那绝对是它的格式化动词（verbs）。这些小小的百分号开头的字符，就像是魔法咒语，能让你的数据按照你想要的方式呈现。掌握它们，你就掌握了输出的艺术。

最常用的几个动词，我们先来过一遍：

%v
登录后复制
(Value): 这是个万能动词，能打印任何值。它会根据值的类型选择合适的默认格式。如果你不确定用什么，用
```
%v
```
登录后复制
通常不会错。
```
fmt.Printf("Default value: %v\n", 123)       // 123
fmt.Printf("Default string: %v\n", "hello") // hello
type User struct { Name string }
u := User{"Goopher"}
fmt.Printf("Default struct: %v\n", u)       // {Goopher}
```
登录后复制
但
```
%v
```
登录后复制
还有更强大的变体：
- ```
%+v
```
  登录后复制
  : 打印结构体时，会带上字段名。
```
fmt.Printf("Struct with fields: %+v\n", u) // {Name:Goopher}
```
  登录后复制
- ```
%#v
```
  登录后复制
  : 打印值的Go语法表示。这对于调试时查看一个值的完整、可重现的表示非常有用。
```
fmt.Printf("Go syntax: %#v\n", u) // main.User{Name:"Goopher"}
```
  登录后复制
%T
登录后复制
(Type): 打印值的类型。这在调试时非常方便，可以快速确认变量的实际类型。
```
fmt.Printf("Type of u: %T\n", u) // main.User
```
登录后复制
%T
登录后复制
(Boolean): 打印布尔值。
```
fmt.Printf("Boolean: %t\n", true) // true
```
登录后复制
整数类：
- ```
%d
```
  登录后复制
  : 十进制整数。
- ```
%b
```
  登录后复制
  : 二进制整数。
- ```
%o
```
  登录后复制
  : 八进制整数。
- ```
%x
```
  登录后复制
  ,
```
%x
```
  登录后复制
  : 小写/大写十六进制整数。
```
num := 255
fmt.Printf("Decimal: %d, Binary: %b, Octal: %o, Hex: %x/%X\n", num, num, num, num, num)
// Decimal: 255, Binary: 11111111, Octal: 377, Hex: ff/FF
```
  登录后复制
浮点数类：
- ```
%f
```
  登录后复制
  : 默认宽度，默认精度浮点数。
- ```
%e
```
  登录后复制
  ,
```
%e
```
  登录后复制
  : 科学计数法（小写/大写e）。
- ```
%g
```
  登录后复制
  ,
```
%g
```
  登录后复制
  : 根据值的大小，选择
```
%e
```
  登录后复制
  或
```
%f
```
  登录后复制
  中最简洁的表示。
```
val := 123.456
fmt.Printf("Float: %f, Scientific: %e, General: %g\n", val, val, val)
// Float: 123.456000, Scientific: 1.234560e+02, General: 123.456
```
  登录后复制
字符串类：
- ```
%s
```
  登录后复制
  : 字符串。
- ```
%q
```
  登录后复制
  : 带双引号的字符串，特殊字符会进行转义。这在打印可能包含空格或特殊字符的字符串时很有用，能清晰地看出字符串的边界。
```
str := "hello world"
fmt.Printf("String: %s, Quoted: %q\n", str, str)
// String: hello world, Quoted: "hello world"
```
  登录后复制

指针类：

%p

登录后复制

: 打印指针地址。

ptr := &num
fmt.Printf("Pointer address: %p\n", ptr) // 0xc0000140a8 (地址会变)

登录后复制

除了这些基本动词，我们还可以通过宽度、精度和标志来进一步控制格式。

宽度： 在动词前加数字，表示最小字段宽度。如果值不足该宽度，会用空格填充（默认右对齐）。

fmt.Printf("Right padded: %8d\n", 123)  // "     123"
fmt.Printf("Left padded: %-8s\n", "Go") // "Go      " (负号表示左对齐)
fmt.Printf("Zero padded: %08d\n", 123) // "00000123" (0表示用0填充)

登录后复制

精度： 在动词前加
```
.数字
```
登录后复制
。对于浮点数，表示小数位数；对于字符串，表示最大字符数。
```
fmt.Printf("Float precision: %.2f\n", 3.14159) // 3.14
fmt.Printf("String precision: %.5s\n", "Golang programming") // Golan
```
登录后复制
组合使用： 宽度和精度可以一起使用。
```
fmt.Printf("Combined: %-10.4f\n", 12.34567) // "12.3457   "
```
登录后复制

掌握这些格式化动词及其修饰符，你就能像个魔术师一样，让数据在控制台或任何输出流中以最优雅、最精确的方式呈现。这不仅仅是美观，更是提升代码可读性和调试效率的关键。

Golang字符串格式化在日志记录和错误处理中的最佳实践是什么？

在我看来，Golang的字符串格式化能力在日志记录和错误处理这两个领域，简直是如鱼得水，发挥着举足轻重的作用。但要用得好，还得讲究一些“最佳实践”，避免一些坑，让我们的日志既清晰又便于分析，错误信息既准确又富有上下文。

日志记录：

日志是排查问题、监控系统运行状态的眼睛。格式化的日志能大大提升可读性和可分析性。

使用
```
fmt.Sprintf
```
登录后复制
构建结构化日志信息： 我们很少会直接用
```
fmt.Printf
```
登录后复制
往控制台打日志，因为生产环境的日志通常需要写入文件、发送到日志服务，或者以结构化格式（如JSON）存储。这时，
```
fmt.Sprintf
```
登录后复制
就成了主力。它能把格式化后的字符串返回给我们，我们再用日志库（比如Go标准库的
```
log
```
登录后复制
包，或者更高级的
```
logrus
```
登录后复制
,
```
zap
```
登录后复制
等）将其写入。
```
package main

import (
    "fmt"
    "log"
)

func main() {
    userID := 101
    action := "login"
    status := "success"

    // 使用Sprintf构建日志消息
    logMsg := fmt.Sprintf("User %d performed action '%s' with status: %s", userID, action, status)
    log.Println(logMsg)
    // 实际应用中，可能会进一步封装成JSON或发送给日志服务
    // log.Printf("{\"user_id\": %d, \"action\": \"%s\", \"status\": \"%s\"}", userID, action, status)
}
```
登录后复制
这样，日志库就能接收到已经格式化好的字符串，进行后续处理。
提供足够的上下文信息： 日志的价值在于提供“当时发生了什么”的线索。所以，在格式化日志时，不要吝啬添加关键信息，比如请求ID、用户ID、操作名称、相关参数等。但也要避免过度冗余，保持信息密度。
一致的日志格式： 无论是人工阅读还是机器解析，一致的日志格式都至关重要。定义好你的日志模板，并坚持使用。例如，总是以时间戳开头，接着是日志级别，然后是具体的事件描述。

错误处理：

Go语言的错误处理哲学是“显式”和“值传递”。

fmt.Errorf

登录后复制

在这个过程中扮演着核心角色，尤其是在需要创建带有详细上下文信息的错误时。

使用

fmt.Errorf

登录后复制

创建富有上下文的错误： 当一个函数遇到错误时，仅仅返回一个通用的错误信息是不够的。我们应该在错误中加入导致错误发生的具体上下文。

fmt.Errorf

登录后复制

允许我们像

Printf

登录后复制

一样格式化错误消息。

package main

import (
    "fmt"
    "strconv"
)

func parseAndProcess(input string) (int, error) {
    val, err := strconv.Atoi(input)
    if err != nil {
        // 在这里添加上下文：哪个输入导致了转换失败
        return 0, fmt.Errorf("failed to parse input '%s' to integer: %v", input, err)
    }
    if val < 0 {
        // 另一个上下文：值不符合业务规则
        return 0, fmt.Errorf("input value %d is negative, expected non-negative", val)
    }
    return val * 2, nil
}

func main() {
    if _, err := parseAndProcess("abc"); err != nil {
        fmt.Println("Error:", err) // Error: failed to parse input 'abc' to integer: strconv.Atoi: parsing "abc": invalid syntax
    }
    if _, err := parseAndProcess("-5"); err != nil {
        fmt.Println("Error:", err) // Error: input value -5 is negative, expected non-negative
    }
}

登录后复制

这样，当错误向上层传播时，上层函数就能获得足够的信息来判断问题出在哪里。

Go 1.13+ 的错误包装（

%w

登录后复制

）： Go 1.13引入了错误包装机制，允许一个错误“包装”另一个错误，形成错误链。

fmt.Errorf

登录后复制

通过

%w

登录后复制

动词支持这一特性，这对于构建可追溯的错误路径至关重要。

package main

import (
    "errors"
    "fmt"
    "os"
)

func readFile(filename string) ([]byte, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        // 使用%w包装原始错误，保留错误链
        return nil, fmt.Errorf("failed to read file '%s': %w", filename, err)
    }
    return data, nil
}

func processFile(filename string) error {
    _, err := readFile(filename)
    if err != nil {
        // 上层函数可以继续包装，或者直接返回
        return fmt.Errorf("error processing file operation: %w", err)
    }
    return nil
}

func main() {
    err := processFile("non_existent_file.txt")
    if err != nil {
        fmt.Println("Application error:", err)
        // 可以使用errors.Is或errors.As来检查错误链中的特定错误
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("File does not exist!")
        }
    }
}

登录后复制