• 只有 package main 的文件才可以编译成可执行文件,其他包编译后不是可执行文件,但是可以被其他文件调用

自己文件测试的时候,也要写 package main 才可以运行,否则提示
cannot run non-main package

  • 一个文件夹下面很多文件 ,但是只能有一个 main 函数,而且他们的包名要一样,同一个 包名下的文件里的东西,可以直接使用 而不需要导入包的操作

(其他函数也不能重名 ?在不同文件?)

  • main () 函数永远没有参数,没有返回值

  • go 里面 不强制使用 当然你想用也可以啦(其实是编译的时候,会自动给每行加个 的) 。 另外 一行多句可以用 连接(但是 所有语言都不推荐这样写)

  • 如果一个包里的函数或者变量想让其他包调用,那么他的名字 首字母要大写(相当于java public, 否则就是私有地 无法调用)

  • 如果要go build main_package 生成可执行文件

那么 go build 后面要指定 (相对于当前 gopath 的src 的位置)xx/…/main(package main 的目录即可)

  • go build -o 文件路径 main包

指定产生可执行文件的位置
如果不指定则默认放在当前 命令行左边的目录下
比如 gopath> go build -o bin/xx.exe mainpackage

  • go run xx (直接run 的时候如果依赖其他文件,需要都写上[xx..])

go build 模块目录 则会自动搜索当前模块的文件,打包为一个独立的可执行文件

  • 同一个包内的变量函数 都是可以共享的,只有不同包才有 公开和私有变量的概念

比如 main 包下面 a.go 声明 了 cc 变量, 那么 main 包下面的 b.go 就可以直接使用 cc 。但是 如果 b.go 不属于 main 包,那就汇报错(除非 cc 声明为 Cc 也就是公开变量)

image.png
  • 因为编译型语言 ,在函数外面不能有执行语句

但是声明并且初始化是可以的 例如 var xx int = 5
但是 在程序文件函数之外的全局变量 不能先声明后赋值
var xx int
xx = 5 // 报错 non-declaration statement outside function body
这也就解释了 为什么 := 只能写在函数内 因为 := 就是 上面两行的缩写。

  • 使用 引入包的别名 相当于 python imoprt xx as xx

import {
   new_package_name  “xx/xx/xxpackagename”
}

然后直接使用 new_package_name 而不用 xxpackagename
经常出现在 包的名字重复 或者太长等不友好的时候使用

  • 每个源文件 都可以有一个 init 初始化函数

package add
func init(){
  your code 
}

每个源文件都可以自定一个 init ,他会在这个文件被使用之前,最后执行 init 函数

执行导入包嵌套顺序

main 导入了 add 包 add 倒入了 test 包。那么tets 的 init 最先执行,其次是 add 最后是 main包

  • 使用 _ 别名 ,导入包只初始化,不用 这样不会报错

package main

import (
    "add"
)
如果不用 add 就会报错了
但是如果add 里面有我们需要的初始化的内容,想要 init 执行一下
那就需要这样 
import (
_ "add"
)
给导入的包 用 _ 别名代替,这样不使用也不会报错了。
  • 批量声明或者引入包这些操作,可以用 ([…])简洁操作多个变量或者导入包

  • 值类型

基本数据类型:int float bool string 数组和struct (通常在栈中分配内存)

  • 引用类型

指针 slice(切片) map(字典) chan(管道) (通常在 堆中分配内存)

  • 其实 可变类型 都是传入的地址

可以理解为一个特殊的指针,声明参数的时候 并没有 带* ,传入的时候也没有 & 符号。简化了 这个操作过程

  • 局部变量就是在 { 里面的} if for 里面都是局部变量

  • 浮点数没有直接 float 的类型 只有 float32 64

但是 整形就有 int 直接写的(这个一般是 四个字节的) 其实和 int32 差不多,但是确实是不同的整形

  • 其实函数的参数都是复制了一份

不同的是 对于值类型,形参直接存储值copy,而引用类型,形参存储的是引用 地址的cpoy

  • 一个字符(存储会转化为 整数) 类型为 byte(单引号,输出需要格式化 %c) 字符串是 string 类型

  • 字符串 为 " " 也可以是 “

后者相当于 多行字符串 n 等转移字符串原样输出。

  • 关于 fmt 的输入输出 fmt 包

其实 fmt 里面有很多io 操作的
fmt 地址 :https://golang.org/pkg/fmt/#Print

func Errorf(format string, a …interface{}) error

