go语言基本语法：基础类型、运算符、流程控制

一、第一个go语言程序

//go语言以包作为管理单位
//每个文件必须先声明包
//程序必须有一个main包（重要）
package main
import "fmt"//导入包后，必须要使用
//入口函数
func main() { //左括号必须和函数名同行
	//打印
	//“hello.go”打印到屏幕
	//调用函数，大部分都需要导入包
	/*这是块注释*/
	fmt.Println("hello go") //go语言语句结尾没有‘；’
	fmt.Println("hello itcast")
}

二、变量的使用

//变量，程序运行期间，可以改变的量
//1.声明格式  var 变量名 类型,变量声明了就必须要用
//2.只是声明，没有初始化的变量，默认值为0
//3.同一个{}里，声明的变量名是唯一的
var a int
fmt.Println("aaaaaaa", a)
//4.可以同时声明多个变量
//var b,c int
a = 10
fmt.Println("a=", a)
//2.变量的初始化，声明变量时，同时赋值
var b int = 10 //初始化
b = 20         //赋值，先声明，后赋值	
fmt.Println("b=", b)

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

三、自动推导类型

var a int//赋值前必须先声明变量
a = 10
fmt.Println("a=", a)

//:=,自动推导类型，先声明变量b，在给b赋值为20
b := 20
fmt.Println("b=", b)

//b := 30//前面已经有变量b，不能再新建一个b
b = 30
fmt.Println("b=", b)

四、Printf和Println的区别

a := 10
fmt.Println("a=", a)//一段一段处理，输出结束自动换行
//格式化输出，把a的内容放在%d的位置
//“a=10\n”这个字符串输出到屏幕，“\n”代表换行符
fmt.Printf("a = %d\n", a)

b := 20
c := 30
fmt.Println("a=", a, "b=", b, "c=", c)
fmt.Printf("a=%d, b=%d, c=%d", a, b, c)

五、多重赋值和匿名变量

func test() (a, b, c int) {//go函数可以返回多个值
	return 1, 2, 3
}
func main() {
	//	a := 10
	//	b := 20
	//	c := 30
	a, b := 10, 20 //多重初始化
	//交换2个变量的值
	var tmp int
	tmp = a
	a = b
	b = tmp
	fmt.Printf("a = %d, b = %d\n", a, b)

	//	i := 10
	//	j := 20
	i, j := 10, 20
	i, j = j, i
	fmt.Printf("i = %d, j = %d\n", i, j)
	//匿名变量，丢弃数据不处理,_匿名函数配合函数返回值使用，才有优势
	tmp, _ = i, j
	fmt.Println("tmp=", tmp)
	var c, d, e int
	c, d, e = test() //return 1,2,3
	fmt.Printf("c=%d,d=%d,e=%d\n", c, d, e)

	_, d, _ = test() //return 1,2,3
	fmt.Printf("d=%d\n", d)
}

六、常量的使用

//变量：程序运行期间，可以改变的量，变量声明需要var
//常量：程序运行期间，不可以改变的量,常量声明需要const
const a int = 10
//a = 20 //尝试修改常量,常量不允许修改
fmt.Println("a = ", a)

const b = 10.2 //没有使用:=
fmt.Printf(" b type is %T\n", b)
fmt.Println("b = ", b)

七、多个变量和常量的定义

//不同类型变量的声明（定义）
//	var a int
//	var b float64
var (
	a int = 10
	b     = 3.14
)
fmt.Println("a=", a)
fmt.Println("b=", b)

//	const i int = 10
//	const j float64 = 3.14
//可以自动推导类型
const (
	i         = 10
	j float64 = 3.14
)
fmt.Println("i=", i)
fmt.Println("j=", j)

八、iota枚举

//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 //0
	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", i, j1, j2, j3, k)

九、bool类型

//1.声明变量,没有初始化，零值（初始值）为false
var a bool
fmt.Println("a=", a)
a = true
fmt.Println("a=", a)

十、浮点型

//声明变量
var f1 float32
f1 = 3.14
fmt.Println("f1=", f1)
//float64存储小数比float32更准确

十一、字符类型

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

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

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

fmt.Printf("hello go %c", '\n') //'\'以反斜杠开头的是转义字符
fmt.Printf("hello itcast")

十二、字符串类型

var str1 string //声明变量
str1 = "abc"
fmt.Println("str1=", str1)
//内建函数，len()可以测字符串的长度，有多少个字符
fmt.Println("len(str2)=", len(str2))

十三、字符与字符串类型的区别

var ch byte
var str string
//字符
//1.单引号
//2.字符，往往只有一个字符，转义字符除外
ch = 'a'
fmt.Println("ch=", ch)
//字符串
//1.双引号
//2.字符串有1个或多个字符组成
//3.字符串都是隐藏了一个结束符‘\0’
str = "a" //由'a'和'\0'组成了一个字符串
fmt.Println("str=", str)
str = "hello go"
//只想操作字符串的某个字符，从0开始操作
fmt.Printf("str[0]=%c,str[1]=%c\n", str[0], str[1])

十四、复数类型

var t complex128 //声明
t = 2.1 + 3.14i  //赋值
fmt.Println("t=", t)
//通过内建函数，取实部和虚部
fmt.Println("real(t2)=", real(t2), ",imag(t2)=", imag(t2))

十五、格式化输出

a := 10
b := "abc"
c := 'a'
d := 3.14
fmt.Printf("%T,%T,%T,%T\n", a, b, c, d)
//%d整形格式，%s字符串格式，%c字符类型，%f浮点类型，%s万能格式
fmt.Printf("a=%d,b=%s,c=%c,d=%f\n", a, b, c, d)
fmt.Printf("a=%v,b=%v,c=%v,d=%v", a, b, c, d)

