Go语言 数据类型,流程控制

Go语言 数据类型,流程控制

人生苦短,Let's Go !

package main // 必须要有一个main包

import "fmt"

func main() {
	fmt.Println("人生苦短,Let's Go!")
}

package main // 必须要有一个main包
import "fmt"
func main() {
	fmt.Println("Hello Golang!")
}
// go语言以包作为管理单位
// 每个文件必须先声明包
// 程序必须有一个main包
package main

import "fmt"

// 入口函数
func main() { //左括号必须和函数名同行
	// 打印
	// "hello go"打印到屏幕, Println()会自动换行
	// 调用函数,大部分都需要导入包
	/*
		这也是注释, 这是块注释
	*/
	fmt.Println("hello go!") // go语言语句结尾是没有分号

	fmt.Println("hello world!")
}

变量的使用

package main // 必须有一个main包

import "fmt" // 导入包,必须要使用

func main() {
	// 变量,程序运行期间,可以改变的量
	// 1、声明格式,var 变量名 类型,变量声明了,必须要使用
	// 2、只是声明没有初始化的变量,默认值为0
	// 3、同一个{}里,声明的变量名是唯一的
	var a int
	fmt.Println("a =", a) // a = 0

	// 4、可以同时声明多个变量
	var b, c int
	fmt.Printf("b = %d, c = %d\n", b, c)

	// 5、变量的赋值
	a = 10
	b = 20
	c = 30
	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

	// 6、变量的初始化,声明变量时,同时赋值
	var d int = 100 // 初始化,声明变量时,同时赋值(一步到位)
	d = 200         // 赋值,先声明,后赋值
	fmt.Println("d =", d)

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

自动推导类型

package main

import "fmt"

func main() {
	// 赋值,赋值前必须先声明变量
	var a int
	a = 10 // 赋值,可以使用n次
	a = 20
	a = 30
	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的区别

package main

import "fmt"

func main() {
	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\n", a, b, c)
}

多重赋值和匿名变量

package main

import "fmt"

// Go函数可以返回多个值
func test() (a, b, c int) {
	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)

	i = 10
	j = 20
	// _匿名变量,丢弃数据不处理,_匿名变量配合函数返回值使用,才有优势
	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)
}

常量的使用

package main

import "fmt"

func main() {
	// 变量:程序运行期间,可以改变的量,变量声明需要var
	// 常量:程序运行期间,不可以改变的量,常量声明需要const
	const a int = 10
	// a = 20 // err报错,常量不允许修改
	fmt.Println("a =", a)

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

多个变量或常量的定义

package main

import "fmt"

func main() {
	// 不同类型的变量的声明定义
	var a int = 1
	var b float64 = 2.0
	var (
		c int     = 1
		d float64 = 2.0
	)
	fmt.Println("a =", a)
	fmt.Println("b =", b)
	fmt.Println("c =", c)
	fmt.Println("d =", d)

	// 可以自动推导类型
	var (
		e = 1
		f = 2.0
	)
	e, f = 10, 3.14

	fmt.Println("e =", e)
	fmt.Println("f =", f)

	// 选中代码,按Ctrl+/,注释和取消注释代码的快捷键
	// const i int = 10
	// const j float64 = 3.14

	const (
		i int     = 10
		j float64 = 3.14
	)
	fmt.Println("i =", i)
	fmt.Println("j =", j)

	// 可以自动推导类型
	const (
		m = 10
		n = 3.14
	)
	fmt.Println("m =", m)
	fmt.Println("n =", n)
}

ioto枚举

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.Println("d =", d)

	// 4、可以只写一个iota
	const (
		a1 = iota // 0
		b1
		c1
		d1
	)
	fmt.Printf("a1 = %d, b1 = %d, c1 = %d, d1 = %d\n", a1, b1, c1, d1)

	// 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)
}

bool类型

package main

import "fmt"

func main() {
	// 声明变量,没有初始化,零值(初始化为false)
	var a bool
	fmt.Println("a =", a)

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

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

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

浮点型

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)
	fmt.Println("f2 =", f2)
	// float64存储小数比float32更准确
}

字符类型

package main

import "fmt"

func main() {
	var ch byte // 声明字符类型
	ch = 97
	fmt.Println("ch =", ch)

	// 格式化输出,%c以字符方式打印,%d以整型方式打印
	fmt.Printf("ch = %d = %c\n", ch, ch)

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

	// '\'以反斜杠开头的字符是转义字符,'\n'代表换行
	fmt.Printf("hello Go%c", '\n')
	fmt.Printf("hello Go\n")
	fmt.Printf("hello shenzhen\n")
} 

字符串类型

package main

import "fmt"

