Apakah kaedah keluaran dalam bahasa go?

Kaedah output: 1. Fungsi Print(), yang boleh dioutput ke konsol (tiada pemformatan diterima), sintaks "fmt.Print(str)" 2. Println() function, yang boleh output ke Stesen kawalan dan pemisah baris, sintaks ialah "fmt.Println(tmp)" 3. Fungsi Printf() hanya boleh mencetak rentetan berformat 4. Fungsi Sprintf() boleh memformat dan mengembalikan rentetan Fungsi Fprintf (), yang boleh diformat dan dikeluarkan kepada "io.Writers".

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Perbezaan antara beberapa kaedah output dalam bahasa Go

Cetak, Println, Printf , <code><strong>Sprintf</strong> Sprintf , Fprintf

adalah semua kaedah awam dalam pakej fmt Fungsi ini diperlukan semasa mencetak maklumat. Jadi apakah perbezaan antara fungsi ini?

Print:   输出到控制台(不接受任何格式化，它等价于对每一个操作数都应用 %v)
         fmt.Print(str)
Println: 输出到控制台并换行
         fmt.Println(tmp)
Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出整形变量和整形 等）
         fmt.Printf("%d",a)
Sprintf：格式化并返回一个字符串而不带任何输出。
         s := fmt.Sprintf("a %s", "string") fmt.Printf(s)
Fprintf：格式化并输出到 io.Writers 而不是 os.Stdout。
         fmt.Fprintf(os.Stderr, “an %s\n”, “error”)

---

Umumnya pilih Printf apabila anda perlu memformat maklumat output Pada masa lain, gunakan Println

output berformat Printf

1. Pemegang tempat universal:

v     值的默认格式。
%+v   添加字段名(如结构体)
%#v　 相应值的Go语法表示 
%T    相应值的类型的Go语法表示 
%%    字面上的百分号，并非值的占位符　

2 Nilai Boolean:

%t   true 或 false

3 🎜 >

%b     二进制表示 
%c     相应Unicode码点所表示的字符 
%d     十进制表示 
%o     八进制表示 
%q     单引号围绕的字符字面值，由Go语法安全地转义 
%x     十六进制表示，字母形式为小写 a-f 
%X     十六进制表示，字母形式为大写 A-F 
%U     Unicode格式：U+1234，等同于 "U+%04X"

4. Nombor titik terapung dan nombor kompleks:

%b     无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat中的 'b' 转换格式一致。例如 -123456p-78 
%e     科学计数法，例如 -1234.456e+78 
%E     科学计数法，例如 -1234.456E+78 
%f     有小数点而无指数，例如 123.456 
%g     根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 
%G     根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出

5

%s     字符串或切片的无解译字节 
%q     双引号围绕的字符串，由Go语法安全地转义 
%x     十六进制，小写字母，每字节两个字符 
%X     十六进制，大写字母，每字节两个字符

6. Penunjuk:

Tiada tanda 'u' di sini. Jika integer adalah jenis tidak bertanda, ia dicetak sebagai tidak bertanda. Begitu juga, tidak perlu menentukan saiz operan (int8, int64).

%p     十六进制表示，前缀 0x

7 Untuk %ｖ, format lalai ialah:

Ia boleh dilihat bahawa format output lalai boleh ditentukan menggunakan %v format output adalah berbeza daripada lalai, anda boleh menggunakan %v sebaliknya (tetapi tidak disyorkan)

bool:                    %t 
int, int8 etc.:          %d 
uint, uint8 etc.:        %d, %x if printed with %#v
float32, complex64, etc: %g
string:                  %s
chan:                    %p 
pointer:                 %p

8. Untuk objek majmuk:

elemen di dalam Gunakan peraturan berikut untuk percetakan:

struct:            {field0 field1 ...} 
array, slice:      [elem0 elem1 ...] 
maps:              map[key1:value1 key2:value2] 
pointer to above:  &{}, &[], &map[]

9 Lebar dan ketepatan:

Lebar ialah nilai selepas %. Jika tidak dinyatakan, nilai ini digunakan Secara lalai, ketepatan ialah nilai yang mengikut lebar Jika tidak dinyatakan, ketepatan lalai bagi nilai yang akan dicetak digunakan. Contohnya: %9.2f, lebar 9, ketepatan 2

Untuk nilai berangka, lebar ialah lebar minimum bagi kawasan yang diduduki oleh nilai berangka; titik. Tetapi untuk %g/%G, ketepatan ialah jumlah bilangan digit. Sebagai contoh, untuk 123.45, format %6.2f akan mencetak 123.45, manakala %.4g akan mencetak 123.5. Ketepatan lalai untuk %e dan %f ialah 6 tetapi untuk %g , ketepatan lalai ialah bilangan digit minimum yang diperlukan untuk menentukan nilai.

%f:      default width, default precision 
%9f      width 9, default precision 
%.2f     default width, precision 2 
%9.2f    width 9, precision 2 
%9.f     width 9, precision 0

Untuk kebanyakan nilai, lebar ialah bilangan minimum aksara untuk dikeluarkan, dengan ruang berlapik jika perlu untuk borang yang diformatkan. Untuk rentetan, ketepatan ialah bilangan maksimum keluaran aksara, dan akan dipotong terus jika perlu.

