Go筆記-print

打印輸出

對每一個Printf，Fprintf和Sprintf，都有另一對相應的函數，例如Print和Println。這些函數不接受格式串，而是爲每一個參數生成一個缺省的格式。Println版本還會在參數之間插入一個空格，並添加一個換行，而Print版本只有當兩邊的操做數都不是字符串的時候才增長一個空格。

fmt.Println("hello", 23)
fmt.Print("hello", "chen", "\n")
fmt.Print("hello", 23, "\n")
fmt.Print(12, 23, "\n")

打印： hello 23 hellochen hello23 12 23

格式化打印函數fmt.Fprint等，接受的第一個參數爲任何一個實現了io.Writer接口的對象；變量os.Stdout和os.Stderr是常見的實例

fmt.Fprint(os.Stdout, "hello")
  fmt.Fprint(os.Stderr, "chen")

複用參數

o := 0666
  fmt.Printf("%d %[1]o %#[1]o\n", o) // 438 666 0666
  x := int64(0xdeadbeef)
  fmt.Printf("%d %[1]x %#[1]x %#[1]X\n", x) // 3735928559 deadbeef 0xdeadbeef 0XDEADBEEF

%以後的[1]副詞告訴Printf函數再次使用第一個操做數

%後的#副詞告訴Printf在用%o、%x或%X輸出時生成0、0x或0X前綴

字符串 %s

字符串前加空格

fmt.Printf("|%10s|\n", "hello")

輸出：

|     hello|

字符串後加空格

fmt.Printf("|%-10s|\n", "hello")

數字前有個 '-'，輸出：

|hello     |

字符 %c

var str string = "chen"
  ch := str[0]
  fmt.Printf("str = %s, ch = %c \n", str, ch)

整型 %d

var i int32 = 123
  fmt.Printf("integer = %d \n", i)

在數字前用0填充

fmt.Printf("%011d\n", 1234) // 00000001234

十六進制整型 %x，%X

%x用於字符串，字節數組和字節切片，以及整數，生成一個長的十六進制字符串，而且若是在格式中有一個空格（% x），其將會在字節中插入空格。

用於整型：

var v uint64 = 1<<64 - 1
  fmt.Printf("%d %x %X\n", v, v, v)

18446744073709551615 ffffffffffffffff FFFFFFFFFFFFFFFF

用於字符串：

var v string = "hello"
  fmt.Printf("%x %X\n", v, v) // 68656c6c6f 68656C6C6F

用於字符數組：

v := []string{"ab", "cd"}
  fmt.Printf("%x %X\n", v, v) // [6162 6364] [6162 6364]

用於字符切片：

v := []string{"ab", "cd", "辰"}
  slice := v[:]
  fmt.Printf("%X\n", slice) // [6162 6364 E8BEB0]

用於整數：

fmt.Printf("%X\n", 97) // 61

加空格：

fmt.Printf("% X\n", "hello") // 68 65 6C 6C 6F
  fmt.Printf("% X\n", []string{"ab", "cd"}) // [61 62 63 64]

浮點型 %f，%g

var v1 float32 = 4.3
	var v2 float64 = 5.6
	fmt.Printf("%f %f\n", v1, v2) // 4.300000 5.600000
	fmt.Printf("%g %g\n", v1, v2) // 4.3 5.6

控制輸出的精度（四捨五入）：

fmt.Printf("%.2f", 3.1482) // 3.15

輸出變量類型

i := 3
	fmt.Printf("%T", i) // int

	const pi = 3.14
	fmt.Printf("%t", pi) // %!t(float64=3.14)

輸出值 %v(value)，%+v，%#v

產生Print和Println的結果。

i := []int{1, 2}
	fmt.Printf("%v", i) // [1 2]
	j := 3.4
	fmt.Printf("%v", j) // 3.4

	i := []int{1, 2}
	fmt.Printf("%#v", i) // []int{1,2}
	j := 3.4
	fmt.Printf("%#v", j) // 3.4

