Go语言系列-Go基础语法(一）

一、 Go语言变量定义

A. 内建变量类型

注意：Go语言中没有隐式强制类型转换，类型转换都是强制的，例如

func triangle() {
		var a, b int = 3, 4
		var c int = int(math.Sqrt(float64(a*a + b*b)))
		fmt.Println(c)
}

B. 函数内定义变量

package main

import "fmt"

/* 变量定义，默认初始值 */
func variableZeroValue() {
	// var为定义变量关键字，变量名在前，变量类型在后
	// Go语言定义变量后要求一定要有一个合理的初始值
	var a int
	var s string
	fmt.Println(a, s) 
	// Printf可以打印出特定的格式，具体对应打印方法后续给出
	fmt.Printf("%d %q\n", a, s)
}

func main() {
	fmt.Println("Hello World")
	variableZeroValue()
}

上述代码的打印结果如下图所示，我们可以通过Printf的打印结果看到int和String的初始值分别为0和“”

当然，除了变量的默认初始值外，我们也可以给变量赋予初始值，代码如下，打印结果这里就不额外进行展示了，想必大家都能够想到

package main

import "fmt"

//variableZeroValue
/* 变量定义，默认初始值 */
func variableZeroValue() {
	…… // (见上方代码块)
}

/* 变量定义，赋初始值 */
func variableInitialValue() {
	// 同一类型的变量可以一起定义
	// 注意！Go语言的定义比较严格，所有定义的变量都不许使用，否则会有红线提示
	var a, b int = 10, 20
	var s string = "abc"
	fmt.Println(a, b, s)
}

func main() {
	fmt.Println("Hello World")
	variableZeroValue()
	variableInitialValue()
}

此外，Go语言同其他大多数语言一样，可以根据赋值来自动识别变量的类型，代码如下，同时，Go语言也提供了一种简易的定义变量的方法，也需要大家掌握

package main

import (
	"fmt"
	"reflect"
)

//variableZeroValue
/* 变量定义，默认初始值 */
func variableZeroValue() {
	…… // (见上方代码块)
}

/* 变量定义，赋初始值 */
func variableInitialValue() {
	…… // (见上方代码块)
}

/* 根据赋值自动定义变量类型 */
func variableTypeDeduction() {
	// Go语言会根据赋予的初值，自动识别对应参数的类型
	// 这种定义下，可以把不同的类型的变量定义在一条语句中
	var a, b, c, s = 10, 20, true, "abc"
	fmt.Println(a, b, c, s)
	fmt.Println(reflect.TypeOf(a))
	fmt.Println(reflect.TypeOf(b))
	fmt.Println(reflect.TypeOf(c))
	fmt.Println(reflect.TypeOf(s))
}

/* 自定义变量简易写法 */
func variableShorter() {
	// 冒号等号,可以用于替代var关键字，来帮助我们快速定义变量
  // 这里Boolean类型的参数会提示黄色，这是IDE的提示，意思是可以简写为true
	a, b, c, s := 10, 20, true, "abc"
	fmt.Println(a, b, c, s)
}

func main() {
	fmt.Println("Hello World")
	variableZeroValue()
	variableInitialValue()
	variableTypeDeduction()
	variableShorter()
}

上述代码中，reflect.TypeOf可以帮助我们获取对应变量的类型，大家可以自己想一下，看看是否和下面的截图中，打印的变量类型结果是否一致

这里需要注意一点，无论是通过那种方法定义的参数，后续修改它的值的时候，只需要使用一个等号即可，尤其是不要写成 := 这个定义方法，避免重复定义参数

C. 函数外定义变量

上面我们看到的都是在函数内来定义变量，当然我们也开在函数外来定义变量，代码如下

package main

import (
	"fmt"
	"reflect"
)

// 特别注意：函数外定义变量，不能使用：=的方式来定义，必须要有var关键字或者func等关键字
// 这里定义的函数外变量，是包内变量，仅在整个包内有效，不是全局变量
var aa = 3
var bb = true
var ss = "abd"

// 简写,这样就不需要重复写多次var
// 当然这种方式同样适用于函数内定义变量
var (
	aaa = 3
	bbb = true
	sss = "ace"
)

//variableZeroValue
/* 变量定义，默认初始值 */
func variableZeroValue() {
	…… // (见上方代码块)
}

/* 变量定义，赋初始值 */
func variableInitialValue() {
	…… // (见上方代码块)
}

/* 根据赋值自动定义变量类型 */
func variableTypeDeduction() {
	…… // (见上方代码块)
}

/* 自定义变量简易写法 */
func variableShorter() {
	…… // (见上方代码块)
}

func main() {
	fmt.Println("Hello World")
	// variableZeroValue()
	// variableInitialValue()
	// variableTypeDeduction()
	// variableShorter()
	fmt.Println(aa, bb, ss)
	fmt.Println(aaa, bbb, sss)
}

二、 Go语言常量定义

常量的定义同变量的定义，关键字为const，示例如下

/* 常量定义 */
const filename = "abc.txt"

const (
	a1 = 3
	b1 = 4
)

func constDemo() {
	const a, b = 3, 4
	var c int
	// const数值可作为各种类型使用，这里即会被当做float32来使用
	c = int(math.Sqrt(a*a + b*b))
	fmt.Println(filename, a1, b1, c)
}

但不同于其他编程语言，Go语言的常量定义，并没有全部大写，因为GO语言的大小写会有额外的含义，这个后续会提到
此外，还有一种比较特殊的常量类型——枚举，示例如下

func enums() {
	// 直接定义枚举类型，注意需要赋值
	const(
		cpp = 1
		java = 2
		python = 3
		golang = 4
	)
	// 简化写法
	const(
		// 注意，这里的iota代表自增值，第一个为0
		cpp1 = iota
		java1
		// 这里可以用下划线来跳过一位
		_
		python1
		golang1
	)
	
	// 稍复杂枚举，定义b, kb, mb, gb, tb, pb(通过左移和iota自增运算）
	const(
		b = 1 << (10 * iota)
		kb
		mb
		gb
		tb
		pb
	)
}

三、 （补充）Golang中Printf的用法

先区别一下Golang中的几种打印

• Print: 输出到控制台(不接受任何格式化，它等价于对每一个操作数都应用 %v)
• Println: 输出到控制台并换行
• Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出整形变量和整形 等）
• Sprintf：格式化并返回一个字符串而不带任何输出
• Fprintf：来格式化并输出到 io.Writers 而不是 os.Stdout

Go为常规Go值的格式化设计提供了多种打印方式，如下代码将一一展示（其中打印结果将作为注释贴在打印语句后方）

package main

import (
	"fmt"
	"os"
)

type point struct {
	x, y int
}

func main() {
	// 1. 如果值是一个结构体，%v 的格式化输出内容将包括结构体的字段名
	p := point{1, 2}
	fmt.Printf("%v\n", p) // {1 2}

	// 2. 如果值是一个结构体，%+v 的格式化输出内容将包括结构体的字段名
	fmt.Printf("%+v\n", p) // {x:1 y:2}

	// 3. 如果值是一个结构体，%#v 形式则输出这个值的 Go 语法表示
	fmt.Printf("%#v\n", p) // main.point{x:1, y:2}

	// 4. 需要打印值的类型，使用 %T
	fmt.Printf("%T\n", p) // main.point

	// 5. 格式化布尔值是简单的
	fmt.Printf("%t\n", true) // true

	// 6. 格式化整形数有多种方式
	// 使用 %b进行标准的二进制格式化
	fmt.Printf("%b\n", 40) // 101000

	// 使用 %c进行给定整数的对应单个字符
	fmt.Printf("%c\n", 40) // (

	// 使用 %d进行标准的十进制格式化
	fmt.Printf("%d\n", 40) // 40

	// 使用 %o进行标准的八进制格式化
	fmt.Printf("%o\n", 40) // 50

	// 使用 %x进行标准的十六进制格式化
	fmt.Printf("%x\n", 40) // 28
	// 使用%x 输出使用 base-16 编码的字符串，每个字节使用 2 个字符表示
	fmt.Printf("%x\n", "hex this") // 6865782074686973

	// 7. 格式化浮点类型多种方式
	// 使用 %f 进行最基本的十进制格式化
	fmt.Printf("%f\n", 78.9) // 78.900000

	// 使用 %e和 %E将浮点型格式化为（稍微有一点不同的）科学技科学记数法表示形式
	fmt.Printf("%e\n", 12300000.0) // 1.230000e+07
	fmt.Printf("%E\n", 12300000.0) // 1.230000E+07

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

	// 使用 %q进行带有双引号的字符串输出
	fmt.Printf("%q\n", "\"string\"") // "\"string\""

	// 9. 使用 %p进行指针的值的输出
	fmt.Printf("%p\n", &p) // 0xc00000e0b0

	// 10. 使用在 % 后面使用数字来控制输出宽度(默认使用右对齐并且通过空格来填充空白部分)
	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     |

	// 11. os.Stdout输出格式化的字符串
	s := fmt.Sprintf("a %s", "string") 
	fmt.Println(s) // a string
	// 格式化并输出到 io.Writers
	fmt.Fprintf(os.Stderr, "an %s\n", "error") // an error(标红）
}

本文至此便告一段落，祝各位码上无ERROR，键盘无BUG！！