Lebar merujuk kepada "lebar minimum yang diperlukan". Jika lebar rentetan hasil melebihi lebar yang ditentukan, lebar yang ditentukan akan menjadi tidak sah.

Jika lebar dinyatakan sebagai `*', nilai lebar akan diperoleh daripada parameter.

Rentetan nombor sejurus selepas "." menunjukkan ketepatan (jika terdapat ".", ia adalah ".0"). Jika penunjuk integer (`d', `i', `b', `o', `x', `X', `u') ditemui, ketepatan menunjukkan panjang bahagian berangka

Jika penunjuk titik terapung (`f') ditemui, ia mewakili bilangan digit dalam bahagian perpuluhan.

Jika anda menemui penunjuk titik terapung (`e', `E', `g', `G'), ia mewakili bilangan digit bererti

Jika ketepatan ditetapkan kepada ` *', nilai ketepatan akan diekstrak daripada parameter

Antaranya, untuk rentetan %s atau jenis titik terapung %f, ketepatan boleh memotong panjang data. Seperti yang ditunjukkan di bawah.

10 Bendera lain:

func main() {
    a := 123
    fmt.Printf("%1.2d\n", a)    //123，宽度为１小于数值本身宽度，失效，而精度为２，无法截断整数
    b := 1.23
    fmt.Printf("%1.1f\n", b)    //1.2，精度为１，截断浮点型数据
    c := "asdf"
    fmt.Printf("%*.*s\n", 1, 2, c) //as，利用'*'支持宽度和精度的输入，并且字符串也可以利用精度截断
}

Untuk setiap fungsi kelas Printf, terdapat fungsi Cetak, yang tidak menerima sebarang pemformatan digunakan pada setiap operan. Satu lagi fungsi parameter pembolehubah, Println, memasukkan kosong antara operan dan menambahkan aksara baris baharu

+     总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。 
-     左对齐 
#     备用格式：为八进制添加前导 0（%#o），为十六进制添加前导 0x（%#x）或0X（%#X），为 %p（%#p）去掉前导 0x；对于 %q，若 strconv.CanBackquote 返回 true，就会打印原始（即反引号围绕的）字符串；如果是可打印字符，%U（%#U）会写出该字符的Unicode编码形式（如字符 x 会被打印成 U+0078 'x'）。 
' '  （空格）为数值中省略的正负号留出空白（% d）；以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开 
0     填充前导的0而非空格；对于数字，这会将填充移到正负号之后

pada penghujung Jika pemegang tempat tidak dipertimbangkan, jika operan ialah nilai antara muka, nilai khusus dalamannya akan digunakan. , dan bukannya antara muka itu sendiri. Seperti yang ditunjukkan di bawah:

11 Paparkan ruang letak parameter:

package main
 
import (
	"fmt"
)
 
type Sample struct {
	a   int
	str string
}
 
func main() {
	var i interface{} = Sample{1, "a"}
	fmt.Printf("%v\n", i)　　　　　　//{1 a}
}

Go menyokong paparan ruang letak parameter dengan menentukan susunan outputnya dalam format output, seperti berikut Ditunjukkan:

<.>

12. Ralat pemformatan:

func main() {
    fmt.Printf("%[2]d, %[1]d\n", 11, 22)  //22, 11，先输出第二个值，再输出第一个值
}

Jika argumen tidak sah diberikan kepada pemegang tempat (seperti menyediakan rentetan kepada %d), ia akan muncul Ralat pemformatan. Semua ralat bermula dengan "%!", kadangkala diikuti dengan satu aksara (tempat letak) dan berakhir dengan perihalan yang disertakan dalam kurungan.

Contoh output

func main() {
	var i int = 1
	fmt.Printf("%s\n", i)  //%!s(int=1)
}

[Cadangan berkaitan:

Pergi tutorial video

package main
import "fmt"
import "os"
type point struct {
    x, y int
}
func main() {
    //Go 为常规 Go 值的格式化设计提供了多种打印方式。例如，这里打印了 point 结构体的一个实例。
    p := point{1, 2}
    fmt.Printf("%v\n", p) // {1 2}
    //如果值是一个结构体，%+v 的格式化输出内容将包括结构体的字段名。
    fmt.Printf("%+v\n", p) // {x:1 y:2}
    //%#v 形式则输出这个值的 Go 语法表示。例如，值的运行源代码片段。
    fmt.Printf("%#v\n", p) // main.point{x:1, y:2}
    //需要打印值的类型，使用 %T。
    fmt.Printf("%T\n", p) // main.point
    //格式化布尔值是简单的。
    fmt.Printf("%t\n", true)
    //格式化整形数有多种方式，使用 %d进行标准的十进制格式化。
    fmt.Printf("%d\n", 123)
    //这个输出二进制表示形式。
    fmt.Printf("%b\n", 14)
    //这个输出给定整数的对应字符。
    fmt.Printf("%c\n", 33)
    //%x 提供十六进制编码。
    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 输出使用 base-16 编码的字符串，每个字节使用 2 个字符表示。
    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)
    //要最对齐，使用 - 标志。
    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而不是 os.Stdout。
    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

,

Pengajaran pengaturcaraan]

Atas ialah kandungan terperinci Apakah kaedah keluaran dalam bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!