1.3.2-types-and-variables
2024-07-13 14:03:17 # 1.3-Golang

https://www.mubu.com/doc/2EyviiAvyQG

Types

1
2
3
4
5
6
7
8
9
var str string = "abc"
var bal bool = false
var number int = -10
var score uint = 100
var pi float64 = 3.14
var b byte = 255
var c complex128 = 1.4 + 4i

fmt.Printf("str value = %v, type=%T\n", str, str)

常用的数据类型有这些，除非特别需要考虑性能，否则，int和uint使用默认的长度即可，无需特别指定其长度。

Unless you have a good reason to, stick to the types above:

1
2
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64

The size (8, 16, 32, 64, 128, etc) represents how many bits in memory will be used to store the variable. The “default” int and uint types refer to their respective 32 or 64-bit sizes depending on the environment of the user.

两个特殊的类型

1
2
3
4
// 字节类型 用于表示一个字节
type byte = uint8
// 代表一个 Unicode 码
type rune = int32

别名与类型定义

通过type，可以自定义类型，有等号的情况下，它其实是一一种别名，其类型仍然是最原始的类型，而直接使用type则会增加一种新的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
type Integer = int
type Name string

func main() {

	var a Integer = 10
	fmt.Printf("type a = %T \n", a)
	var b Name = "Marcho"
	fmt.Printf("type b = %T \n", b)
}
---------
type a = int
type b = main.Name

Variables

定义变量的几种不同方式；

1
2
3
4
5
6
7
8
9
10
11
// 简短定义并赋值的方式，只能用在函数内部
s := ""
// 声明一个变量，并且指定其类型，未进行赋值操作，零值
var s string
// 声明一个变量，并赋值，让编译器推断该变量的类型
var s = ""
// 声明一个变量，并且初始化赋值
var s string = ""

// 单行定义多个变量
mileage, company := 80276, "Tesla"

变量的默认零值有: int = 0 string = "" bool = false float = 0.0 指针 = nil

还有批量的定义方式：

1
2
3
4
5
6
7
8
9
var (
name string
age int
)

func main() {
	fmt.Printf("Default name type = %T\n", name)
	fmt.Printf("Default age type = %T\n", age)
}

简短定义并赋值变量的方式，每次至少有一个新的变量需要产生，如果没有产生，则无法通过编译；

1
2
file,err := os.OpenFile("input.txt");
file2,err := os.OpenFile("input2.txt");

第二句中的 err 就不是声明了，而是作为赋值存在。

匿名变量

匿名变量以下划线（_）表示

匿名变量不占用命名空间，也不会分配内存。匿名变量可以重复声明使用。

1
2
3
// 匿名变量
file, _ := os.Open("go.mod")
fmt.Printf("opne a file %p\n", file)

作用域（可见性）

包作用域 (Package Scope)

  • 定义：在包级别定义的变量和常量。
  • 可见性：在整个包内可见。
    函数作用域 (Function Scope)
  • 定义：在函数内部定义的变量和常量。
  • 可见性：仅在定义它们的函数内可见。
    块作用域 (Block Scope)
  • 定义：在代码块内（如for循环、if语句、switch语句等）定义的变量和常量。
  • 可见性：仅在该代码块内可见。

生命周期

全局变量

  • 定义：在包级别定义的变量，通常在文件的顶层。
  • 生命周期：在程序启动时初始化，并在程序结束时销毁。
    局部变量
  • 定义：在函数或代码块中定义的变量。
  • 生命周期：在进入函数或代码块时创建，并在退出函数或代码块时销毁。

逃逸分析与堆分配

  • 定义：Go编译器通过逃逸分析决定变量是分配在堆上还是栈上。如果一个变量在函数返回后仍然被使用，它会被分配到堆上。
  • 生命周期：堆分配的变量在没有任何引用时由垃圾回收器（GC）回收。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func createPointer() *int {
    var localVar = 42
    return &localVar // localVar 逃逸到堆上
}

func main() {
    p := createPointer()
    fmt.Println(*p) // 即使 createPointer 函数已经返回，p 仍然有效
}

Constants

定义一个常量，常量一旦定义则不可修改。

1
const pi = 3.14159

iota

iota 常用用定于enum 的定义，每一行都会自增1，从0开始, 且同一行的值是相同的。

