go,int基本类型加安装过程,

go

下载最新go的包,下载goland

直接安装
会自动添加两个环境一个gopath是你所有的执行文件

```go
//单行注释
/* 多行注释*/


package main // 标识当前go文件属于main包
import "fmt" // 导入fmt包
func main(){
    fmt.Println("hello world")//打印 同 python print 一样
}

a...是编辑器给你的提示,参数名是a
```

## 定义变量的三种方式:

```go
第一种:
    var a int=10//声明变量,var,类型 然后值
第二种:
    var a = 10//类型推导
第三种:
    a:= 10// 也是最常见的
强类型语言声明就只能使用该类型,不可从新赋值,
var(
    name = "haha"
    age = 29
    height int
)
一次声明多个变量

var a int//不赋值默认值就是0
str 就是空的字符串
```

```go
fmt.Printf("%T",a) // 查看a是什么类型
```

### int中的类型

```go
    /*
    int类型：表示整数,int8   int16  int32  int64
    计算机最小计量单位：bit位  int8 是 8个比特位=1个字节，表示的范围是：正负2的7次方减1
    在32位机器上int 就是int32 ，在64位机器上int就是int64
    uint类型：表示正整数 uint8 uint16...
    float类型：表示小数只有float32和float64
    complex64类型：复数
    byte: uint8的别名
    rune:int32的别名
     */
```

### 声明常量:

```go
const a  = 10
常用在settings中
关键字声明const
```

### 函数

基本格式

```go
func main(参数 类型,参数2 类型,参数3 类型) (返回值类型,多个用括号一个不用){
    函数体代码
    
}
//在go中没有位置参数和关键字参数，都是位置参数,也没有默认参数

什么是闭包函数
定义在函数内部对外部作用域的引用 ,就是闭包函数
def func():
    a = 10
    def innter():
        res = a+20
        return res
    return innter

res =  func()
print(res())


//命名返回值
//func test(a,b int) (c int, d string)  {
//    c=10
//    d="成功"
//    return
给返回值命名  一般一会用

//返回多个值
//func test(a,b int) (int,string)  {
//    return a+b,"成功"
//不定长参数
//func test(a ...interface{})  {
//    fmt.Println(a)



func innser(a ...interface{}){
    fmt.Println(a)
}

func res()  {
    innser(1,2,2,3,3)
}

func main()  {
    res()
}
interface接受多个参数
```

​    接受返回函数返回值,"_"代表接受空就是不要该返回值

返回值为函数的

package main

import "fmt"

func Test(person string)(work func()string) {
/*
Do someting
*/
work = func()string{
return (person + " is working")
}
return
}
func main() {
p := Test("Sergey")
fmt.Println(p) //输出结果:0x10b2790
fmt.Println(p()) //输出结果:Sergey is working
//我想说的重点应该是在这里
}