Go基础学习二

Go编程语言：支持并发、垃圾回收的编译型系统级编程语言！本文主要是按照无闻的《Go 编程基础》开源视频学习并记录笔记。

一、go语言常用命令

go get 获取远程包（需提前安装git）
go run 运行
go build 测试编译(package main 的文件)
go fmt 格式化代码
go install 编译包文件和整个程序
go test 运行测试文件（**_test.go是测试文件，命名自己文件的时候需要注意）
go doc 查看文档（本地官网 godoc -http=:8080 & 后台执行）

我们可以将go的官网放到本地：

godoc -http=:8080

然后我们可以访问本地8080端口：

http://localhost:8080/

Go环境变量与工作目录：GOPATH下需要建立 3个目录（bin存放编译后生成的可执行文件；pkg存放编译后生成的包文件；src存放项目源码）

二、go 语法结构

1、Go导入package的格式

package main包含main函数
一个程序有且只有一个main包和一个main函数
package 要放在非注释的第一行
package 后加import,import 引入非main包
一般建议package的名称和目录名一致 pacage 名称不要使用驼峰标记法,使用下划线
var 全局变量
type 基本类型 比如：type newtype struct/interface{（内容）}

改包名：

import abc "fmt"/import . "fmt"

调用的时候

abc.Println/Println

不推荐使用.那种，容易混淆

只有package 为 main 的包可以包含main函数，一个可执行程

test.go

package ok
// package main  这里故意将main 包名写错

import "fmt"

func main(){
    fmt.Println("Hello,World")
}

如果我们运行的程序里边没有 package main 包，则执行会报错；
? src go run myfirstgo/test.go go run: cannot run non-main package

• 导入包之后，就可以使用格式<PackageName>.<FuncName>
• 如果导入包之后 未调用 其中的函数或类型将会报出编译错误

import and not used:"io";

2、package别名

当使用第三方包时，包名可能会非常接近或相同，此时就可以使用别名来进行区别和调用

import "fmt"

// 使用别名
import std "fmt"
std.Println("Hello,world")

省略调用

// 省略调用
import . "fmt"
Println("Hello,world")

注意点：
1.不建议使用省略调用，易混淆
2.不可以和别名同时使用

3.可见性规则

Go语言中，使用 大小写 来决定该常亮、变量、类型、接口、结构或函数，是否可以被外部包所调用：
根据约定，函数名首字母小写即为private

func getField(){
  // ...
}

函数名首字母大写即为public

func Print(){
  // ...
}

完整示例：

package main

// 导入其他的包
import "fmt"     // 第一种导入方法
/*
import{
    "fmt"
    "io"
    "os"
}
*/

// 常量的定义
const PI = 3.14

// 全局变量的声明与赋值
var name = "gopher"

// 一般类型声明
type newType int

// 结构的声明
type gopher struct{}

// 接口的声明
type golang interface{}

// 由 main 函数作为程序入口点启动
func main(){
    fmt.Println("Hello,World")
}

牛刀小试：
既然导入多个包可以进行简写，那么声明多个常亮、全局变量或一般类型（非接口、非结构）是否也可以使用同样的方法呢？

定义常亮：

const(
  PI = 3.14
  const1 = 1
  Radis = 10
)

全局变量的声明与赋值:

var (
 name = "corwien"
 age  = 20
 address = "guangzhou"
)

一般类型声明:

type (
 newType int
 type1 float32
)

三、类型与变量

1.类型

1、布尔类型：bool
长度：1字节
取值范围：true,false
注意事项：不可以用数字代表true或false

2、整型：int/uint
-根据运行平台可能为32或64位

3、8位整型：int8/uint8
-长度：1字节
-取值范围：-128~127/0~255

