Golang與變量

1. Go語言中的命名

1.1 命名規則

GO語言中的變量名、函數名、類型名、常量名、包名等等的命名都應該遵循一個基本的原則，那就是 命名應該是以一個英文字母或者一個下劃線開頭，後面可以跟任意數量的英文字母，數字和下劃線，且區分字母大小寫 ,命名儘量做到見名知意.

package main

import "fmt"

const PI float64  = 3.1415926
var 姓名 string = "張三"

func main(){
	name := "demo1"
	namE := "demo2"
	fmt.Println(PI)
	fmt.Println(姓名)
	fmt.Println(name)
	fmt.Println(namE)
}

輸出

3.1415926
張三
demo1
demo2

我們可以看到Go語言中可以使用中文作爲變量名,但是實際開發中沒人這麼做.

1.2 關鍵字

比較常見的編程語言中都有關鍵字,這些特定的關鍵字是在一些特定的語法中使用,不能濫用.Go語言中有25個關鍵字,關鍵字不能用於自定義名字

下面列舉了 Go 代碼中會使用到的 25 個關鍵字或保留字：

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

除了關鍵字還有一些內建常量,類型和函數,我們在自定義名稱的時候也不要與他們重名

內建常量: 
    true false iota nil
內建類型: 
        int int8 int16 int32 int64
        uint uint8 uint16 uint32 uint64 uintptr
        float32 float64 complex128 complex64
        bool byte rune string error
內建函數: 
        make len cap new append copy close delete
        complex real imag
        panic recover

2. Go語言變量

2.1 什麼是變量

高級編程語言編寫的程序中,變量是組成程序的基本單位. 變量的作用是存儲用戶數據,就本質而言,變量相當於對一塊數據存儲空間的命名,程序通過定義一個變量在內存中申請一塊數據存儲空間,然後通過引用變量名來使用這塊存儲空間

我們能總結變量的關鍵要素是 變量名,變量類型,變量值

2.2 變量的使用概述

1.聲明變量

2.初始化變量

3.給變量賦值

4.使用變量

2.2.1 變量聲明的基本語法

var 變量名數據類型

package main

import (
	"fmt"
	"github.com/go-redis/redis"
)

var i int
var s string
var f float64
var v1 struct{
	cc int
}
var v2 *int
var v3 map[string]int
var v4 func(a int) int
var r *redis.Client

func main(){
	fmt.Printf("value = %v\n",i)
	fmt.Printf("type = %T",s)
}

聲明之後不賦值,那麼就使用默認值

2.2.2 聲明變量,並且賦值

package main

import (
	"fmt"
)

var v1 int = 99
var v2 string
var v3 float64
var v4 map[string]int

func main(){
	v2 = "Hi"
	v3  = 99.9
	v4 = map[string]int{"age":100}
	fmt.Printf("value = %v\n",v1)
	fmt.Printf("type = %T\n",v1)
	fmt.Printf("value = %v\n",v2)
	fmt.Printf("type = %T\n",v2)
	fmt.Printf("value = %v\n",v3)
	fmt.Printf("type = %T\n",v3)
	fmt.Printf("value = %v\n",v4)
	fmt.Printf("type = %T\n",v4)
}

value = 99
type = int
value = Hi
type = string
value = 99.9
type = float64
value = map[age:100]
type = map[string]int

2.2.3 多變量聲明

既一次性聲明多個變量

package main

import (
	"fmt"
)

var (
	v1 int = 99
	v2 string
	v3 float64
	v4 map[string]int
)

func main() {
	v2 = "Hi"
	v3 = 99.9
	v4 = map[string]int{"age": 100}
	fmt.Printf("value = %v\n", v1)
	fmt.Printf("type = %T\n", v1)
	fmt.Printf("value = %v\n", v2)
	fmt.Printf("type = %T\n", v2)
	fmt.Printf("value = %v\n", v3)
	fmt.Printf("type = %T\n", v3)
	fmt.Printf("value = %v\n", v4)
	fmt.Printf("type = %T\n", v4)
}

