Go入门（二）之基础类型、fmt格式化、运算符、流程控制

上一篇文章> Go入门（一）之环境安装与初体验

一、基础类型

---

1、数据类型

命名规范：

1. 字母，下划线，数字

2. 不能以数字开头

3. 名字不能关键字

4. 区分大小写

2、变量

（1）变量声明

package main
import "fmt"
func main() {
	//变量，程序运行期间，可以改变的量

	//1、声明格式 var变量名 类型，变量声明了，必须要使用
	//2、只是声明没有初始化的变量，默认值为0
	//3、同一个{}里，声明的变量名是唯一的
	//4、可以同时声明多个变量
	var a int
	fmt.Println("a=", a)
	a = 10
	fmt.Println("a=", a)
}

结果：

E:\MyWork\Go Projects\01>go run 变量的使用.go
a= 0
a= 10

（2）变量初始化

package main
import "fmt"
func main() {
	//1、初始化，声明变量同时赋值
	var b int = 10
	fmt.Println("b=", b)
	b = 20
	fmt.Println("b=", b)

	//2、自动推导类型，必须初始化，通过初始化的值确定类型(常用)
	c := 30
	//%T打印变量所属的类型
	fmt.Printf("c type is %T\n", c)
}

结果：

E:\MyWork\Go Projects\01>go run 变量的使用.go
b= 10
b= 20
c type is int

（3）Printf和Println的区别

package main

import "fmt"

func main() {
	a := 10
	b := 20
	// 一段一段处理自动加换行
	fmt.Println("a = ", a, ", b = ", b)
	fmt.Printf("a = %d, b = %d\n", a, b)
}

（4）多重变量赋值

package main

import "fmt"

func main() {
	a, b := 10, 20
	a, b = b, a
	fmt.Printf("a=%d, b=%d\n", a, b)
}

结果：

a=20, b=10

（5）匿名变量

package main

import "fmt"

func test() (a, b, c int) {
	return 1, 2, 3
}

func main() {
	var a int
	// _匿名变量，丢弃数据不处理
	_, a, _ = test()
	fmt.Printf("a = %d\n", a)
}

结果：

a = 2

2、常量

（1）常量的使用

package main

import "fmt"

func main() {
	//变量：程序运行期间，可以改变的量，var
	//常量：成勋运行期间，不可以改变的量，const

	const a int = 10
	// a = 20   //err,常量不允许修改
	fmt.Println("a = ", a)

	const b = 11
	fmt.Printf("b type is %T\n", b)
}

结果：

a =  10
b type is int

（2）批量定义变量

注：var和const一样

package main

import "fmt"

func main() {
	//变量：程序运行期间，可以改变的量，var
	//常量：成勋运行期间，不可以改变的量，const
	const (
		a int = 10
		b = 11
	)
	// a = 20   //err,常量不允许修改
	fmt.Println("a = ", a)

	fmt.Printf("b type is %T\n", b)
}

（3）iota枚举

package main

import "fmt"

func main() {
	// 1、iota常量自动生成器，每个衣阿华那个，自动累加1
	// 2、iota给常量赋值使用

	const (
		a = iota //0
		b = iota //1
		c = iota //2
	)
	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

	// 3、iota遇到const，重置为0
	const d = iota
	fmt.Printf("d = %d\n", d)

	// 4、可以只写一个iota
	const (
		a1 = iota
		b1
		c1
	)
	fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1)
	// 5、如果是同一行，值都一样
	const (
		i          = iota
		j1, j2, j3 = iota, iota, iota
		k          = iota
	)
	fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k)
}

结果：

a = 0, b = 1, c = 2
d = 0
a1 = 0, b1 = 1, c1 = 2
i = 0, j1 = 1, j2 = 1, j3 = 1, k = 2

3、基础数据类型

（1）分类

（2）布尔类型

package main

import "fmt"

