目录
1 go语言变量类型
# 数字
# int 整数有正负 int8 int16 int32 int64
java byte short int long
-int8 一个字节表示(8个比特位) 范围: -2的7次方 到 +2的7次方-1
-int16 2个字节表 范围: -2的15次方 到 +2的15次方-1
-同理以此类推
-int:32位机器,是int32,64位机器是int64
# uint 正整数 uint uint8 uint16 uint32 uint64
-uint8 一个字节表示(8个比特位) 范围: 0 到 +2的8次方-1
-uint16 2个字节表示(8个比特位) 范围: 0 到 +2的16次方-1
-uint:32位机器,是uint32,64位机器是uint64
# 浮点型:表示小数 表示小数后范围不一样
float32:
float64:
# 复数类型 实部和虚部
complex64
complex128
# rune byte
byte 是 uint8 的别名
rune 是 int32 的别名
# string
-双引号包裹的:不能换号
-反引号包裹的:可以换行
# go 也有单引号包裹的,它不是字符串
# 布尔类型
true
false
2 常量
package main
import "fmt"
// 常量:恒定不变的变量,一旦定义,值固定了,不允许修改 const关键字定义的变量
//func main() {
//
// // 定义常量 const
// //const name string="lqz"
// const name ="lqz"
// fmt.Println(name)
//
//}
// 变量,常量的作用域范围 (变量只要不再同一个范围内,是可以再定义的)
var name = "lqz"
//name:="lqz"
func main() {
//var name = "pyy"
name="pyy"
fmt.Println(name)
}
// LEGB各自代表的含义
// 5 iota的使用 必须用const关键字
// 同时定义多个常量,第二个如果没有赋初值,初值就是上一个的值
// iota的用法一:后续定义的常量会自增,后续的就可以不用等于iota,会自增
// 只要用了iota,后续的都会自增1,
// iota 放在第几行,值就是多少,后续的都会自增
const (
a = 10
b
c
d = iota
e
)
func main() {
fmt.Println(c)
}
3 函数基础
package main
import "fmt"
// 函数
func main() {
//1 调用普通函数
//test()
// 2 调用有参数的函数 (类型必须严格一致,有几个值就传几个值,按位置,没有关键字传参)
//test1(11, "lqz")
// 3 调用简写的有参函数
//test2(11, 12, "lqz")
// 4 调用有返回值的函数
//res := test3(1, 2)
//var res = test3(1, 2)
//var res int= test3(1, 2)
//fmt.Println(res)
//test3(3, 4)
// 5 调用多个参数,多个返回值的函数 必须用多个接收,有几个就要用几个变量接收,不能多不能少
//res1, res2, res3 := test4(5, 6)
//fmt.Println(res1)
//fmt.Println(res2)
////fmt.Println(res3)
// 5.1 就不想要第三个参数,后面不会用第三个参数
//_, _, res1 := test4(5, 6) // 忽略掉第三
//fmt.Println(res1)
////fmt.Println(res2)
////fmt.Println(res3)
//fmt.Println(_) //不能当变量用,就是个空白
}
// 1 定义普通函数,没有参数,没有返回值
func test() {
fmt.Println("我是普通函数")
}
// 2 有参数的函数,必须指定参数类型
func test1(a int, b string) {
fmt.Println(a)
fmt.Println(b)
}
// 3 有参数的函数,多个参数,类型一致可以简写 (go语言想发设法让你少写代码)
//func test2(a, b int, c string) {
// fmt.Println(a)
// fmt.Println(b)
// fmt.Println(c)
//}
// 4 既有参数,又有返回值的 ,只有一个返回值的,需要指明返回值类型
func test3(a, b int) int {
return a + b
}
// 5 多个参数,多个返回值
func test4(a, b int) (int, int, string) {
return a + b, a * b, "成功"
}
4 函数高级
# 同一个包下,变量,函数只能定义一次
# 匿名函数:函数没有名字,一般定义在其他函数内部
f := func() {
}
package main
import "fmt"
// 函数高级
func main() {
// 1 匿名函数
//test5()
// 2 匿名函数赋值给变量
//test6()
// 3 调用函数,返回闭包函数
res := test7()
fmt.Println(res) //0x68de00 内存地址
res()
}
// 1 匿名函数加括号直接调用
func test5() {
func() {
fmt.Println("我是内层函数")
}()
}
// 2 匿名函数赋值给一个变量--->函数是一种类型---》在go中,函数又称一等公民(可以赋值给变量的都叫一等公民),又叫头等函数,一等函数
//func test6() {
// //f:=func() {
// // fmt.Println("我是内层函数")
// //}
// // f 类型是什么呀?完整定义,写类型
// var f func() = func() {
// fmt.Println("我是内层函数")
// }
// fmt.Printf("%T", f) // func()
//
//}
// 3 函数是一等公民,是一种类型---》函数的参数和返回值都是类型的一部分
//func test6() {
// var f func() = func() {
// fmt.Println("我是内层函数")
// }
// var f1 func(int) int = func(a int) int {
// fmt.Println(a)
// return 10
// }
// var f2 func(int) string = func(c int) string {
// fmt.Println(a)
// return "10"
// }
// fmt.Printf("%T\n", f)
// fmt.Printf("%T", f1)
// f2(1)
//}
func test7() func() {
//return func() {
// fmt.Println("我是内存函数")
//}
t := 10
f := func() {
fmt.Println(t)
fmt.Println("我是内存函数")
}
return f // 闭包函数
}
标签:函数,int,fmt,Println,func,go,变量,常量
From: https://www.cnblogs.com/bnmm/p/17353535.html