Go学习笔记（一）

2019-08-03  本文已影响0人  dev_winner
Go保留的关键字只有25个 Go中36个预定标识符（包括基本数据类型和系统内嵌函数） 
// 单行注释
/* 多行注释 */
// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    "fmt"
    // "time"  // 导入的包要使用，否则会产生编译错误
)

// 定义全局常量
const NAME string = "global const var"

// 定义全局变量
var tmp string = "global var"

// 一般类型声明
type countInt int

// 结构体的声明
type Learn struct {

}

// 声明接口
type Ilearn interface {

}

// 函数定义
func learnGo() {
    fmt.Println("learn go!")
}

// 主函数
func main() {
    fmt.Println("Hello World!!!")
    fmt.Println(NAME)
    fmt.Println(tmp)
    learnGo()
}

错误记录

workspace 
         |--bin

         |--pkg

         |--src
               |---learn
                        |----learn.go
               |---show
                        |----show.go
         |--main.go

import (
    "fmt"
    "src/learn"
    "src/show"
)

结果报如下错误，细细观察，通过查找和对比，可以发现上面讲的原理；

import包名的查找顺序

于是，把main.go文件中import包的代码改一下（去掉"src"）：

import (
    "fmt"
    "learn"
    "show"
)

再次键入执行命令：go run main.go，结果就成功执行了！

执行结果

learn.go的代码如下：

package learn

import (
    "fmt"
    "show"
)

func init() {
    show.Show()
    fmt.Println("learn init...")
}

func Learn() {
    fmt.Println("learn 学习...")
}

show.go的代码如下：

package show

import (
    "fmt"
)

func init() {   
    fmt.Println("show init...")
}

func Show() {
    fmt.Println("show 展示...")
}

main.go的代码如下：

// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    "fmt"
    // "time"  // 导入的包要使用，否则会产生编译错误
    "learn"
    "show"
)
// 函数定义
func learnGo() {
    fmt.Println("learn go!")
}
// init函数
func init() {
    fmt.Println("main init...")
}
// 主函数
func main() {
    show.Show()
    learn.Learn()
    learnGo()
}
go的环境配置 
// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    zzz "fmt"  // 包"fmt"的别名定义为zzz
    // "time"  // 导入的包要使用，否则会产生编译错误
    "learn"
    "show"
)

// 函数定义
func learnGo() {
    zzz.Println("learn go!")
}

// init函数
func init() {
    zzz.Println("main init...")
}

// 主函数
func main() {
    show.Show()
    learn.Learn()
    learnGo()
}

2、点（.）操作的含义是：点（.）表示的包导入后，调用该包中函数时可以省略前缀包名；

// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"  // 使用 . 操作，调用包"fmt"中的函数时，省略包名.
    // "time"  // 导入的包要使用，否则会产生编译错误
    "learn"
    "show"
)

// 函数定义
func learnGo() {
    Println("learn go!")  // 省略包名fmt.
}

// init函数
func init() {
    Println("main init...")
}

// 主函数
func main() {
    show.Show()
    learn.Learn()
    learnGo()
}

3、下划线（_）操作的含义是：导入该包，但不导入整个包，而是执行该包的init函数，因此无法通过包名来调用包中的其他函数。使用下划线（_）操作往往是为了注册包里的引擎，让外部可以方便地使用。

（_）测试1 执行产生错误

以上报错说明无法调用learn.go文件中的Learn()函数，我们将main()函数中的代码learn.Learn()注释掉，再用命令行执行main.go可以发现执行了learn.go中的init()函数，说明_操作只调用init()函数，当然在执行init()函数之前，会先初始化learn.go文件中的常量和变量。

Go语言的基本数据类型

