Golang基础篇-变量常量

变量定义常见形式

• 第一种: 明确指定变量类型

package main

import （
	"fmt"
）

// 全局变量申明
var (
    milesson = "课程"
    id = 100
)

var (
    intVal1 int
    intVal2 string
)

// 编译失败: 不带var申明格式,只能在函数体中出现
inVal3 := 100

func test001() {
    fmt.Printf("%T, %s\n", milesson, milesson)  // string 课程
}

func test() {
	// 使用 var 关键字申明变量,指定变量类型，如果没有初始化，则变量默认为零值(零值就是变量没有做初始化时系统默认设置的值)
	var name string
	// %q: 像 Go 源代码中那样带有双引号的输出,记住: 仅仅只是一种输出形式,方便查看
	fmt.Printf("%q\n", name)  // ""
	// %d: 格式化整形数有多种方式，使用 %d进行标准的十进制格式化;记住: 仅仅只是一种输出形式,方便查看
	var age int
  	fmt.Printf("%q, %d\n", age, age)  // '\x00', 0
	var youName string = "conk"
	fmt.Printf("%q\n", youName) // "conk"
	// 一次性申明多个变量
	var hisName, hisSex string
	fmt.Printf("%q, %q\n", hisName, hisSex)  // "", ""
	var myName, mySex string = "conk", "男"
	fmt.Printf("%q, %q\n", myName, mySex)  // "conk", "男"
}

func main() {
	test()
}

• 第二种: 根据值自行判断变量类型

package main

import (
	"fmt"
)

func test02() {
	var name, age, sex = "", 18, "男"
	// %s: 基本的字符串输出形式, 注意: 男 没有双引号 但记住: 仅仅只是一种输出形式，方便查看
	fmt.Printf("%q, %d, %s\n", name, age, sex) // "", 18, 男
}

• 第三种: 根据值自行判断变量类型,但省去var关键字

package main

import (
	"fmt"
)

func test03() {
    sex, name, age, isMe := "男", "", 18, true
    // %t: 格式化布尔值，但记住: 仅仅只是一种输出形式，方便查看
    fmt.Printf("%s, %q, %d, %t\n", sex, name, age, isMe)
}

常量定义常见形式

• 第一种: 显示类型申明常量

package main

import (
	"fmt",
)

// 全局常量申明
const (
	chinese = iota
  	math
  	english
)

const (
	b = 1 << (10 * iota)
	kb
	mb
	gb
	tb
	pb
)

func test() {
	const name string = "conk"
	// 多个相同类型的申明简写如下
	const myName, mySex string = "conk", "男"
	fmt.Printf("%s, %s\n", myName, mySex)  // conk, 男
}

• 第二种: 隐式类型申明常量

package main

import (
	"fmt"
)

func test() {
	const name = "conk"
	const myName, myAge, isMe = "conk", 18, true
	fmt.Printf("%s, %d, %t\n", myName, myAge, isMe)  // conk 18 true
}

变量与常量之间的区别

• 编译阶段是否需要进行强类型转换

package main

import (
	"fmt"
)

func test06(m int) {
    fmt.Printf("%T\n", m)  // int
    var d int = 10
    fmt.Println(d + m)
}

func test07(k float64) {
    fmt.Printf("%T\n", k)  // float64
    fmt.Println(k)
}

func test04() {
    var a, b := 3, 4
    test06(a)
    // 报错: 编译不通过
    test07(b)  // cannot use b (type int) as type float64 in argument to test07
}

func test05() {
    const a, b = 3, 4
    test06(a)
    // 编译正常
    test07(b)
}

// 思考回顾案例1
func test03() {
    a, b := 3, 4
    var c int
    // 必须做类型转换，否则报错
    c = int(math.Sqrt(float64((a * a + b * b))))
    fmt.Println(c)
}

// 思考回顾案例2
func test02() {
    const a, b = 3, 4
    var c int
    c = int(math.Sqrt(a * a + b * b))
    fmt.Println(c)  // 5
}

变量定义的坑位:

• 第一个: 是否申明了新的变量

// 省略val,注意:=左侧如果没有申明新的变量,就会产生编译错误
func variableDemo01() {
    var intVal int
    // 编译失败
    intVal := 10  // no new variables on left side of :=
    fmt.Println(intVal)
}

// 省略val,只要:=左侧有申明新的变量,就不会产生编译错误
func variableDemo02() {
    var intVal int
    fmt.Println(intVal)
    intVal, intVal1 := 1, 2
    // 不报错
    fmt.Println(intVal, intVal1)
}