string 和 byte[] - Golang教程网

Go语言以“包”作为管理单位，每个 Go 源文件必须声明它所属的包，所以我们会看到每个 Go 源文件的开头都是一个 package 声明

package main    // 声明 main 包，main 包是 Go 语言程序的入口包，一个 Go 语言程序必须有且仅有一个 main 包。如果一个程序没有 main 包，那么编译时将会出错，无法生成可执行文件。

import "fmt"       // 导入 fmt 包，导入的包中不能含有代码中没有使用到的包，否则Go编译器会报编译错误

func main() {   // 声明 main 主函数，main 函数只能声明在 main 包中，不能声明在其他包中，并且，一个 main 包中也必须有且仅有一个 main 函数。Go语言函数的左大括号{必须和函数名称在同一行，否则会报错。
    fmt.Println("Hello World!") // 打印 Hello World!
}

Go 语言基本数据类型

boolstringuint8uint16uint32uint64int8int16int32int64uintptrintuintbyterunefloat32float64complex64complex128

大多数情况下，我们只需要 int 一种整型即可，它可以用于循环计数器（for 循环中控制循环次数的变量）、数组和切片的索引，以及任何通用目的的整型运算符，通常 int 类型的处理速度也是最快的。

byte 和 rune 可以表示字符类型

var b byte = 'a'
fmt.Println(b) // 97

Go语言中不允许将布尔型强制转换为整型，编译会报错

var n bool
fmt.Println(int(n))
// cannot convert n (type bool) to type int

变量的声明

使用 var 关键字（函数内外都可使用）

1. var a, b int
2. var a, b string = "hello", "world" // 字符串不能用单引号，可以不提供变量类型
3. var (
    a int,
    b string,
    c bool = true,
    d = "hi"
)
4. str := `this is another
string`

使用 := 方式声明（仅函数内部可用）
使用 := 声明变量不能提供数据类型

1. a := 1
2. a, b := 2, "hi" // 同时声明并赋值多个变量

Go语言中没有隐式转换，只能强制转换，const 定义常量没有指定数据类型时可以隐式的转换数据类型

package main

import "fmt"

func sum(a float32, b float32) float32{
    return a + b
}

func main(){
    // var m, n = 1.1, 2 // 报错
    const m, n = 1.1, 2 // 正常
    fmt.Println(sum(m, n))
}

常量

const Pi = 3.14159

在 Go 语言中，你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

const b string = "abc"const b = "abc"

数字型的常量是没有大小和符号的，并且可以使用任何精度而不会导致溢出

并行赋值

const beef, two, c = "eat", 2, "veg"
const Monday, Tuesday, Wednesday, Thursday, Friday, Saturday = 1, 2, 3, 4, 5, 6
const (
    Monday, Tuesday, Wednesday = 1, 2, 3
    Thursday, Friday, Saturday = 4, 5, 6
)

指针

package main

import "fmt"

func main(){
    str := "指针"
    fmt.Println(&str) // 0xc0000501f0
    fmt.Printf("%T", &str) // *string
}

&*

package main

import "fmt"

func main(){
    str := "PHP is the best language in the world!"

    ptr := &str

    value := *ptr

    // 打印ptr的类型
    fmt.Printf("ptr type: %T\n", ptr) // ptr type: *string

    // 打印ptr的指针地址
    fmt.Printf("address: %p\n", ptr) // address: 0xc0000661e0

    // 取值后的类型
    fmt.Printf("value type: %T\n", value) // value type: string

    // 指针取值后就是指向变量的值
    fmt.Printf("value: %s\n", value) //value: PHP is the best language in the world!
}

使用指针修改值

package main

import "fmt"

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main(){
    a, b := 1, 2
    fmt.Println(a, b) // 1 2
    swap(&a, &b)
    fmt.Println(a, b) // 2 1
}

创建指针的另一种方法 — new()函数
Go语言还提供了另外一种方法来创建指针变量，方法如下：

str := new(string)
*str = "PHP is the best language in the world!"
fmt.Println(*str) // PHP is the best language in the world!

类型别名与类型定义

type TypeAlias = Type

package main
import "fmt"

type IntAlias = int

func main() {
    var a, b IntAlias = 3, 4
    c := a + b
    fmt.Printf("c has the value: %d", c) // 输出：c has the value: 7
}

type NewType Type

package main

import "fmt"

//类型定义
type NewInt int

//类型别名
type AliasInt = int

func main() {
    var a NewInt
    var b AliasInt

    fmt.Printf("type ocf a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int
}
// 区别：结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。AliasInt类型只会在代码中存在，编译完成时并不会有AliasInt类型。