go之基本类型与函数使用

一、go语言介绍

1 go语言介绍

Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言，特点：语法简单，速度快。

Go是静态（编译型）强类型语言，是区别于解析型语言的弱类型语言(静态：类型固定 强类型：不同类型不允许直接运算)。

python动态强类型语言。

编译型语言：Java，c，c++，c#，go

解释性语言：python，js，php...

编译型语言涉及到跨平台问题，因为它需要编译成该平台的可执行文件。比如：java运行在jvm之上。go语言可以进行跨平台编译，即交叉编译。比如，从windows上编译成linux上的可执行文件。

解释性不涉及跨平台问题，因为各个平台有各个平台的解释器。

2 go语言特性

• 跨平台的编译型语言，交叉编译
• 管道（channel），切片（slice），并发（routine）
• 有垃圾回收的机制
• 支持面向对象和面向过程的编程模式（go的面向对象中没有类的概念，python是完全的面向对象）

3 go的历史发展

• 2009年11月7日 weekly.2009-11-06 —— 早期的版本
• 2015年8月19日 go1.5 —— 实现的架构变化，同时保留了和旧版本的兼容性,本次更新中移除了”最后残余的C代码”。（从此以后，自举，自己写自己）
• 2018年8月24日 go 1.11 ：增加了modules，包管理
• 2020 年 8 月 go 1.15

4 go语言的应用领域

Google、Facebook、腾讯、七牛云

go语言书写：docker、k8s、蓝鲸...

应用领域：服务开发、并发、分布式、微服务等方向。

二、go语言开发环境

1 go环境配置

1. IDE(Goland): 集成开发环境。
2. 开发环境：sdk【一路下一步即可】
3. go语言不需要手动添加到环境变量(python、java需要)
4. go version ： 打印go的版本信息

注意事项：

1. goland创建项目：需要选择go sdk的安装路径【默认被选中】。

2. 指定gopath：代码必须放到该路径下，否则无法执行。【默认会在环境变量中创建GOPATH，需要手动自定义进行修改】。同时，所有的go代码必须放在这个路径下的src文件夹下，否则无法执行【E:Go_projectsrc项目名】。

   

3. 路径和文件都不要出现中文。

2 go常用命令

go version  // 查看go的版本信息 go env  // 查看go的环境变量   - GO111MODULE=on  // 使用了go.mod模式   - GOPATH=E:Go_project  // 代码存放路径   - GOROOT=D:golang  // go sdk安装路径   - ...  go build  // 编译。编译型语言，需要先编译再执行，编译成可执行文件 go run  // 编译并执行。两步并作一步 go clean  // 清除编译后的可执行文件  go fmt  // 格式化代码【没用】 go get  // 下载并安装包和依赖等同于pip install ... 

三、第一个hello world

//单行注释 /*多行注释*/  编译型语言:    - 编译: go build .test01.go   - 执行: .test01.exe - 编译并执行: go run .test01.go 

package main  // 声明包名，包名是main  import "fmt"  // 内置包  // 定义了一个main函数，go项目运行的入口【所以编译型语言必须有一个入口】 func main() { 	fmt.Println("hello world")  // 等同于python中的print（python中的print是内置函数） } 

注意：每个go文件都要有一个包名，代表其属于某个包。

goland中文件执行有file、package等几种方式。【可以自己进行配置，一般一个项目中使用package即可，测试的时候使用file就行】

四 变量

1 变量定义

• var 变量名 变量类型 = 变量值

  var age int = 10

  go中变量定义了就必须使用，如果不适用就报错。

• var 变量名 = 变量值 类型推导(可以不写类型)

  var age = 10

  package main  import "fmt" // 内置包  func main() { 	var age int = 10 	var name string = "YangYi" 	fmt.Printf("%Tn", age)  // int  (看类型，没有python中的type方法，没有自动换行，需要手动n) 	fmt.Printf("%Tn", name)  // string  	fmt.Print()  // 打印不换行 	fmt.Println()  // 打印换行 	fmt.Printf("%Tn", name)  // 查看类型 	fmt.Printf("%p", &name)  // 0xc0000881e0 } 

  go中变量类型一旦定义，后期不能改变。（编译型语言通用，python中可以修改，python中存放的内存地址，所以可以改变类型）