value = 99
type = int
value = Hi
type = string
value = 99.9
type = float64
value = map[age:100]
type = map[string]int

2.2.5 類型推導

根據值自動判斷變量類型

package main

import (
	"fmt"
)

var (
	v1  = 99
	v2  = "golang"
)

func main() {
	fmt.Printf("value = %v\n", v1)
	fmt.Printf("type = %T\n", v1)
	fmt.Printf("value = %v\n", v2)
	fmt.Printf("type = %T\n", v2)
}

value = 99
type = int
value = golang
type = string

2.2.6 省略var的聲明方式

package main

import (
	"fmt"
)

func main() {
	v3 := "hello world"
	fmt.Printf("value = %v\n", v3)
	fmt.Printf("type = %T\n", v3)
	v3 = "hi world"
	fmt.Printf("value = %v\n", v3)
	fmt.Printf("type = %T\n", v3)
}

value = hello world
type = string
value = hi world
type = string

2.2.7 全局變量

在函數外部聲明的變量就是全局變量

package main

import (
	"fmt"
)
var (
	// 定義的全局變量
	v1  = 500
	v2  = "Monkey King"
)

func getInfo()  {
	// 函數內使用全局變量
	v1 = 999
	v2 = "one"
	fmt.Println(v1,v2)
}
func main() {
	v3 := "hello world"
	fmt.Printf("value = %v\n", v3)
	fmt.Printf("type = %T\n", v3)
    // 在主函數中使用全局變量
	fmt.Println(v2)
    // 調用函數
	getInfo()
}

value = hello world
type = string
Monkey King
999 one

2.2.8 多變量賦值

package main

import "fmt"

var x int = 99
var y int = 88

func main() {
	fmt.Printf("x  = %v\n",x)
	fmt.Printf("y  = %v\n",y)
	// 交換變量值,也是多重賦值
	x,y = y,x
	fmt.Printf("x  = %v\n",x)
	fmt.Printf("y  = %v\n",y)
}

x  = 99
y  = 88
x  = 88
y  = 99

package main

import (
	"fmt"
)

// 給v3,v4,v5 賦值
var v3, v4, v5 = 100, "ddemo", map[string]int{"name": 99}