當打印一個結構體時，帶修飾的格式%+v會將結構體的域使用它們的名字進行註解，對於任意的值，格式%#v會按照完整的Go語法打印出該值。

type T struct {
		a int
		b float64
		c string
	}
	t := &T{7, 6.4, "abc\tdef"}
	fmt.Printf("%v\n", t)
	fmt.Printf("%+v\n", t)
	fmt.Printf("%#v\n", t)

輸出：

&{7 6.4 abc	def}
  &{a:7 b:6.4 c:abc	def}
  &main.T{a:7, b:6.4, c:"abc\tdef"}

前面的&表示是指針。

輸出指針%p

i := 3
	fmt.Printf("%d的地址是%p", i, &i) // 3的地址是0x10328000

帶有引號的字符串 %q(quotation)，%#q

經過%q來實現帶引號的字符串格式，用於類型爲string或[]byte的值。格式%#q將盡量的使用反引號（嵌套的引號使用不一樣的單雙引號）。（格式%q還用於整數和符文，產生一個帶單引號的符文常量。）

str := []string{"abc\"hello,'chen'.\"",
		"abc'hello,\"chen\".'",
		"abc\"hello,\"chen\".\""}
	for _, s := range str {
		fmt.Printf("%q %#q\n", s, s)
	}

輸出：

"abc\"hello,'chen'.\"" `abc"hello,'chen'."`
"abc'hello,\"chen\".'" `abc'hello,"chen".'`
"abc\"hello,\"chen\".\"" `abc"hello,"chen"."`

用於整型時將轉換成字符：

c := 97
	fmt.Printf("%q %#q\n", c, c) // 'a' 'a'

字符串中有\t:

v := "hello\tchen"
	fmt.Printf("%q %#q\n", v, v) // "hello\tchen" `hello	chen`

Println輸出多行文本

fmt.Println(`
		Enter following commands to control the player:
		lib list -- View the existing music lib
		lib add <name><artist><source><type> -- Add a music to the music lib
		lib remove <name> -- Remove the specified music from the lib
		play <name> -- Play the specified music
	`)

輸出：

Enter following commands to control the player:
		lib list -- View the existing music lib
		lib add <name><artist><source><type> -- Add a music to the music lib
		lib remove <name> -- Remove the specified music from the lib
		play <name> -- Play the specified music

"`" 這個是1前面的那個鍵。

`This is a raw string \n` 中的 `\n` 會被原樣輸出

自定義類型的String()

type T struct {
	a int
	b float64
	c string
  }

  func (t *T) String() string {
	return fmt.Sprintf("%d-%g-%q", t.a, t.b, t.c)
  }

	t := &T{23, 6.4, "hello"}
	fmt.Printf("%v\n", t)

輸出：

23-6.4-"hello"

不要將調用Sprintf的String方法構形成無窮遞歸。若是Sprintf調用嘗試將接收者直接做爲字符串進行打印，就會致使再次調用該方法，發生這樣的狀況。這是一個很常見的錯誤，正如這個例子所示。

type MyString string

  func (m MyString) String() string {
    return fmt.Sprintf("MyString=%s", m) // Error: will recur forever.
  }

這也容易修改：將參數轉換爲沒有方法函數的，基本的字符串類型。

type MyString string
  func (m MyString) String() string {
    return fmt.Sprintf("MyString=%s", string(m)) // OK: note conversion.
  }

只有Sprintf想要一個字符串的時候，纔去調用m的String方法，若是是」%f」這樣的，就不會去調用該方法。

不帶fmt的輸出

單純地打印一個字符串或變量甚至能夠使用預約義的方法來實現，如：print、println：print("ABC")、println("ABC")、println(i)（帶一個變量 i）。

這些函數只能夠用於調試階段，在部署程序的時候務必將它們替換成 fmt 中的相關函數。