4、字节型：byte(uint8别名）

5、16位整型：int16/uint16
-长度：2字节
-取值范围：-32768~32767/0~65565

6、32位整型：int32(rune)/uint32
-长度：4字节
-取值范围：-32768~32767/0~65565

7、浮点型：float32/float64
-长度：4/8字节
-小数位：精确到7/15小数位

8、复数：complex64/complex128
-长度：8/16字节
足够保存指针的32、64位整数型：uintptr

9、其他值类型：

• array、struct、string

10、引用类型：

• slice，map，chan

11、接口类型：interface
12、函数类型：func,可以赋值给变量

类型零值

零值并不等于空值，而是当变量被声明为某种类型后的默认值，通常情况下值类型的默认值为0，bool为false,string为空字符串

类型别名

type (
  byte int8
  rune int32
  文本 string
)

// 使用中文类型，牛逼啊
var b 文本
b = "你好哈亲"

2.变量

2.1 单个变量的声明与赋值

• 变量的声明格式：var <变量名称><变量类型>
• 变量的赋值格式：<变量名称> = <表达式>
• 声明的同时赋值：var <变量名称>[变量类型] = <表达式>

示例：

var a int // 变量的声明
a = 123   // 变量的赋值

// 变量声明的同时赋值
var a int = 123

// 上行的格式可省略变量类型，由系统推断
var c = 123

// 变量声明与赋值的最简写法
d := 678

d := 678 冒号的作用就是代替关键字 var 的

2.2 多个变量的声明与赋值

• 全局变量的声明可以使用var()的方式进行简写
• 全局变量的声明不可以省略var,但可以使用并行方式
• 所有变量都可以使用类型推断
• 局部变量不可以使用var()的简写，只能使用并行方式

举例：

var(
  // 使用常规方式
  a = 'hello'
 
  // 使用并行方式以及类型推断
   b,c = 1,2
  // d := 3 // 不可以省略 var
)

多个变量的声明

// 多个变量的声明
var a,b,c int

// 多个变量的赋值
a,2,3

// 多个变量声明的同时赋值
var d,e,f int = 4,5,6

// 省略变量类型，有系统推断
var g,h,m  = 7,8,9

// 多个变量声明与赋值的最简写法
n,o,p := 10,11,12

2.3 变量的类型转换

• Go中不存在隐式转换，所有类型转换必须显示声明
• 转换只能发生在两种相互兼容的类型之间
• 类型转换的格式：

// 当变量未在前边申明过，则需要冒号：，如果已经声明过，则不需要冒号
<ValueA>[:] = <TypeOfValueA>(<ValueB>)

示例：

// 在相互兼容的两种类型之间转换
var a float32 = 1.1
b := int(a)

// 以下表达式无法通过编译
var c bool = true
d := int(c)

全局变量的声明不可以省略var 局部变量不可以使用var()的方式简写

思考
尝试运行下边的代码，开会发生什么，并思考为什么？

// 变量类型转换，整数转为字符，会发生什么呢？
func main() {
    var a int = 65
    b := string(a)
    fmt.Println(b)
}

四、常量与运算符

1、常量的定义

• 常量的值在编译时就已经确定
• 常量的定义格式与变量基本相同
• 等号右侧必须是常量或者常量表达式

// 定义单个常量
const a int = 1
const b = 'A'
const {
  text = "123"
  length = len(text)
  num = b * 20
}

// 同时定义多个变量
const i,j,k = 1,"2","3"
const(
  text2,length2,num2 = "234",len(text2),k * 10
)

2、常量的初始化规则与枚举

• 在定义常量组时，如果不提供初始值，则表示将使用上行的表达式
• 使用相同的表达式不代表具有相同的值
• iota是常量的计数器，从0开始，组中每定义1个常量自动递增1
• 通过初始化规则与iota可以达到枚举的效果
• 每遇到一个 const 关键字，iota就会重置为0

示例：

const (
    // a与b都为"A"
    a = "A"
    b
    c = iota
    d // d的值为3
)

const(
  e = iota
  f // f 的值为1
)

// 星期枚举
const(
  // 第一个常量不可省略表达式
    Monday = iota
    Tuesday
    Wednesday
    Thursday
    Firday
    Saturday
    Sunday
)

3、运算符

• Go中的运算符均是从左至右结合
  优先级（从高到底）
• ^ ! (一元运算符）
• * / % << >> & &^
• + - | ^ (二元运算符）
• == != < <= >= >
• <- (专门用于channel)
• &&
• ||

相关资源：
Go 编程基础
Go学习笔记整理

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!