func main() {
	// 1、声明变量
	var a bool
	fmt.Println("a = ", a)
	a = true
	fmt.Println("a = ", a)

	// 2、自动推导类型
	var b = false
	fmt.Println("b = ", b)

	c := false
	fmt.Println("c = ", c)
}

结果：

a =  false
a =  true
b =  false
c =  false

（3）浮点型

package main

import "fmt"

func main() {
	var f1 float32
	f1 = 3.14
	fmt.Println("f1 = ", f1)

	//自动推导类型
	f2 := 3.14
	fmt.Printf("f2 type is %T\n", f2) // type => float64
	// float64存储小数比float32更准确
}

结果：

f1 =  3.14
f2 type is float64

（4）字符类型

package main

import "fmt"

func main() {
	var ch byte // 声明字符类型
	ch = 97
	// 格式化输出，%c以字符方式打印，%d以整型方式打印
	fmt.Printf("%c, %d\n", ch, ch)

	ch = 'a' //字符，单引号
	fmt.Printf("%c, %d\n", ch, ch)

	//大小写相差32，小写大
	fmt.Printf("大写转小写：%c\n", 'A'+32)
	fmt.Printf("小写转大写：%c\n", 'a'-32)
}

结果：

a, 97
a, 97
大写转小写：a
小写转大写：A

（5）字符串类型

package main

import "fmt"

func main() {
	var str1 string
	str1 = "abc"
	fmt.Println("str1 = ", str1)

	// 自动推导类型
	str2 := "wielun"
	fmt.Printf("str2 类型 %T\n", str2)

	// 内建函数，len()可以测字符串的长度
	fmt.Printf("str2 长度 %d\n", len(str2))
}

结果：

str1 =  abc
str2 类型 string
str2 长度 6

（6）字符和字符串区别

package main

import "fmt"

func main() {
	var (
		ch  byte
		str string
	)

	// 1、字符单引号；字符串双引号
	// 2、字符单个字符，转义字符除外（'\n'）；字符串1个或多个字符
	// 3、字符串都是隐藏了一个结束符，'\0'
	ch = 'a'
	fmt.Println("ch = ", ch)

	str = "a" //由'a'和'\0'组成了一个字符串
	fmt.Println("str = ", str)

	str = "wielun"
	fmt.Printf("str[0] = %c, str[1] = %c\n", str[0], str[1])
}

结果：

ch =  97
str =  a
str[0] = w, str[1] = i

（7）复数类型

package main

import "fmt"

func main() {
	var t complex128
	t = 1 + 2.3i
	fmt.Println("t = ", t)

	// 自动推导类型
	t2 := 3.4 + 2.1i
	fmt.Printf("t2 type %T\n", t2)

	// 通过内建函数，取实部和虚部
	fmt.Println("实部：", real(t2), "虚部:", imag(t2))
}

结果：

t =  (1+2.3i)
t2 type complex128
实部： 3.4 虚部: 2.1

二、fmt格式化与类型

---

1、fmt包的格式化输出输入

（1）格式说明

（2）格式化输出

package main

import "fmt"

func main() {
	a := 10
	b := "abc"
	c := 'a'
	d := 3.21
	fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)
	fmt.Printf("a = %d, b = %s, c = %c, d = %f\n", a, b, c, d)

	// %v自动匹配格式输出
	fmt.Printf("a = %v, b = %v, c = %v, d = %v\n", a, b, c, d)
}

结果：

int, string, int32, float64
a = 10, b = abc, c = a, d = 3.210000
a = 10, b = abc, c = 97, d = 3.21

（3）输入的使用

package main

import "fmt"

func main() {
	var a int
	fmt.Printf("请输入变量a: ")

	// 阻塞等待用户的输入
	// fmt.Scanf("%d", &a)

	fmt.Scan(&a)

	fmt.Println("a = ", a)
}

2、类型转换

package main

import "fmt"