1、布尔型：只可以是常量 true 或者 false,不能是其他类型。一个简单的例子：var b bool = true。
2、整数类型：整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
1.uint8：无符号 8 位整型 (0 到 255)
2.uint16：无符号 16 位整型 (0 到 65535)
3.uint32：无符号 32 位整型 (0 到 4294967295)
4.uint64：无符号 64 位整型 (0 到 18446744073709551615)
5.int8：有符号 8 位整型 (-128 到 127)
6.int16：有符号 16 位整型 (-32768 到 32767)
7.int32：有符号 32 位整型 (-2147483648 到 2147483647)
8.int64：有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
3、浮点数类型
1.float32：IEEE-754 32位浮点型数
2.float64：IEEE-754 64位浮点型数
3.complex64：32 位实数和虚数
4.complex128：64 位实数和虚数
4、字符串类型string，编码统一为"UTF-8"。
5、其他数字类型
1.byte：类似 uint8，无符号类型。
2.rune：类似 int32，表示一个Unicode码。
3.uint：32 或 64 位，其取决于操作系统的位数
4.int：与 uint 一样大小，其取决于操作系统的位数
5.uintptr：无符号整型，用于存放一个指针

变量与常量

var(
  a int
  b float32
  name string
)

5、同一行声明多个变量和赋值：var a, b, c int = 1, 2, 3 或者a, b := 1, 2。注意：:=是声明并赋值；系统会自动推断类型；不需要var关键字；只能使用在局部变量。
6、全局变量必须使用var关键字，局部变量则可以省略。
7、特殊变量下划线_：相当于一个垃圾桶，把值赋值给下划线
，相当于把值丢进一个垃圾桶，以后都不再使用。
8、Go语言中不存在隐式转换，类型转换必须是显式转换。类型转换只能发生在两种兼容类型之间；类型转换格式：<变量名称> [:]= <目标类型>(<需要转换的变量>)。

// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
    "reflect"
)

var(
    a uint
    b float32
    c bool
    d string = "你好"
)

func main() {
    var v1, v2, v3 = 4, 5, 1.222  // 可以声明每个变量的类型，省略的话--->系统自动推断类型
    Println(reflect.TypeOf(v3))  // float64
    Println(v1, v2, v3)  // 4 5 1.222
    Println(a, b, c, d) // 0 0 false 你好

    c1, c2, c3 := 33, "string", 1.222 // 简写方式，系统自动推断类型，只能用在函数体内
    Println(reflect.TypeOf(c2)) // string
    Println(c1, c2, c3) // 33 string 1.222

    // 下划线的使用
    // var a1, _, a2 = 9, 8, 7
    // Println(a1, _, a2) // 报错：
    // # command-line-arguments
    // .\main.go:31:9: cannot use _ as value

    // 类型转换测试： 只能用在相同类型之间进行转换
    var h float64 = 2.6555555
    k := int64(h)  // 括号不能省
    Println(k) // 2，直接向下取整
    Println(reflect.TypeOf(k))  // int64
}

// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
    "reflect"
)

const(
    name string = "cat" // 显式定义
    age = 12 // 隐式定义
)

const a, b, c = 1, 2, "我是中文"

const lenc = len(c)  // 一个中文占三个字节，长度为12

func main() {
    Println(name, age)  // cat 12
    Println(a, b, c) // 1 2 我是中文
    Println(reflect.TypeOf(c)) // string
    Println(lenc) // 12
}

// 程序所属包,每个.go文件必须要有package关键字
package main // 包名尽量与文件目录名一样

// 导入依赖包
import (
    . "fmt"
)

// iota在关键字出现时被重置为0
const a = iota // 0
const b = iota // 0

const(
    c = iota
    m = 2014 // 插入使用法，iota依然计数
    d = iota
    _  // 跳值使用法，下划线单独占用一行，iota依然计数
    e = iota
)

const(
    b1 = iota * 3
    b2 // 自动使用向上第一个非空表达式，此时每增加一行常量const，iota计数加1，即b2 = 1 * 2 
    b3 // b3 = 2 * 3 = 6
)

const(
    c1, c2 = iota + 1, iota * 3
    c3, c4  // 沿用上面第一个非空的表达式，注意格式要一样，且const新增一行，iota计数器才会加1
    c5 = iota // 否则就得赋予值

)

func main() {
    Println(a, b) // 0 0
    Println(c, d, e) // 0 2 4
    Println(b1, b2, b3) // 0 3 6
    Println(c1, c2, c3, c4, c5) // 1 0 2 3 2
}
上一篇 下一篇

猜你喜欢

热点阅读