• 变量名 := 变量值 简略声明（类型和var关键字都不写）

  a := 10

  a := 10 var a int = 100 var a = 99  // 重复定义，报错（变量不可以重复定义，同时，变量必须先定义，后使用） 

  /* 只定义，不赋值 */ var a int  // 可以（只能用这种方式） var a  // 不可以（因为没有类型，不知道a是什么，因为类型需要在定义阶段确定，且不能改） 

/* 声明多个变量 */ var width, height int = 100, 50  // 第一种 var width, height = 100, 50  // 第二种 width, height := 100, 50  // 第三种  var (     name   = "YangYi"  // 不赋类型     age  int  = 29  // 赋类型     height int  // 声明 ) 

/* 小坑 */ var a int =10 var b =99 b,a:=99,100    //这个不报错，我们觉得是重复定义，冒号左侧，只要有一个没有定义过的变量，就可以 

2 变量定义规范

2.1 变量命名规范

变量命令建议用驼峰（大小写有特殊意义【私有和公有的意义】）；
go文件命名建议用 下划线；（ps：python中都建议都使用下划线；java中建议都是驼峰；js中变量名驼峰）

一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线；

大写字母和小写字母是不同的：Name和name是两个不同的变量；

关键字和保留字都不建议用作变量名；

2.2 go语言中的关键字

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

五 数据类型

1 基础数据类型

• 数字

  // 有符号整形 int 在32位机器是int32，在64位机器是int64 int8 表示整数范围是：8个比特位，8个bit是1byte ，负数和0， 2的7次方-1 的范围 int16 2的15次方减一 int32  int64 /* 强类型举例: var a int8 = 10 var b int16 = 20 fmt.Println(a + b)  // 报错【go是强类型，其中没有java中的自动类型转换一说】 fmt.Println(int16(a) + b) */ /* byte：是int8的别名  单引号包裹 rune：是int32的别名  单引号包裹 */ var a byte = 99  // int8 fmt.Println(a) var b byte = 'b'  // 存放的是字符,其中也是数字而已 fmt.Println(b)  // 98 var c rune = '你'  // 可以打印，字符中其实是数字 fmt.Println(c)  // 20320 var d byte = '你'   fmt.Println(d)  // 报错，超出范围  // 无符号整形 uint8  2的8次方减一 (定义一个人的年龄) uint16 uint32 uint64  // 浮点数（小数），表示小数点后长度多少位 float32 float64  // 复数 complex64 complex128 var a complex64 = 20 + 10i 

• 字符串

  "双引号包裹" `反引号包裹`  // 和js一样; python中是 """ """ 

• 布尔类型

  bool true 和 false var flag bool = false var flag = true 

数据类型默认值：数字类型是0， 字符串类型是空字符串，布尔类型是false。

2 常量

go中常量定义使用const关键字；java中的常量为final关键字；python中是大写。

• const 变量名 变量类型 = 变量值

  const name string = "yangyi"  // 常量可以定义之后不使用，不会报错 

• const 变量名 = 变量值

  const age = 90 

• 其他定义方式

  const name, age = "yangyi", 18 const ( 	name string = "yangyi"     age = 18 )  // 应该不会使用吧 const ( 	s1 = iota     s2     s3 = iota     s4 = 99     s5 ) fmt.Println(s1)  // 0 fmt.Println(s2)  // 1 fmt.Println(s3)  // 2 fmt.Println(s4)  // 99 fmt.Println(s5)  // 99 太奇怪  const ( 	s1 = iota     s2     s3 = iota     s4 = 99     s5 = iota ) fmt.Println(s1)  // 0 fmt.Println(s2)  // 1 fmt.Println(s3)  // 2 fmt.Println(s4)  // 99 fmt.Println(s5)  // 4 太奇怪 

六 函数

1 函数基础

func 函数名(参数名 类型, 参数名 类型)(返回值类型, 返回值类型){     函数体内容     return 返回值1, 返回值2 } 

函数使用示例