func main() {
	var name1 string // 声明变量
	name1 = "zhouwanchun"
	fmt.Println("name1 =", name1)

	name2 := "eric" // 自动推导类型
	fmt.Printf("name2的类型是%T\n", name2)

	// 内置函数,len()可以测字符串的长度,有多少个字符
	fmt.Println("len(name1) =", len(name1))
	fmt.Println("len(name2) =", len(name2))
}

字符和字符串的区别

package main

import "fmt"

func main() {
	var ch byte
	// 字符:
	// 1、单引号
	// 2、字符,往往都只有一个字符,转义字符除外'\n'
	ch = 'a'
	fmt.Println("ch =", ch)

	var str string
	// 字符串:
	// 1、双引号
	// 2、字符串有一个过多个字符组成
	// 3、字符串都是隐藏了一个结束符'\0'
	str = "a" // 由'a'和'0'组成的一个字符串
	fmt.Println("str =", str)

	str = "hello Go"
	// 只想操作字符串的某个字符,从0开始操作
	fmt.Printf("str[0] = %c\n", str[0])
	fmt.Printf("str[1] = %c\n", str[1])
}

复数类型

package main

import "fmt"

func main() {
	var t1 complex128 // 声明变量
	t1 = 2.1 + 3.14i  // 赋值
	fmt.Println("t1 =", t1)

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

	// 通过内置函数,取实部和虚部
	fmt.Println("real(t2) =", real(t2)) // 取实部
	fmt.Println("imag(t2) =", imag(t2)) // 取虚部
}

格式化输出

package main

import "fmt"

func main() {
	a := 10
	b := "abc"
	c := 'a'
	d := 3.14
	// %T操作变量所属类型
	fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)

	// %d 整数格式
	// %s 字符串格式
	// %c 字符个数
	// %f 浮点型个数
	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)
}

输入的使用

package main

import "fmt"

func main() {
	var username string // 声明变量
	fmt.Printf("请输入你的用户名:")

	// 阻塞等待用户的输入
	// fmt.Scanf("%d", &username) //别忘了&
	fmt.Scan(&username)

	var password string
	fmt.Printf("请输入你的密码:")
	fmt.Scan(&password)

	fmt.Println("-------------------------------------")
	fmt.Printf("你的用户名是:%s\n", username)
	fmt.Println("你的密码是:", password)
}

类型转换

package main

import "fmt"

func main() {
	var flag bool
	flag = true
	fmt.Printf("flag = %t\n", flag)

	// bool类型不能转换int
	// fmt.Printf("flag = %d\n", int(flag)) // 这种不能转换的类型,叫不兼容类型

	// 0就是假,非0就是真
	// 整型也不能转换为bool
	// flag = bool(1)

	var ch byte
	ch = 'a' // 字符类型本质上就是整型
	var t int
	t = int(ch) // 类型转换,把ch的值取出来后,转成int再给t赋值
	fmt.Println("t =", t)
}

类型别名

package main

import "fmt"

func main() {
	// 给int64起一个别名叫bigint
	type bigint int64

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

	type (
		long int64
		char byte
	)

	var b long = 22
	var ch char = 'a'
	fmt.Println("b =", b)
	fmt.Printf("ch = %c\n", ch)
}

运算符

package main

import "fmt"

func main() {
	fmt.Println("4 > 3 结果:", 4 > 3)
	fmt.Println("4 != 3 结果:", 4 != 3)

	fmt.Println("!(4 > 3) 结果:", !(4 > 3))
	fmt.Println("!(4 != 3) 结果:", !(4 != 3))

	// && 与,并且,左边右边都为真,结果才为真,其它都为假
	fmt.Println("true && true 结果:", true && true)
	fmt.Println("true && false 结果:", true && false)

	// || 或者,左边右边都为假,结果才为假,其它都为真
	fmt.Println("true || false 结果:", true || false)
	fmt.Println("false || false 结果:", false || false)

	a := 22
	fmt.Println("0 <= a && a <= 10 结果为:", 0 <= a && a <= 10)
}

if的使用

package main

import "fmt"

func main() {
	name := "王思聪"

	// if和{就是条件,条件通常都是关系运算符
	if name == "王思聪" { // 左括号和if在同一行
		fmt.Println("左手一个妹子,右手一个少妇")
	}

	// if支持1个初始化语句,初始化语句和判断条件以;分隔
	if a := 10; a == 9 {
		fmt.Println("a == 10")
	}
}

if_else_if_else的使用

package main

import "fmt"

