go语言基础变量、类型、函数
一、介绍
2009年11月Google公司正式对外公开的一门编程语言，语法简单，速度快。是静态（编译型）强类型语言。Python是动态强类型语言
编译型：java， c， c++， c#， go 涉及到跨平台，因为他们需要编译成该平台的可执行文件，但go可以跨平台编译即交叉编译，例如在windows上可以编译出mac上执行
解释型：python，js，php...... 不存在跨平台，有解释器
特性：跨平台编译型语言，管道，切片，并发，由垃圾回收机制，支持面向对象和面向过程的编程模式
二、开发环境搭建
1、IDE继承开发环境，推荐用goland或者pycharm，idea，androidstudio
2、开发环境
go get # 下载并安装包和依赖等同于pip install
三、第一个程序
1.hello world
package main //单行注释 /* 多行注释 */ /* go(所有编译型语言)项目运行，必须有一个入口 go的入口是main包下的main函数 main包下不可以有多个main函数 */ import "fmt" //导入包，内置包 func main() { fmt.Println("hello world") //打印函数，等于Python的print() }
2、变量命名与定义
package main import "fmt" func main() { //1.定义变量的第一种方式 //var 关键字 变量名 变量类型 = 变量值 ，且在go中，变量定义了就必须使用，如果不使用就报错 //var age int = 18 //fmt.Println(age) //2.第二种方式：类型推导（类型不需要写了） //var age = 10 //fmt.Println(age) //打印不换行 //fmt.Printf("%T", age) //打印类型 //fmt.Printf("%P", age) //打印内存地址 //3.第三种：简略声明（类型和var关键字都不写) //age := 18 冒号等号中间不能分开 //fmt.Println(age) //4.其他变形方式 //var age int //定义变量，只定义不赋值，只能用这种 //fmt.Println(age) //声明多个变量 //var width, height int = 100,50 //var width, height = 100,50 //width, height := 100,50 //声明多个变量并赋值 var ( name = 'a' age = 18 height int ) fmt.Println(name, age, height) //只要冒号左侧有一个没有定义过的变量，就不报错,如下 var a int = 10 b, a := 100, 99 fmt.Println(b, 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
*/
3.类型
package main import "fmt" func main() { /* 基础数据类型 数字： 有符号整形 -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 */ //强类型，不同类型不允许直接运算 var a int8 = 6 var b int16 = 78 //fmt.Println(a+b) //此时是不能这样运算的 fmt.Println(int16(a) + b) //此时转为一种类型是可以运算的 }
4.常量
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 关键字定义，不允许改变
5.函数
定义方式
/* func 名字(参数名 类型，参数名 类型)(返回值类型，返回值类型){ 函数体内容 return 返回值1，返回值2 } */
写函数方式，对于函数，定义的函数需要在main包外面重新定义新的函数，然后函数的调用在main包里面调用
基本函数
package main import "fmt" //函数 func main() { //1、2调用函数 //add(2,3) 直接给函数传参 //3调用函数 add(2,3,"xxx") //一个返回值，直接用一个变量接收 //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(_) } //创建函数 //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 多个参数，一个返回值，括号后面加int //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 //}
高级函数：变量作函数、闭包函数
//函数 func main() { var a int =10 var b Myint=9 fmt.Println(a+int(b)) //匿名函数(定义在函数内部的函数，不能是有名函数)，头等函数。函数是一等公民，函数可以赋值给变量 //var a func() //a = func (){ // fmt.Println("我是匿名函数") //} //a() 调用a变量，打印"我是匿名函数" //7 函数返回值是函数 //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中没有装饰器的语法糖），通过闭包实现装饰器 } //7 函数返回值为函数，test()后面的func()是类型，返回的时候也得声明类型func() //func test() func() { // return func() { // fmt.Println("我是返回函数") // } //} //8 函数返回值为函数,返回的函数带参数 // 类型只要有不一样的地方，就不是一个类型,比如此时func(msg string)为带参数的类型，所以return时也必须func(msg string)，这样类型才一致 //func test() func(msg string) { // return func(msg string) { // fmt.Println(msg) // } //} //9 函数返回值为函数,返回的函数带参数,带返回值，此时func(a,b int) int整体为类型 //func test() func(a,b int) int{ // return func(a,b int) int { // return a+b // } //} //10 函数参数为函数类型，返回值为带参数，带返回值的函数类型，f func()：f为函数参数，func()为函数参数类型。func(a,b int) (int,int)分别为返回值参数类型 //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对外部作用域有引用 // 闭包函数就是多了一种函数传参的方法，包进去了。此时a调用了函数参数age //func test(age int) func() { // a:= func() { // fmt.Println(age) // } // return a //}
给类型重命名
package main import "fmt" //给类型命别名，此时给func(a,b int)(int,string)类型命名为MyFunc，然后后面调用这个类型时，直接调用名字 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)) //类型重命名 var a MyFunc =test() //fmt.Println(a) //打印函数地址 c,d := a(1,2) //c,d就是接收返回值的10，“ok” fmt.Println(c,d) } func test() MyFunc { return func(a,b int)(int,string) { //(int,string)为返回值类型对应返回值10,"ok"。此时a,b相当于参数 fmt.Println(a+b) return 10,"ok" } }
6、变量作用域范围
同一个包下，函数名不能重名
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) }
浙公网安备 33010602011771号