// 1 有参数无返回值 func add(a int, b int){     fmt.Println(a + b) }  add(100, 200)  // 调用函数    // 2 有参数无返回值,有多个相同类型的参数 func add(a, b int){     fmt.Println(a + b) }  // 3 有参数无返回值,有多个不同类型的参数 func add(a, b int, msg,name string){ }  // 4 多个参数，一个返回值 func add(a, b int) int {     return a + b }  // 5 多个参数，多个返回值【python和go支持多返回值】 func add (a, b int) (int, int){     return a + b, a * b }  a, b := add(100, 200)  // 多返回值就需要用多变量进行接受【和python一样】 a, _ := add(3, 4)  // python中的下划线可以打印，但是go中就是空  // 6 命令返回值 func add(a, b int) (c int, d int){     c = a + b  // 就是在函数体中已经声明了c d的变量     d = a * b       return  // 就会直接将c d返回出去，不需要写 return c,d } 

2 函数高级

函数是一等公民，函数可以赋值给变量【python中也是如此】

在编译型语言中，和解释性语言不同，没有先定义函数，后使用函数一说，编译之后都能找到。

// 匿名函数(定义在函数内部，不能有名字)： python中是lamdba // 第一种 func (){   }()  // 匿名函数直接调用  // 第二种 var a func()  // 定义一个变量，类型为func()【哈哈】 a = func(){  // 此时a是一个函数         fmt.Println("我是匿名函数") } a()  // 我是匿名函数 

// 7 函数返回值为函数 func test() func(){     return func(){         fmt.Println("我是返回的函数...")     } } a := test() fmt.Println(a)  // 0x5451e0 【打印函数名，拿到的还是函数的内存地址】   // 8 返回值函数，返回的函数带参数 // 返回值类型必须跟返回的函数类型匹配 即 func()和func(msg string)不是一个类型 func test() func(msg string){  // 返回值类型必须跟返回的函数类型匹配     return func(msg string){         fmt.Println("我是返回的函数...")     } }  a := test() a("hello")  // 函数调用  // 9 函数返回值为函数，返回的函数带参数，带返回值 func test() func(a, b int) int {     return func(a, b int) int {         return a + b     } }  a := test()  // a的类型为 var a func(a, b int)int fmt.Println(a(2, 3))  // 10 函数参数为函数类型，返回值为带参数带返回值的函数类型 func test(f func()) func(a, b int) (int, int){     f()  // f函数执行     return func(a, b int) (int, int){         f()  // f函数执行         return a + b, a * b     } }  // 函数操作 a, b := test(     func(){         fmt.Println("我是函数参数...")     } )(3, 4)  // 函数调用  // 或者  f := func(){     fmt.Println("我是函数参数...") } f1 := test(f) a, b := f1(3, 4) fmt.Println(a, b) 

3 闭包函数

①定义在函数内部； ②对外部作用域有引用；

闭包函数其实就是多了一种对函数传参的方式。