func main() {
	a := 10
	if a == 10 {
		fmt.Println("a == 10")
	} else {
		fmt.Println("a != 10")
	}

	if b := 10; b == 10 {
		fmt.Println("b == 10")
	} else {
		fmt.Println("b != 10")
	}

	mm := 35
	if mm == 35 {
		fmt.Println("风韵尚存呀!哈哈!")
	} else if mm < 35 {
		fmt.Println("你已经是小熟女了")
	} else if mm > 35 {
		fmt.Println("你已经是老熟女了")
	}

	if mm := 40; mm == 35 {
		fmt.Println("风韵尚存呀!哈哈!")
	} else if mm < 35 {
		fmt.Println("你已经是小熟女了")
	} else if mm > 35 {
		fmt.Println("你已经是老熟女了")
	}
}

if_else_if和多个if的区别

package main

import "fmt"

func main() {
	// if_else嵌套(推荐这种方式)
	mm1 := 35
	if mm1 == 35 {
		fmt.Println("风韵尚存呀!哈哈!")
	} else if mm1 < 35 {
		fmt.Println("你已经是小熟女了")
	} else if mm1 > 35 {
		fmt.Println("你已经是老熟女了")
	}

	// 多个if判断
	mm2 := 40
	if mm2 == 35 {
		fmt.Println("风韵尚存呀!哈哈!")
	}
	if mm2 < 35 {
		fmt.Println("你已经是小熟女了")
	}
	if mm2 > 35 {
		fmt.Println("你已经是老熟女了")
	}
}

switch的使用

package main

import "fmt"

func main() {
	var num int
	fmt.Printf("请按下电梯楼层:")
	fmt.Scan(&num)

	switch num { // switch后面写的是变量本身
	case 1:
		fmt.Println("按下的是1楼")
		break // Go语言保留了break关键字,跳出switch语句,不写break默认就包含。
	case 2:
		fmt.Println("按下的是2楼")
		fallthrough // 不跳出switch语句,这条语句后面语句可以无条件执行。
	case 3:
		fmt.Println("按下的是3楼")
	case 4:
		fmt.Println("按下的是4楼")
	default:
		fmt.Println("按下的是xxx楼")
	}
}

switch使用的补充

package main

import "fmt"

func main() {
	// 支持一个初始化语句,初始化语句和变量本身,以分号分隔
	switch num := 4; num { // switch后面写的是变量本身
	case 1:
		fmt.Println("按下的是1楼")
		break // Go语言保留了break关键字,跳出switch语句,不写break默认就包含。
	case 2:
		fmt.Println("按下的是2楼")
		fallthrough // 不跳出switch语句,这条语句后面语句可以无条件执行。
	case 3, 4, 5:
		fmt.Println("按下的是345楼")
	case 6:
		fmt.Println("按下的是4楼")
	default:
		fmt.Println("按下的是xxx楼")
	}

	score := 85
	switch {
	case score > 90: // case后面可以放条件
		fmt.Println("优秀")
	case score > 80:
		fmt.Println("良好")
	case score > 70:
		fmt.Println("一般")
	default:
		fmt.Println("很差")
	}
}

for循环

package main

import "fmt"

func main() {
	// for 初始化条件; 判断条件; 条件变化 {
	// }

	// 计算从1加到100
	sum := 0

	for i := 1; i <= 100; i++ {
		sum = sum + i
	}
	fmt.Println("sum =", sum)

	// 打印1到100的整数
	for i := 1; i <= 100; i++ {
		fmt.Println(i)
	}
}

range的使用

package main

import "fmt"

func main() {
	name := "zhouwanchun"

	// 通过for打印每个字符
	for i := 0; i < len(name); i++ {
		fmt.Printf("name[%d]=%c\n", i, name[i])
	}
	fmt.Println("----------------------")

	// range迭代打印每个元素,默认返回2个值: 一个是元素的位置,一个是元素本身
	for i, data := range name {
		fmt.Printf("name[%d]=%c\n", i, data)
	}
	fmt.Println("----------------------")

	// 第2个返回值,默认丢弃,返回元素的位置(下标)
	for i := range name {
		fmt.Printf("name[%d]=%c\n", i, name[i])
	}

	fmt.Println("----------------------")
	// 第2个返回值,默认丢弃,返回元素的位置(下标)
	for i, _ := range name {
		fmt.Printf("name[%d]=%c\n", i, name[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)
	}
}

goto的使用

package main

import "fmt"

func main() {
	// break is not in a loop, switch, or select
	// continue is not in a loop
	// goto 可以用在任何地方,但是不能跨函数使用
	fmt.Println("111111111111111111111111")

	goto End // goto是关键字,End是用户起的名字,它叫标签

	fmt.Println("222222222222222222222222")

End:
	fmt.Println("333333333333333333333333")
}
上一篇:python基础(变量、基础数据类型、流程控制)


下一篇:struts2拦截器执行模拟 参考马士兵老师