十六、输入的使用

var a int
fmt.Printf("请输入变量a：")
//阻塞等待用户的输入
//fmt.Scanf("%d", &a)
fmt.Scan(&a)
fmt.Println("a=", a)

十七、类型转换

//这种不能转换的类型就叫做不兼容类型
var flag bool
flag = true
fmt.Printf("flag=%t\n", flag)
//布尔类型不能转化为整型
//fmt.Printf("flag=%d\n", int(flag))
//0就是假，非0就是真
//整型也不能转化为布尔类型
//flag = bool(1)	
//类型转换
var ch byte
ch = 'a' //字符型本质上是整型
var t int
t = int(ch) //把ch的值取出来后，转成int再给t赋值
fmt.Println("t=", t)

十八、类型别名

type bigint int64//给int64起一个别名叫bigint
var a bigint //等价于int64 a
fmt.Printf("a type is %T\n", a)
type (
	long int64
	char byte
)
var b long = 11
var ch char = 'a'
fmt.Printf("b=%d,ch=%c\n", b, ch)

十九、运算符

fmt.Println("4>3结果：", 4 > 3)
fmt.Println("4!=3结果：", (4 != 3))
fmt.Println("true&&true:", true && true)//&&与，并且，左边右边都为真，结果为真
fmt.Println("true||flase=", true || false)//||或者，只要左边右边都为假，结果才为假，否则结果为真
a := 8
//fmt.Println("0<a<8", 0 < a < 8)

二十、if的使用

s := "wangsicong"
if s == "wangsicong" {
	fmt.Println("zuoshouizhiji,youshouyizhiya")
}
//if支持1个初始化语句，初始化语句和判断条件以‘;’分割
if a := 10; a == 10 { //条件为真就执行括号里的东西
	fmt.Println("a==10")
}

二十一、if...elseif...else的使用

//1
a := 10
if a == 10 {
	fmt.Println("a==10")
} else {
	fmt.Println("a!=10")
}
//2
if a := 10; a == 10 {
	fmt.Println("a==10")
} else {
	fmt.Println("a!=10")
}
a = 10
if a == 10 {
	fmt.Println("a==10")
} else if a > 10 {
	fmt.Println("a>10")
} else {
	fmt.Println("a<10")
}

二十二、多个if和if...else的区别

//这种好
a:=10
if a==10{
	fmt.Println("a==10")
}else if {
	fmt.Println("a>10")
}else{
	fmt.Println("a<10")
}
b:=10
if b==10{
	fmt.Println("b==10")
}
if b>10{
	fmt.Println("b>10")
}
if b<10{
	fmt.Println("b<10")
}

二十三、switch的使用

var num int
fmt.Printf("请输入：")
fmt.Scan(&num)
switch num { //switch后面写的是变量本身，不是条件
case 1:
	fmt.Printf("按下的是%d楼\n", num)
	//break//go语言保留了break关键字，调出switch，可以不写
	fallthrough //相当于C语言的不加break
case 2:
	fmt.Printf("按下的是%d楼\n", num)
	//break
case 3:
	fmt.Printf("按下的是%d楼\n", num)
	//break
case 4:
	fmt.Printf("按下的是%d楼\n", num)
	//break
default:
	fmt.Println("按下的是xxx楼")
}

二十四、switch的使用

//num := 1
//支持一个初始化语句，初始化语句和变量本身，以';'分割
switch num := 1; num { //switch后面写的是变量本身，不是条件
case 1:
	fmt.Printf("按下的是%d楼\n", num)
	//break//go语言保留了break关键字，调出switch，可以不写
	fallthrough //相当于C语言的不加break
case 2:
	fmt.Printf("按下的是%d楼\n", num)
	//break
	fallthrough
case 3, 4, 5:
	fmt.Printf("按下的是%d楼\n", num)
	//break
	fallthrough
case 6:
	fmt.Printf("按下的是%d楼\n", num)
	//break
	fallthrough
default:
	fmt.Println("按下的是xxx楼")
}
	score := 85
	switch { //可以没有条件
	case score > 90: //case后面可以放条件
		fmt.Println("优秀")
	case score > 80:
		fmt.Println("良好")
	default:
		fmt.Println("其他")

	}

二十五、for的使用

//for 初始条件;判断条件;条件变化{
//}
//1+2+3+...+100
//1.初始条件 i:=1
//2.判断条件是否为真，i<=100,如果为真，执行循环体，如果为假，调出
//3.条件变化i++
//4.重复2,3,4
sum := 0
for i := 1; i <= 100; i++ {
	sum += i
}
fmt.Println("sum=", sum)

二十六、range的使用

str := "abc"
for i := 0; i < len(str); i++ {//通过for打印每个字符
	fmt.Printf("str[%d]=%c\n", i, str[i])
}
//迭代打印每个元素，默认返回2个值:一个是元素位置，一个是元素本身
for i, data := range str {
	fmt.Printf("str[%d]=%c\n", i, data)
}
for i := range str { //第二个返回值默认丢弃，返回元素位置
	fmt.Printf("str[%d]=%c\n", i, str[i])
}
for i, _ := range str { //第二个返回值默认丢弃，返回元素位置
	fmt.Printf("str[%d]=%c\n", i, str[i])
}

二十七、break和continue的使用

package main
import "fmt"
import "time"
func main() {
	i := 0
	for { //for后面不写任何东西，这个循环条件永远为真
		i++
		time.Sleep(time.Second) //延时1秒
		if i == 5 {
			//break//跳出循环，如果嵌套多个循环，跳出最近的那个内循环
			continue //跳过本次循环，下一次继续
		}
		fmt.Println("i=", i)
	}
}