func main() {

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

2.2.9 匿名變量

我們在調用一個函數的時爲了獲取某一個值,卻因爲函數返回多個值而不得不定義一些無意義的變量,可以使用匿名變量避免這種情況

package main

import (
	"fmt"
)

func getName()(firstname,lastname,nickname string){
	return "king","pick","tom"
}
func main() {

	// _(下劃線)可以看作是特殊的變量名,賦予他的值都會丟棄
	_, i, j, _ := 10, 20, 30, 40
	fmt.Println(i, j)
    // 只需要獲取暱稱
	_,_,nickname := getName()
	fmt.Println("my name is",nickname)

}

20 30
my name is tom

2.2.10 變量重名

變量在同一作用域(同一函數或者代碼塊中)不能重名

package main

import "fmt"

var v1 string
func main() {
	v1 = "captain"
	fmt.Println(v1)
	v1 := "tom"
	fmt.Println(v1)
	v1 := "red" //與上一個v1重名了
	fmt.Println(v1)
}

3. 變量默認值

Go語言如果聲明瞭變量,但是沒有賦值,那麼編譯器會使用默認值,變量類型不同, 默認值也是不同的

package main

import "fmt"

var v1 int
var v2 int8
var v3 int16
var v4 float32
var v5 float64
var v6 string
var v7 bool
var v8 complex64
var v9 complex128
var v10 error
var v11 interface{}
func main() {
	fmt.Printf("v1 = %v\n",v1)
	fmt.Printf("v2 = %v\n",v2)
	fmt.Printf("v3 = %v\n",v3)
	fmt.Printf("v4 = %v\n",v4)
	fmt.Printf("v5 = %v\n",v5)
	fmt.Printf("v6 = %v\n",v6)
	fmt.Printf("v7 = %v\n",v7)
	fmt.Printf("v8 = %v\n",v8)
	fmt.Printf("v9 = %v\n",v9)
	fmt.Printf("v10 = %v\n",v10)
	fmt.Printf("v11 = %v\n",v11)
}

v1 = 0
v2 = 0
v3 = 0
v4 = 0
v5 = 0
v6 = 
v7 = false
v8 = (0+0i)
v9 = (0+0i)
v10 = <nil>
v11 = <nil>

3. GO語言常量

在Go語言中，常量是指編譯期間就已知且不可改變的值。常量可以是數值類型（包括整型、
浮點型和複數類型）、布爾類型、字符串類型等

3.1 常量的定義

GO語言中通過關鍵字 const 定義一個常量

package main

import "fmt"

const OS = "Linux"
const HOST = "127.0.0.1"
const(
	MEMORY = 32
	zero = 0.0
)
const a,b,c = "A","B","C"

func main() {
	fmt.Printf("type = %T\n",OS)
	fmt.Printf("value = %v\n",OS)
}

type = string
value = Linux

3.2 iota枚舉

iota 被認爲是一個可以被編譯器修改的常量,在每個const 關鍵字出現時被重置爲0 ,在下一次出現const出現之前,每出現一次iota,其所代表的數字都會自動加1,我們也可以將iota描述爲是GO語言中的常量計數器,只能在常量表達式中使用

package main

import "fmt"

const(
	x = iota 	// iota = 0       0
	y = iota	// iota + 1 = 1   1
	z = iota	// iota + 1 = 2	  2
	v       	// 隱式 v= iota    3

)
const(
	a,b,c = iota,iota,iota		//iota在同一行所有值相同 都是0
)
const w = iota // 遇見const iota重置爲0
const(
	x1 = iota*2
	y1 = iota*2
	z1 = iota*2
	v1 = iota*2
)
const(
	d  = iota
	e  = "e"
	f  = iota
	g
	h,i,j = iota,iota,iota

)
func main() {
	fmt.Println(x,y,z,v)
	fmt.Println(a,b,c)
	fmt.Println(w)
	fmt.Println(x1,y1,z1,v1)
	fmt.Println(d,e,f,g,h,i,j)
}

0 1 2 3
0 0 0
0
0 2 4 6
0 e 2 3 4 4 4

package main

import "fmt"

const(
	_ = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
	Sunday
)
func main(){
	fmt.Println(Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday)
}

1 2 3 4 5 6 7

4. 變量作用域

函數內部聲明和定義的變量叫做 局部變量 ,作用域僅限於 該函數內部

函數外部聲明和定義的變量叫做 全局變量 , 作用域在整個包內都有效 ,如果首字母大寫那麼在整個程序都有效

變量首字母大寫,則該變量可見性最高

package main

import "fmt"

// 聲明一個全局變量 globalP
var globalP int
func demo1(){
	//使用全局變量
	globalP = 66
	fmt.Println(globalP)
}
func main()  {
	// 聲明一個局部變量 part
	var part int
	// 只能在定義的函數內部使用
	part = 99
	fmt.Println(part)
	//包內都可用
	globalP = 55
	fmt.Println(globalP)
	demo1()

}

99
55
66

文章目錄

1. Go語言中的命名

1.1 命名規則

1.2 關鍵字

2. Go語言變量

2.1 什麼是變量

2.2 變量的使用概述

2.2.1 變量聲明的基本語法

2.2.2 聲明變量,並且賦值

2.2.3 多變量聲明

2.2.5 類型推導

2.2.6 省略var的聲明方式

2.2.7 全局變量

2.2.8 多變量賦值

2.2.9 匿名變量

2.2.10 變量重名

3. 變量默認值

3. GO語言常量

3.1 常量的定義

3.2 iota枚舉

4. 變量作用域

Go Modules基礎

Golang與變量

Golang操作MySql

Go語言入門教程-小案例-基礎排序程序

Golang結構體struct

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結