go字符串格式化

Go 字符串格式化

千次阅读 2017-07-26 15:59:58

转载自：... Go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。 package main import "fmt" import "os" type point struct { x, y int } func main() { // G


转载自：http://blog.csdn.net/fer_ba/article/details/38293157


Go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。
package main

import "fmt"
import "os"

type point struct {
    x, y int
}

func main() {

    // Go提供了几种打印格式，用来格式化一般的Go值，例如
    // 下面的%v打印了一个point结构体的对象的值
    p := point{1, 2}
    fmt.Printf("%v\n", p)

    // 如果所格式化的值是一个结构体对象，那么`%+v`的格式化输出
    // 将包括结构体的成员名称和值
    fmt.Printf("%+v\n", p)

    // `%#v`格式化输出将输出一个值的Go语法表示方式。
    fmt.Printf("%#v\n", p)

    // 使用`%T`来输出一个值的数据类型
    fmt.Printf("%T\n", p)

    // 格式化布尔型变量
    fmt.Printf("%t\n", true)

    // 有很多的方式可以格式化整型，使用`%d`是一种
    // 标准的以10进制来输出整型的方式
    fmt.Printf("%d\n", 123)

    // 这种方式输出整型的二进制表示方式
    fmt.Printf("%b\n", 14)

    // 这里打印出该整型数值所对应的字符
    fmt.Printf("%c\n", 33)

    // 使用`%x`输出一个值的16进制表示方式
    fmt.Printf("%x\n", 456)

    // 浮点型数值也有几种格式化方法。最基本的一种是`%f`
    fmt.Printf("%f\n", 78.9)

    // `%e`和`%E`使用科学计数法来输出整型
    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

    // 使用`%s`输出基本的字符串
    fmt.Printf("%s\n", "\"string\"")

    // 输出像Go源码中那样带双引号的字符串，需使用`%q`
    fmt.Printf("%q\n", "\"string\"")

    // `%x`以16进制输出字符串，每个字符串的字节用两个字符输出
    fmt.Printf("%x\n", "hex this")

    // 使用`%p`输出一个指针的值
    fmt.Printf("%p\n", &p)

    // 当输出数字的时候，经常需要去控制输出的宽度和精度。
    // 可以使用一个位于%后面的数字来控制输出的宽度，默认
    // 情况下输出是右对齐的，左边加上空格
    fmt.Printf("|%6d|%6d|\n", 12, 345)

    // 你也可以指定浮点数的输出宽度，同时你还可以指定浮点数
    // 的输出精度
    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

    // To left-justify, use the `-` flag.
    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")

    // `Printf`函数的输出是输出到命令行`os.Stdout`的，你
    // 可以用`Sprintf`来将格式化后的字符串赋值给一个变量
    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

    // 你也可以使用`Fprintf`来将格式化后的值输出到`io.Writers`
    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

运行结果
{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
0x103a10c0
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error

收起

展开全文

Go 字符串格式化的实例代码详解
2020-09-17 23:00:34
主要介绍了Go 字符串格式化的实例代码详解,本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
收起

清华尹成带你实战GO案例（4）Go 字符串格式化

2018-05-21 18:06:58

Go 字符串格式化Go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。package main import "fmt" import "os" type point struct { x, y int } func main() { // Go提供...

Go 字符串格式化
Go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。
package main
import "fmt"
import "os"
type point struct {
x, y int
}
func main() {
// Go提供了几种打印格式，用来格式化一般的Go值，例如
// 下面的%v打印了一个point结构体的对象的值
p := point{1, 2}
fmt.Printf("%v\n", p)
// 如果所格式化的值是一个结构体对象，那么`%+v`的格式化输出
// 将包括结构体的成员名称和值
fmt.Printf("%+v\n", p)
// `%#v`格式化输出将输出一个值的Go语法表示方式。
fmt.Printf("%#v\n", p)
// 使用`%T`来输出一个值的数据类型
fmt.Printf("%T\n", p)
// 格式化布尔型变量
fmt.Printf("%t\n", true)
// 有很多的方式可以格式化整型，使用`%d`是一种
// 标准的以10进制来输出整型的方式
fmt.Printf("%d\n", 123)
// 这种方式输出整型的二进制表示方式
fmt.Printf("%b\n", 14)
// 这里打印出该整型数值所对应的字符
fmt.Printf("%c\n", 33)
// 使用`%x`输出一个值的16进制表示方式
fmt.Printf("%x\n", 456)
// 浮点型数值也有几种格式化方法。最基本的一种是`%f`
fmt.Printf("%f\n", 78.9)
// `%e`和`%E`使用科学计数法来输出整型
fmt.Printf("%e\n", 123400000.0)
fmt.Printf("%E\n", 123400000.0)
// 使用`%s`输出基本的字符串
fmt.Printf("%s\n", "\"string\"")
// 输出像Go源码中那样带双引号的字符串，需使用`%q`
fmt.Printf("%q\n", "\"string\"")
// `%x`以16进制输出字符串，每个字符串的字节用两个字符输出
fmt.Printf("%x\n", "hex this")
// 使用`%p`输出一个指针的值
fmt.Printf("%p\n", &p)
// 当输出数字的时候，经常需要去控制输出的宽度和精度。
// 可以使用一个位于%后面的数字来控制输出的宽度，默认
// 情况下输出是右对齐的，左边加上空格
fmt.Printf("|%6d|%6d|\n", 12, 345)
// 你也可以指定浮点数的输出宽度，同时你还可以指定浮点数
// 的输出精度
fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
// To left-justify, use the `-` flag.
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")
// `Printf`函数的输出是输出到命令行`os.Stdout`的，你
// 可以用`Sprintf`来将格式化后的字符串赋值给一个变量
s := fmt.Sprintf("a %s", "string")
fmt.Println(s)
// 你也可以使用`Fprintf`来将格式化后的值输出到`io.Writers`
fmt.Fprintf(os.Stderr, "an %s\n", "error")
}


运行结果
{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
0x103a10c0
| 12| 345|
| 1.20| 3.45|
|1.20 |3.45 |
| foo| b|
|foo |b |
a string
an error


网址：http://www.qukuailianxueyuan.io/


欲领取造币技术与全套虚拟机资料
区块链技术交流QQ群：756146052  备注：CSDN
尹成学院微信：备注：CSDN

收起

展开全文

go字符串格式化实例

千次阅读 2019-03-17 12:16:38

格式化整型 fmt.Printf("%d\n", 123) ------123 格式化浮点型 `%f` fmt.Printf("%f\n", 78.9) ------78.900000 `%e`和`%E`使用科学计数法来输出整型 fmt.Printf(&...


    格式化整型
    fmt.Printf("%d\n", 123)

------123

    格式化浮点型 `%f`
    fmt.Printf("%f\n", 78.9)

------78.900000

    `%e`和`%E`使用科学计数法来输出整型
    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

------1.234000e+08

------1.234000E+08

    使用`%s`输出基本的字符串
    fmt.Printf("%s\n", "\"string\"")

------ “string”

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

------ |   foo|     b|

    左对齐你可以在宽度之前加上`-`号
    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")

------ |foo   |b     |

    `Sprintf` 将格式化后的字符串赋值给一个变量
    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

------ a string

收起

展开全文

go语言字符串格式化

2017-08-15 09:22:01

Go语言对字符串格式化提供了良好的支持。下面通过代码展示字符串的格式化。 package main import "fmt" import "os" type point struct { x, y int } func main() { // Go提供了几种打印格式，用来格式化一般...



Go语言对字符串格式化提供了良好的支持。下面通过代码展示字符串的格式化。
package main

import "fmt"
import "os"

type point struct {
    x, y int
}

func main() {

    // Go提供了几种打印格式，用来格式化一般的Go值，例如
    // 下面的%v打印了一个point结构体的对象的值
    p := point{1, 2}
    fmt.Printf("%v\n", p)

    // 如果所格式化的值是一个结构体对象，那么`%+v`的格式化输出
    // 将包括结构体的成员名称和值
    fmt.Printf("%+v\n", p)

    // `%#v`格式化输出将输出一个值的Go语法表示方式。
    fmt.Printf("%#v\n", p)

    // 使用`%T`来输出一个值的数据类型
    fmt.Printf("%T\n", p)

    // 格式化布尔型变量
    fmt.Printf("%t\n", true)

    // 有很多的方式可以格式化整型，使用`%d`是一种
    // 标准的以10进制来输出整型的方式
    fmt.Printf("%d\n", 123)

    // 这种方式输出整型的二进制表示方式
    fmt.Printf("%b\n", 14)

    // 这里打印出该整型数值所对应的字符
    fmt.Printf("%c\n", 33)

    // 使用`%x`输出一个值的16进制表示方式
    fmt.Printf("%x\n", 456)

    // 浮点型数值也有几种格式化方法。最基本的一种是`%f`
    fmt.Printf("%f\n", 78.9)

    // `%e`和`%E`使用科学计数法来输出整型
    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)

    // 使用`%s`输出基本的字符串
    fmt.Printf("%s\n", "\"string\"")

    // 输出像Go源码中那样带双引号的字符串，需使用`%q`
    fmt.Printf("%q\n", "\"string\"")

    // `%x`以16进制输出字符串，每个字符串的字节用两个字符输出
    fmt.Printf("%x\n", "hex this")

    // 使用`%p`输出一个指针的值
    fmt.Printf("%p\n", &p)

    // 当输出数字的时候，经常需要去控制输出的宽度和精度。
    // 可以使用一个位于%后面的数字来控制输出的宽度，默认
    // 情况下输出是右对齐的，左边加上空格
    fmt.Printf("|%6d|%6d|\n", 12, 345)

    // 你也可以指定浮点数的输出宽度，同时你还可以指定浮点数
    // 的输出精度
    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)

    // To left-justify, use the `-` flag.
    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")

    // `Printf`函数的输出是输出到命令行`os.Stdout`的，你
    // 可以用`Sprintf`来将格式化后的字符串赋值给一个变量
    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)

    // 你也可以使用`Fprintf`来将格式化后的值输出到`io.Writers`
    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

运行结果
{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
0x103a10c0
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string
an error
转自：http://blog.csdn.net/fer_ba/article/details/38293157
参考：http://blog.csdn.net/liuxinmingcode/article/details/50448278

收起

展开全文

Go by Example 中文：字符串格式化
2020-05-23 20:59:03
Go by Example 中文：字符串格式化 Go 在传统的printf 中对字符串格式化提供了优异的支持。这里是一些基本的字符串格式化的人物的例子。下面是go的源代码示例程序： // Go by Example 中文：字符串格式化 // ...
收起
Go log 字符串格式化
千次阅读 2019-05-07 15:11:33
收起
Go by Example 中文版: 字符串格式化
2020-09-07 09:24:52
Go by Example 中文版: 字符串格式化 Go 在传统的 printf 中对字符串格式化提供了优异的支持。这儿有一些基本的字符串格式化的任务的例子。 Go的示例代码如下： package main import ( "fmt" "os" ) type point...
收起
[golang]-go中字符串格式化与fmt包简介
2021-01-30 22:58:58
文章目录格式化符通用指针数值字符串与字节序列宽度与精度标识符占位符格式化错误GoStringer & StringerScanningPrintingErrorf fmt包中实现了格式化的I/O函数（类似Ｃ语言中的printf和scanf，但更加简单）。...
收起
Golang字符串格式化
2018-09-13 21:53:00
Go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。 package main import ( "fmt" "os" ) type point struct { x, y int } func main() { // Go提供了几种打印格式，...
收起
go fmt 格式化字符串
千次阅读 2018-01-31 07:15:30
Go对字符串格式化提供了良好的支持。下面我们看些常用的字符串格式化的例子。 package main import "fmt" import "os" type point struct { x, y int } func main() { // Go提供了几种打印格式，用来格式化...
收起
fmt
Golang之字符串格式化
2017-08-15 12:12:00
// Go 之 字符串格式化 // // Copyright (c) 2015 - Batu // package main import ( "fmt" ) type point struct { x, y int } func main(){ // 格式化整型。使用`%d`是一种 // 标准的以十进制来输出整型的...
收起
golang 格式化字符串_如何在Go中格式化字符串
2020-08-12 13:09:15
golang 格式化字符串As strings are often made up of written text, there are many instances when we may want to have greater control over how strings look to make them more readable for humans through ...
收起
列表 python java 正则表达式
GO语言之基础数据类型__字符串格式化
2019-05-20 17:44:00
　格式化样式：字符串形式，格式化动词以%开头。　参数列表：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错　在GO语言中，格式化的命名延续C语言的风格： var progress = 2 ...
收起
格式化Go字符串而不打印？
2020-06-15 10:29:40
Is there a simple way to format a string in Go without printing the string? 有没有一种简单的方法可以在Go中格式化字符串而
收起
string formatting

Go 字符串格式化

Go 字符串格式化的实例代码详解

清华尹成带你实战GO案例（4）Go 字符串格式化

go字符串格式化实例

go语言字符串格式化

Go by Example 中文：字符串格式化

Go log 字符串格式化

Go by Example 中文版: 字符串格式化

[golang]-go中字符串格式化与fmt包简介

Golang字符串格式化

go fmt 格式化字符串

Golang之字符串格式化

golang 格式化字符串_如何在Go中格式化字符串

GO语言之基础数据类型__字符串格式化

格式化Go字符串而不打印？

go字符串格式化