func test(age int) func() {     // age := 18       a := func(){  // 定义在函数内部         fmt.Println(age)  // 对外部作用域有引用     }     return a  }  a := test(19) a()  // 闭包函数的调用【并没有传参，实际上已经有参数传递进去】  // 一般来说，函数执行完毕，参数应该被释放，但是由于闭包函数的存在，所以age一直没有被释放，有东西对其有引用。【引出内存逃逸: 正常应该被回收，其实没有被回收】  // 装饰器是闭包函数的典型应用（go语言中没有装饰器的语法糖，python中有语法糖） 

4 type类型重命名

type MyFunc func()  // 类型重命名 func test() MyFunc  {     return func(){     } }  type MyFunc func(a,b int)(int,string) func test() MyFunc  { 	return func(a,b int)(int,string) { 		fmt.Println("xxx") 		return 10,"ok" 	} }  type Myint int  // 这里Myint和int已经不是铜鼓一个类型了 var a int = 10 var b Myint = 100 fmt.Println(a + b)  // 报错 fmt.Println(a + int(b))  // 强制类型转换 

5 变量的作用域范围

同一个包下，函数名不能重名。比如：都在main包中

// 第一种方式 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)  // 99 }  // 第二种方式【局部 ——> 全局 ——> 内置】 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) } 

推荐这些文章：

go 函数传参接口返回具体的类型

package mainimport "fmt"func Slic(q interface{}) *int { s:= q.(*int) fmt.Println(*s) switch v:= q.(type) { case *int: fmt.Println(*v) case string: fmt.Println(v) default: fmt.Println("is not type!") } return nil}func main() { var i int Slic(&i)
00
进程 已完成，退出代码...

go的复合类型

package main

import "fmt"

func main() {
arr := [10]int{} //数组
arr[1] = 8
fmt.Println(arr)

arr2 := [2][3]string{{"1", "2", "3"}} //二维数组
arr2[1][0] = "4"
arr2[1][1] = "5"
arr2[1][2] = "5"
fmt.Println(arr2)

s := []string{"你好", "再见"} //切片(代表内存地址,地址传递)
s = ap...

go语言的变量定义

package main

import "fmt"

func main() {

// 变量定于的语法格式

// 常规写法
var age int
age = 30
fmt.Println(age)

// 简化
var name string = "paul"
fmt.Println(name)

// 类型推断
var float1 = 13145.20
fmt.Printf("%f,%T",float1, float1)

// 简短写法，只能在函数中使用
r...

go语言的基础语法

字符串数组
package main

import (
"fmt"
)

func main() {
var str string
str = "hello world"
ch := str[0]
fmt.Printf("the length of\"%s\" is %d \n", str, len(str))
fmt.Println("the first character of\"%s\"is %c.\n", str, ch)
}

基本变量
package main

import (
"fmt"
)

func main() {
/*变量使用
var v1, v2...

go 空接口和结构体类型判断,

package main
import (
"fmt"
)
type Animal interface {
Talk()
Eat()
Name() string
}
type Dog struct {
}
func (d Dog) Talk() {
fmt.Println("汪汪汪")
}
func (d Dog) Eat() {
fmt.Println("我在吃骨头")
}
func (d Dog) Name() string {
fmt.Println("我的名字叫旺财")
return "旺财"
}
type Pig struct {
}
func (d Pig) Talk() {
f...

go 函数也是一种类型, 匿名函数

/* 函数也是一种类型 */
package main

import (
"fmt"
)

/* 自定义函数类型 接受两个int参数,返回int类型*/
type op_func func(int, int) int

func main() {
test_func()
}

func test_func() {
/* 声明变量c 类型为自定义类型 */
var c op_func
/* add函数赋值给c add函数接受两个int参数,返回int类型 */
c = add
sum := c(100, 103)
fmt.Println(sum)

/* 调用自定义函数,传...

go修改变量值

1,在函数中修改全局变量 情况二比情况一的函数m给a赋值多了一个:
package main

import "fmt"

var a = "G"

func main() {
n()
m()
n()
}
func n() {
fmt.Println(a)
}

/* 情况一
func m() {
a = "O"
fmt.Println(a)
}
//情况一输出:
//G
//O
//O
*/

// 情况二:
func m() {
a := "O"
fmt.Println(a)
}
//情况二输出:
//G
//O
//G

写入自己的博客中才能记得长久

...

go 函数传参切片不确定个数

package main

import "fmt"

func calc(a , b int) (int,int){
sum := a+b
sub := a-b
return sum,sub
}

func calc1(a , b int) (sum int,sub int){
sum = a+b
sub = a-b
return
}

func calc_v1(b ...int) int{
sum := 0
for i:=0;i<len(b);i++{
sum += b[i]
}
return sum
}

func calc_v2(a int,b ...

go 语言里面的 & 和 *

& ：返回变量的存储地址
* ：取指针变量对应的数值

package main
import "fmt"
func main(){
//定义一个变量：
var age int = 18
fmt.Println("age对应的存储空间的地址为：",&age)//age对应的存储空间的地
var ptr *int = &age
fmt.Println(ptr)
fmt.Println("ptr这个指针指向的具体数值为：",*ptr)
}

...

go语言学习——接口

1、接口的定义

import "fmt"

type Personer interface {
SayHello()
}

type Student struct {

}

func (stu *Student)SayHello() {
fmt.Println("老师好")
}

func main() {
//创建一个学生对象
var stu Student
//通过接口变量的方式来调用，必须都实现接口中声明的所有方法
var person Personer

person = &stu
person.SayH...