golang第三天，常量的使用

打印详解

package main
import "fmt"
func main() {
  // 打印结构体
  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}

  // 打印类型
  fmt.Printf("%T\n", p) //输出结果为 main.point

  // 打印布尔值
  fmt.Printf("%t\n", true) //输出结果为 true

  // 打印整数。
  fmt.Printf("%d\n", 123) //输出结果为 123

  // 打印二进制
  fmt.Printf("%b\n", 14) //输出结果为 1110

  // 打印字符
  fmt.Printf("%c\n", 33) //输出结果为 ！

  // 打印 16 进制
  fmt.Printf("%x\n", 456) //输出结果为 1c8

  // 打印浮点数
  fmt.Printf("%f\n", 78.9) //输出结果为 78.900000
  // 指数型
  fmt.Printf("%e\n", 123400000.0) //输出结果为 1.234000e+08
  fmt.Printf("%E\n", 123400000.0) //输出结果为 1.234000E+08

  // 字符串
  fmt.Printf("%s\n", "\"string\"") //输出结果为 "string"
  // 双引号字符串.
  fmt.Printf("%q\n", "\"string\"") //输出结果为 "\"string\""

  // 每个字符用两位 16 进制表示。
  fmt.Printf("%x\n", "hex this") //输出结果为 6865782074686973

  // 打印指针`.
  fmt.Printf("%p\n", &p) //输出结果为 0xc00001c08

  // 字符宽度
  fmt.Printf("|%6d|%6d|\n", 12, 345) //输出结果为 |    12|   345|

  //字符精度
  fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45) //输出结果为 |  1.20|  3.45|

  // 左对齐
  fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45) //输出结果为 |1.20  |3.45  |

  //同样可以控制字符的宽度
  fmt.Printf("|%6s|%6s|\n", "foo", "b") //输出结果为 |   foo|     b|

  // 同样字符左对齐.
  fmt.Printf("|%-6s|%-6s|\n", "foo", "b") //输出结果为 |foo   |b     |

  // 合并
  s := fmt.Sprintf("a %s", "string") //输出结果为 a string
  fmt.Println(s) //输出结果为
  // 同样的效果
  fmt.Fprintf(os.Stderr, "an %s\n", "error") //输出结果为 an error
}

1.1 常量声明

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

package mainimport "fmt"func main() {const length int = 10const width int = 4var area intconst a, b, c = 1, false, "str"area = length * widthfmt.Printf("面积为：%d", area)      // 40println()println(a, b, c)    // 1, false, "str"}

运行结果：

面积为 : 40
1 false str

常量可以作为枚举，常量组

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

package mainimport "fmt"func main() {    const (        x uint16 = 16        y        s = "abc"        z    )        fmt.Printf("%T,%v\n", y, z)     // uint16, abc        fmt.Printf("%T,%v\n", x, s)     // uint16, abc        fmt.Printf("%T,%v\n", y, y)     // unit16, 16        fmt.Printf("%T,%v\n", z, z)     // string, abc}

运行结果：

常量的注意事项：

• 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型

• 不曾使用的常量，在编译的时候，是不会报错的

• 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

1.2 iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

iota 用法

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运行结果：

0 1 2 ha ha 100 100 7 8

如果中断iota自增，则必须显式恢复。且后续自增值按行序递增

自增默认是int类型，可以自行进行显示指定类型

数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址