1
2
3
4
5
6
7
const (

A = iota // 0
B = "String" // 1
C, D, E = iota, iota, iota //2

)

Point

指针是一个变量的地址，通过地址信息，可以获取和访问指针所指向的值。通过 & 符号获得指针的地址。

1
2
3
4
5
6
7
8
9
10
11
var number int = 10
var numberPoint *int = &number
var pointValue = *numberPoint

fmt.Printf("number val=%d, its address -> %p\n", number, &number)
fmt.Printf("numberPoint val=%v, its address -> %p\n", numberPoint, &numberPoint)
fmt.Printf("pointValue val=%v, its address -> %p\n", pointValue, &pointValue)
-----------
number val=10, its address -> 0x14000112008
numberPoint val=0x14000112008, its address -> 0x14000108018
pointValue val=10, its address -> 0x14000112010

关键字new 可以很容易的获取到一个变量的指针，且通过new函数创建的变量，变量值为0值

1
2
var c = new(int)
fmt.Println(*c)

类型定义

通过类型定义，可以将一个底层数据类型赋予一定的实际意义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
type Kilogram int

type Gram int

func main() {

fmt.Println(GramToKilo(1000))

}

func GramToKilo(d Gram) Kilogram {

return Kilogram(d / 1000)

}

For

循环语句

1
2
3
4
5
6
7
8
9
10
11
12
13
for initialization; condition; post {
// zero or more statements 
}

// a traditional "while" loop 
for condition { 
// ... 
}

// a traditional infinite loop 
for { 
// ... 
}

初始化语句、判断条件、递增语句。或者可以只提供条件，来达到while语句的效果。而且还可以写一个死循环，通过return 或者break来控制。

Function

使用关键字 func 定义一个函数, 函数的结构如下：
函数名称首字母大写，说明该函数从当前包内导出, 即可以在其他包内访问到。

This function takes a name parameter whose type is string. The function also returns a string. In Go, a function whose name starts with a capital letter can be called by a function not in the same package. This is known in Go as an exported name. For more about exported names, see Exported names in the Go tour.

多返回值

https://go.dev/doc/effective_go#multiple-returns

函数可以指定有多个返回值，通常情况下，通过返回error的方式来处理异常，如果 error == nil 则说明函数正常执行并返回。

1
func (file *File) Write(b []byte) (n int, err error)

One of Go’s unusual features is that functions and methods can return multiple values

if

if 与其他编程语言不同的地方在于，它可以定义一个变量，且这个变量只在if作用域内生效。

1
2
3
4
5
6
7
8
9
10
11
func main() {
	if x := sub(10, 2); x > 0 {
		fmt.Println("x > 0")
	} else {
		fmt.Println("x < 0")
	}
}

func sub(a int, b int) int {
	return a - b
}

defer

defer语句定义一个逆向的，在函数退出前调用的一个堆栈。

1
2
3
4
5
6
7
func DeferTest() {

	defer fmt.Println("1")
	defer fmt.Println("2")
	defer fmt.Println("3")

}

Function

函数可以定义多个返回值，并且函数支持将一个函数作为变量进行传递

可以按照返回值的顺序返回，或者给返回值定义变量名，给返回的变量赋值后进行 return

通过 type 的方式，可以将一个函数重新定义一个类型

1
2
3
4
5
func test(a int) (bool, error) {
	return a >= 3, nil
}

type Filter func(int) bool

将一个函数作为变量的值传入

1
2
3
4
5
6
7
8
9
10
11
func ListFilter(list []int, filter Filter) []int {

	result := make([]int, 0)
	
	for _, item := range list {
		if filter(item) {
			result = append(result, item)
		}
	}
	return result
}

Error

Panic 和 Recover

panic 作为 go 语言中的一种错误处理机制，不想Java 可以将异常进行抛出。panic在出错的位置，将代码不再继续向下执行。而是返回，返回到上一层堆栈。

Recover 只能定义在 defer 中才有效，且可以在 recover中捕获异常信息。

1
2
3
4
5
6
func pain() {
	fmt.Println(user)
	if user == "" {
		panic("no value for $USER")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
func checkError() (b bool) {

	defer func() {
		if x := recover(); x != nil {
			fmt.Println("find a error")
			b = true
		}
	}()
	
	pain()
	return
}
上一页
2024-07-13 14:03:17 # 1.3-Golang
下一页