美文网首页
2-8 Go --- 格式化输出

2-8 Go --- 格式化输出

作者: 捌千里路雲和月 | 来源:发表于2021-07-17 03:09 被阅读0次

fmt 包的 Print 系列函数

  • 内容标准化输出：Print、Println、Printf。
  • Print 函数直接输出内容，不自带换行符。
  • Println 函数会在输出内容的结尾添加换行符。
  • Printf 函数支持格式化输出字符串，不自带换行符。
  • Print 函数不自带换行符。
package main

import "fmt"

func main() {
    n1 := 100    // int 整形变量 n1，赋值 100
    s1 := "Hello World!"    // string 字符串变量 s1，赋值 "Hello World!"
    f1 := 3.1415926    // float64 浮点数变量 f1，赋值 3.1415926

    fmt.Print(n1)    // 打印 n1
    fmt.Print(s1)    // 打印 s1
    fmt.Print(f1)     // 打印 f1
    fmt.Print(n1, s1, f1)       // 打印 n1,s1,f1
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
100Hello World!3.1415926100Hello World!3.1415926
  • 从输出结果可以看出 Print 函数的输出是一个接一个。值与值之间没有空格，每个 Print 结尾也不会换行。
  • Print 函数需要借助转译符完成清晰有序的输出。
package main

import "fmt"

func main() {
    n1 := 100
    s1 := "Hello World!"
    f1 := 3.1415926

    fmt.Print("n1= ", n1, "\n")    // \n 换行
    fmt.Print("s1= ", s1, "\n")
    fmt.Print("f1= ", f1, "\n")
    fmt.Print("n1= ", n1, "、 ", "s1= ", s1, "、 ", "f1= ", f1, " ")  
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1= 100
s1= Hello World!
f1= 3.1415926
n1= 100、 s1= Hello World!、 f1= 3.1415926
  • 从输出结果可以看出 。由于Print 函数不自带换行，只能借助转译符 "\n" 实现换行。另外，多个值输出没有空格，也只能自定义字符串格式化输出。例如 "、"标点符号，" " 空格。
  • Println 函数输出内容结尾自带换行符，多个值之间会有空格隔开。
package main

import "fmt"

func main() {
    n1 := 100
    s1 := "Hello World!"
    f1 := 3.1415926

    fmt.Println("n1=", n1)    // Println 函数自带换行
    fmt.Println("s1=", s1)
    fmt.Println("f1=", f1)
    fmt.Println(n1, s1, f1)      // Println 函数多个值之间自带空格
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1= 100      // 换行
s1= Hello World!
f1= 3.1415926
100 Hello World! 3.1415926    // 空格隔开
  • Printf 函数支持格式化输出字符串
  • 占位符，Printf 首段输出内容需要是字符串格式，字符串里面可以加入占位符。占位符就是字符串内容当中的这个固定位置保留下来，后面根据具体的值来替换占位符的位置，形成一段灵活而有意义的输出内容。
package main

import "fmt"

func main() {
    n1 := 100

// %d 用于整形的占位符，%d 就是为后面输入的整形数值先占一个固定位置。
// 当 n1进来时，它就会顶替 %d 的位置。"n1=%d" 实际上就是 fmt.Print("n1=", n1)。
    fmt.Printf("n1=%d", n1)   
}
// 输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1=100

----------------------------------- 分隔线 --------------------------------

package main

import "fmt"

func main() {
    s1 := "Hello World!"
    fmt.Printf("s1=%s", s1)    // %s 用于字符串（string）的占位符
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
s1=Hello World!

----------------------------------- 分隔线 --------------------------------

package main

import "fmt"

func main() {
    f1 := 3.1415926
    fmt.Printf("f1=%f", f1)    // %f 用于浮点数（float）的占位符
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
f1=3.141593      //浮点数默认精度保留四舍五入保留 6 位小数
  • Printf 结尾不自带换行。输出多个值时，值与值之间没有空格分隔。
package main

import "fmt"

func main() {
    n1 := 100      // int 整形变量 n1，赋值 100
    s1 := "Hello World!"    // string 字符串变量 s1，赋值 "Hello World!"
    f1 := 3.1415926    // float64 浮点数变量 f1，赋值 3.1415926

    fmt.Printf("n1=%d", n1)    // 打印 n1
    fmt.Printf("s1=%s", s1)    // 打印 s1
    fmt.Printf("f1=%f", f1)    // 打印 f1
    fmt.Printf("n1=%d,s1=%s,f1=%f", n1, s1, f1)    // 打印 n1,s1,f1
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1=100s1=Hello World!f1=3.141593n1=100,s1=Hello World!,f1=3.141593
// 多个值连续输出，值与值之间没有换行和空格隔开。
  • 转译符，Printf 不自带换行符，转译符 \n （换行）。
package main

import "fmt"

func main() {
    n1 := 100
    s1 := "Hello World!"
    f1 := 3.1415926

    fmt.Printf("n1=%d\n", n1)    // \n 换行符
    fmt.Printf("s1=%s\n", s1)
    fmt.Printf("f1=%f\n", f1)
    fmt.Printf("n1=%d,s1=%s,f1=%f\n", n1, s1, f1)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1=100      // 加了 \n 换行输出的内容
s1=Hello World!
f1=3.141593
n1=100,s1=Hello World!,f1=3.141593
  • 通用占位符：
  • %v：输出值的默认格式。
  • %T：打印值的类型。
  • %%：打印 % 百分号。
// %v：输出值的默认格式。
package main

import "fmt"

func main() {
    n1 := 100
    s1 := "Hello World!"
    f1 := 3.1415926

    fmt.Printf("n1=%v\n", n1)    //%v 占位符，以值的默认格式输出
    fmt.Printf("s1=%v\n", s1)
    fmt.Printf("f1=%v\n", f1)
    fmt.Printf("n1=%v,s1=%v,f1=%v\n", n1, s1, f1)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1=100
s1=Hello World!
f1=3.1415926
n1=100,s1=Hello World!,f1=3.1415926

---------------------------------- 分隔线 -----------------------------------
//%T：打印值的类型。
package main

import "fmt"

func main() {
    n1 := 100
    s1 := "Hello World!"
    f1 := 3.1415926

    fmt.Printf("n1=%T\n", n1)    //%T 占位符，输出值的类型
    fmt.Printf("s1=%T\n", s1)
    fmt.Printf("f1=%T\n", f1)
    fmt.Printf("n1=%T,s1=%T,f1=%T\n", n1, s1, f1)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1=int
s1=string
f1=float64
n1=int,s1=string,f1=float64

---------------------------------- 分隔线 -----------------------------------
// %%：打印 % 百分号。
package main

import "fmt"

func main() {
    n1 := 100
    fmt.Printf("n1=%v%%\n", n1)    // %v是值的占位符，%% 是输出 % 百分号
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
n1=100%
  • bool 布尔占位符
package main

import "fmt"

func main() { 
    b1 := true    // b1初始化为 true
    b2 := false    // b2初始化为 flase

 // %t bool占位符，%T输出值的类型。第一个b1对应 %t，第二个b1对应 %T
    fmt.Printf("b1:%t,type:%T\n", b1, b1)    
    fmt.Printf("b2:%t,type:%T\n", b2, b2)    // 同上同理
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
b1:true,type:bool
b2:false,type:bool
  • 整形占位符
package main

import "fmt"

func main() {
    fmt.Printf("100 的二进制是：%b\n", 100)
    fmt.Printf("中国，您好，对应的Unicode码点：%c%c%c%c%c\n", 0x4e2d, 0x56fd, 0xff0c, 0x60a8, 0x597d)
    fmt.Printf("中国，您好，Unicode格式显示：%U,%U,%U,%U,%U\n", 0x4e2d, 0x56fd, 0xff0c, 0x60a8, 0x597d)
    fmt.Printf("100 的十进制是：%d\n", 100)
    fmt.Printf("100 的八进制是：%o\n", 100)
    fmt.Printf("10 的十六进制（a~f）：%x\n", 10)
    fmt.Printf("10 的十六进制（a~f）：%X\n", 10)
    fmt.Printf("中国您好，单引号围绕的字符字面值，用于Go语法安全地转义：%q,%q,%q,%q\n", 0x4e2d, 0x56fd, 0x60a8, 0x597d)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
100 的二进制是：1100100
中国，您好，对应的Unicode码点：中国，您好
中国，您好，Unicode格式显示：U+4E2D,U+56FD,U+FF0C,U+60A8,U+597D    // 0x 改为 U+
100 的十进制是：100
100 的八进制是：144
10 的十六进制（a~f）：a
10 的十六进制（a~f）：A
中国您好，单引号围绕的字符字面值，用于Go语法安全地转义：'中','国','您','好'
  • 浮点数占位符和宽度、精度标识符。宽度是指通过设定紧跟在百分号后面的十进制数来达到值输出时填充指定数量的空格，如果没有指定宽度，则输出值时除必需之外不作填充。精度是指通过 %. 百分号点数字设定显示小数的位数，如果 . 点后面没有跟数字，表示精度为0。
package main

import "fmt"

func main() {
    f1 := 3.1415926
    fmt.Printf("3.1415926 默认宽度，默认精度（默认四舍五入保留6位小数）:%f\n", f1)
    fmt.Printf("3.1415926 默认宽度，只保留2位小数（四舍五入）:%.2f\n", f1)
    fmt.Printf("3.1415926 默认宽度，只保留整数:%.f\n", f1)
    fmt.Printf("3.1415926 默认宽度，保留10位小数位:%.10f\n", f1)
    fmt.Printf("3.1415926 20宽度，默认精度（默认四舍五入保留6位小数）:%20f\n", f1)
    fmt.Printf("3.1415926 20宽度，只保留2位小数（四舍五入）:%20.2f\n", f1)
    fmt.Printf("3.1415926 20宽度，只保留整数:%20.f\n", f1)
    fmt.Printf("3.1415926 20宽度，保留10位小数位:%20.10f\n", f1)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.8> go run .\main.go
3.1415926 默认宽度，默认精度（默认四舍五入保留6位小数）:3.141593
3.1415926 默认宽度，只保留2位小数（四舍五入）:3.14
3.1415926 默认宽度，只保留整数:3
3.1415926 默认宽度，保留10位小数位:3.1415926000      //有效小数位未达设定的保留位数将用 0 填充
3.1415926 20宽度，默认精度（默认四舍五入保留6位小数）:            3.141593
3.1415926 20宽度，只保留2位小数（四舍五入）:                3.14
3.1415926 20宽度，只保留整数:                   3
3.1415926 20宽度，保留10位小数位:        3.1415926000    //有效小数位未达设定的保留位数将用 0 填充
PS C:\Users\86186\go\src\chapter2\2.8>

相关文章

网友评论

      本文标题：2-8 Go --- 格式化输出

      本文链接：https://www.haomeiwen.com/subject/ecmdpltx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|2-8 Go --- 格式化输出|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！