go-基础语法
注释
//单行注释 /* 多行注释 多行注释 */
执行
go(所有编译型语言)项目要运行,必须有一个入口 go的入口是main包下的main函数 // main包下可不可以有多个main函数:不可以 package main //声明包名,包名是main,每一个go文件都属于某个包 import "fmt" //导入包,内置包 func main() { //定义了一个main函数,大括号包裹是函数体的内容 fmt.Println("hello world") //打印函数等同与print() } go文件执行前要先进行编译后才能执行 第一种方法 命令编译后执行 // 编译 go build s1.go // 执行 s1.exe 第二种方法 编译并执行,两步并一步 // 编译并执行
go run s1.go 第三种方法 右键运行 // 在goland中,右键,运行即可
package main func main() { //1 定义变量的第一种方式:全定义 //var关键字 变量名 变量类型 = 变量值 var age int =10 //在go中,变量定义了就必须使用,如果不使用就报错 fmt.Println(age) //2 定义变量的第二种方式:类型推导(类型不需要写了) var age =10 age=100 var name ="lqz" fmt.Println(age) //打印并换行 fmt.Print(name) //打印不换行 fmt.Printf("%T\n",age) //查看变量类型 fmt.Printf("%T",name) fmt.Printf("%p",&name) //3 定义变量的第三种方式:简略声明(类型和var关键字都不写)这种用的多,冒号和等号是一家 a:=10 var a int =100 //重复定义 var a =99 //重复定义 a:=99 //重复定义 a=99 fmt.Println(a) //4 其他变形方式 //4.1 只定义不赋值 var age int //定义变量 //如果是只定义,不赋值,只能用这种 var age //只定义,不赋值,不行 //4.2 声明多个变量 var width, height int = 100, 50 // 声明多个变量 var width,height =100,50 // 声明多个变量 var width,height =100,"lqz" // 声明多个变量 width,height :=100,";qz" // 声明多个变量 //4.3 声明多个变量,并赋初值 var ( name = "naveen" age int = 29 height int ) fmt.Println(name,age,height) //4.4 小坑(两个参数要有一个没有被定义过) var a int =10 //var b =99 b,a:=99,100 //这个不报错,我们觉得是重复定义,冒号左侧,只要有一个没有定义过的变量,就可以 fmt.Println(b) fmt.Print(a) /* 总结: 1 变量类型在定义阶段就确定了,一旦确定,不允许改变 2 变量不可以重复定义 3 变量要先定义再使用 */ }
/* 变量命名规范 -变量命令建议用驼峰,(大小写有特殊意义) -go文件命名建议用 下划线 - 一个名字必须以一个字母(Unicode字母)或下划线开头,后面可以跟任意数量的字母、数字或下划线 -大写字母和小写字母是不同的:Name和name是两个不同的变量 -关键字和保留字都不建议用作变量名 */ /* Go语言中关键字有25个 break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var go语言中有37个保留字,主要对应内建的常量、类型和函数 内建常量: true false iota nil 内建类型: int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error 内建函数: make len cap new append copy close delete complex real imag panic recover */
基础数据类型 数字: 有符号整形 -int:在32位机器是int32,在64位机器是int64 -int8:表示整数范围是:8个比特位,8个bit是1byte ,负数和0, 2的7次方-1 的范围 -int16 2的15次方减一 -int32 -int64 无符号整型 -uint8 2的8次方减一 定义一个人的年龄 -uint16 -uint32 -uint64 浮点型(小数),表示小数点后长度多少位 -float32 -float64 复数 -complex64 -complex128 byte:是int8的别名 单引号包裹 rune:是int32的别名 单引号包裹 字符串 双引号包裹 反引号包裹 ` ` 布尔 bool true 和 false 数据类型默认值: 数字类型是 0 字符串类型是 空字符串 布尔类型 false
package main func main() { //常量的定义,第一种 //const 变量名 变量类型 = 变量值 const age int8 = 99 //常量定义了就不能修改就报错 age=199 fmt.Println(age) //第二种方式类型推导 const age = 99 age=88 fmt.Println(age) //其他定义方式 const name,age = "zhangsan",99 const ( name string ="lqz" age =99 ) const ( s1 =iota s2 =iota s3 s4 =99 s5 =iota ) fmt.Println(s1) fmt.Println(s2) fmt.Println(s3) fmt.Println(s4) fmt.Println(s5) } //const 关键字定义,不允许改变
package main import "fmt" //给类型命别名 type MyFunc func(a,b int)(int,string) type Myint int //函数 func main() { // 类型不同相加不了 var a int =10 var b Myint=9 fmt.Println(a+int(b)) // 必须要强制转换为相同类型 //定义方式 /* func 名字(参数名 类型,参数名 类型)(返回值类型,返回值类型){ 函数体内容 return 返回值1,返回值2 } */ //1 调用函数 add(2,3,"xxx") var a int =add(2,3) a := add(2, 3) fmt.Println(a)
//多返回值就需要用多变量接收 a,b:=add(3,4) fmt.Println(a,b)
//多返回值,忽略一个返回值 a,_:=add(3,4) fmt.Println(a) fmt.Println(_) //匿名函数(定义在函数内部的函数,不能是有名函数),头等函数 var a func() a = func (){ fmt.Println("我是匿名函数") } a()
//函数返回值是函数 a:=test() fmt.Println(a) // 函数内存地址 a()
//8 函数返回值为函数,返回的函数带参数 a:=test() a("xxx") //9 函数返回值为函数,返回的函数带参数,带返回值 var a func(a,b int)int a=test() fmt.Println(a(2,3)) //10 函数参数为函数类型,返回值为带参数,带返回值的函数类型 a,b:=test(func() { fmt.Println("我是函数参数") })(3,4) f:= func() { fmt.Println("我是函数参数") } f1:=test(f) a,b:=f1(3,4) fmt.Println(a,b) //闭包函数的使用 a:=test(19) //a是闭包函数 a() //装饰器是闭包函数的典型应用(go中没有装饰器的语法糖),通过闭包实现装饰器 //类型重命名 var a MyFunc =test() c,d:=a(1,2) fmt.Println(c,d) } //1 有参数无返回值(定义函数) func add(a int,b int) { fmt.Println(a+b) } //2 有参数无返回值,有多个相同类型参数 func add(a ,b int) { fmt.Println(a+b) }
//3 有参数无返回值,有多个相同类型参数,也有不同类型 func add(a ,b int,msg string) { fmt.Println(a+b) fmt.Print(msg) } //4 多个参数,一个返回值 func add(a, b int) int { return a + b } //4 多个参数,多个返回值 func add(a, b int) (int,int) { return a + b,a*b } //5 命名返回值 func add(a, b int) (c int,d int) { c=a+b d=a*b //return时,不需要再写c,d了 return } //6 函数是一等公民,函数可以赋值给变量 //7 函数返回值为函数 func test() func() { return func() { fmt.Println("我是返回函数") } } //8 函数返回值为函数,返回的函数带参数 // 类型只要有不一样的地方,就不是一个类型 func test() func(msg string) { return func(msg string) { fmt.Println(msg) } } //9 函数返回值为函数,返回的函数带参数,带返回值 func test() func(a,b int) int{ return func(a,b int) int { return a+b } } //10 函数参数为函数类型,返回值为带参数,带返回值的函数类型 func test(f func()) func(a,b int) (int,int){ return func(a,b int) (int,int) { f() return a+b,a*b } } //11 闭包函数:1 定义在函数内部 2对外部作用域有引用 // 闭包函数就是多了一种函数传参的方法,包进去了 func test(age int) func() { a:= func() { fmt.Println(age) } return a } //12 自定义函数名 func test()MyFunc { return func(a,b int)(int,string) { fmt.Println("xxx") return 10,"ok" } }
package main import "fmt" //在同一个包下,函数名不能重名 var a int //全局变量,全局有效,只要改了,就是改了 func main() { fmt.Println(a) //0 a=19 fmt.Println(a) //19 test1() //99 fmt.Println(a) //99 } func test1() { a=99 fmt.Println(a) } //变量的作用域范围 var a int //全局变量,全局有效,只要改了,就是改了 func main() { var a int fmt.Println(a) //0 a=19 //局部变量 fmt.Println(a) //19 test1() // 0 fmt.Println(a) //19 } func test1() { fmt.Println(a) }