func main() {
	// 布尔类型不能转换叫不兼容类型；0为假,非0为真
	var flag bool
	flag = true
	fmt.Printf("flag = %t\n", flag)

	var ch byte
	ch = 'a' //字符本质就是整型
	var t int
	t = int(ch)
	fmt.Println("t = ", t)
}

结果：

flag = true
t =  97

3、类型别名

package main

import "fmt"

func main() {
	// 给int64
	type bigint int64
	var a bigint // 等价于int64 a
	fmt.Printf("a type is %T\n", a)
}

结果：

a type is main.bigint

三、运算符

---

1、算数运算符

2、关系运算符

3、逻辑运算符

4、位运算符

5、赋值运算符

6、其他运算符

7、运算符优先级

四、流程控制

---

1、选择结构

（1）if语句

package main

import "fmt"

func main() {
	s := "wielun"

	if s == "wielun" {
		fmt.Printf("hello Wielun!!!\n")
	}

	// if支持1个初始化语句，初始化语句和判断条件以分号分隔
	if a := 10; a == 10 {
		fmt.Printf("a == 10\n")
	}

	val := 10
	if val == 10 {
		fmt.Printf("val == 10")
	} else if val > 10 {
		fmt.Printf("val > 10")
	} else {
		fmt.Printf("val < 10")
	}
}

结果：

hello Wielun!!!
a == 10
val == 10

（2）switch语句

package main

import "fmt"

func main() {
	var num int
	fmt.Printf("请输入楼层：")
	fmt.Scan(&num)

	switch num {   //可以放在一行switch num := 1;num
	case 1:
		fmt.Println("按下的是", num)
		// break   // 默认包含
		fallthrough //不跳出switch，后面无条件执行
	case 2:
		fmt.Println("按下的是", num)
		fallthrough
	case 3:
		fmt.Println("按下的是", num)
		fallthrough
	default:
		fmt.Println("按下的是", num)
	}
}

结果：

请输入楼层：1
按下的是 1
按下的是 1
按下的是 1
按下的是 1

package main

import "fmt"

func main() {
	var score int
	fmt.Printf("请输入分数：")
	fmt.Scan(&score)
	switch {
	case score > 90:
		fmt.Println("优秀")
	case score > 80:
		fmt.Println("良好")
	default:
		fmt.Println("差")
	}
}

结果：

请输入分数：123
优秀

2、循环语句

（1）for循环

package main

import "fmt"

func main() {
	// for初始化条件; 判断条件; 条件变化 {
	// }
	sum := 0
	for i := 1; i <= 100; i++ {
		sum += i
	}
	fmt.Println("sum = ", sum)
}

结果：

sum =  5050

（2）range循环

package main

import "fmt"

func main() {
	str := "abc"
	for i, data := range str {
		fmt.Printf("str[%d] = %c\n", i, data)
	}
	for j, _ := range str {
		fmt.Printf("str[%d] = %c\n", j, str[j])
	}
}

结果：

str[0] = a
str[1] = b
str[2] = c
str[0] = a
str[1] = b
str[2] = c

3、跳转语句

（1）break和continue

注意：break可用于for、switch、select，而continue仅能用于for循环

package main

import (
	"fmt"
	"time"
)

func main() {

	i := 0
	for { // 死循环
		i++
		time.Sleep(time.Second) //延迟一秒
		if i == 5 {
			// break    //直接跳出循环
			continue
		}
		fmt.Println("i = ", i)
	}
}

结果：

i =  1
i =  2
i =  3
i =  4
i =  6
i =  7
i =  8
   .
   .
   .

（2）goto

goto可以用在任何地方，但是不能跨函数使用

package main

import "fmt"

func main() {
	fmt.Println("111")
	goto End //goto是关键字，End是标签（用户自定义名字）

	fmt.Println("222")
End:
	fmt.Println("333")
}

结果：

111
333

下一篇文章> Go入门（三）之自定义函数、匿名函数、闭包、defer、作用域