func Fprint(w io.Writer, a …interface{}) (n int, err error)

func Fprintf(w io.Writer, format string, a …interface{}) (n int, err error)

func Fprintln(w io.Writer, a …interface{}) (n int, err error)

func Fscan(r io.Reader, a …interface{}) (n int, err error)

func Fscanf(r io.Reader, format string, a …interface{}) (n int, err error)

func Fscanln(r io.Reader, a …interface{}) (n int, err error)

func Print(a …interface{}) (n int, err error)

func Printf(format string, a …interface{}) (n int, err error)

func Println(a …interface{}) (n int, err error)

func Scan(a …interface{}) (n int, err error)

func Scanf(format string, a …interface{}) (n int, err error)

func Scanln(a …interface{}) (n int, err error)

func Sprint(a …interface{}) string

func Sprintf(format string, a …interface{}) string

func Sprintln(a …interface{}) string

func Sscan(str string, a …interface{}) (n int, err error)

func Sscanf(str string, format string, a …interface{}) (n int, err error)

func Sscanln(str string, a …interface{}) (n int, err error)

type Formatter

type GoStringer

type ScanState

type Scanner

type State

type Stringer

  • 简单说说 Print Println Printf 的区别:
    从他们函数定义来说: Print Println 接收可变参数 (Println 会在末尾多输出 n),而Printf 第一个是占位字符串,后面是 可变参数(可变参数个数要和第一个参数占位符一一对应)

  • 还有 Sprint 和 Print 区别 :返回值不一样 带S 开头的,会有字符串返回(原来是输出到控制台的,现在直接返回给调用者,控制台不在输出了)

  • go 函数不支持重载,一个包里面不能有重复 函数名

  • 函数也可以定义为一种类型

例如 type func_type func (int, int) int func_type 就是一种类型(两个int 参数,一个返回int 类型的函数类型)任何满足这个结构的函数都可以属于这个类型,你也可以当做普通类型来声明一个变量

  • 函数返回值可以直命名

例如 func (int, int) int { xx := 1 return xx}
也可以直接 func (int, int) (xx int) {xx := 1 return}
(第二种,直接制定了 返回变量,所以 return 后面就不需制定了)

  • 函数可变参数

func xx(args...int) int { 
}
格式固定 ... 连接可变参数名和 类型, 这个和 python * 类似
函数里面 用 args[index] 来取出每个可变 参数的值
  • defer 关键字 吧语句 压入栈

func xx() {
    a := 1
    defer  fmt.Printf("a is %d", a)
    a = 100   
    fmt.Printf("a is %d", a)
}
func main(){
  xx()
}
>> a is 100  a is 1
defer 会先把当前标记的语句放到函数最后执行,但是 ,现在会立即把u哦
有变量值固定住,放到堆栈。(有点进程加 py finally 的感觉)
多个 defer 语句遵循 后写的先执行。
  • label 不止可以使用 goto 跳转

其他的break continue 也是可以的

  • 使用 new 或 make 给变量分配内存

new 为 值类型分配内存(返回的是指针) make为 可变类型分配内存

  • 数组申明时,不加长度就是一个切片slice

var a [] int (slice切片,引用 类型,使用时候,必须通过make 分配内存才可以使用)
var b [2] int 数组值类型
切片和普通数组的区别就是,切片传给函数,函数内部可以该变切片的值到外面。

  • 字符串也是一个数组

其实字符串底层是 bytes 类型元素的数组
比如py 常见的 字符串可以切片,同样 go 也可以

var a = "aabb"
b := a[0:3]
b就是  aab 了  (但现在 b底层是一个 bytes 类型的切片了)

  • 字典 map 类型

image.png

ps 例如 slice map 这些 ,如果不直接赋值初始化,后面就要用 make 初始化,否则无法使用

  • 普通类型也可以添加自定义方法

普通结构体,当然可以绑定他自己的方法,只要上面一个方法在它前面,加上它所属于的结构体的类型,它就属于这个结构体,这个已经讲过了。
其实你也可以把函数绑定在普通的类型上,比如像下面这样:

func (a int)  get() {
    fmt.Print(a)
}
var a = 2
a.get()
>>  2

太灵活 了

  • go 的结构体继承通过结构体类型的字段实现

通过在结构体里面写其他结构体类型的匿名字段,实现继承那个结构体里面的东西

image.png

文章来源于互联网,如有雷同请联系站长删除:go 教程笔记

发表评论