GoLang 基礎語法 (1)

Golang 基礎語法 (1)

變量的聲明

在 go 的包中,一個變量或者方法函數或者常量以大寫字母開頭,能夠被包外看見使用
既大寫的包變量或者包方法或者包常量是能夠導出的
小寫的包變量和包方法還有包常量只能在包內訪問數組

  • 如下定義方法不管是函數體外仍是內均可以數據結構

//定義一個變量,名稱爲 "numberOfTimes",類型爲 "int"
var numberOfTimes int
//定義三個變量,類型爲 「int"
var var1, var2, var3 int
//定義一個變量,名稱爲 "numberOfTimes",類型爲 "int",值爲 "3"
var numberOfTimes int = 3
//定義三個類型爲 "int" 的變量,而且初始化它們的值
var var1, var2, var3 int = 1, 2, 3
  • 變量聲明快捷方式(只能在函數或者方法內)app

package main

//✅
var foo string
//❌
foo := "test"
func main(){
    var bar int
    foo1 := 10
    //v1 v2 v3能夠是任意類型,編譯器會自動確認數據類型
    vname1, vname2, vname3 := v1, v2, v3
    
    //下面的 var1 := 11會報錯,由於變量 var1已經被定義,不能重複定義
    var var1 int = 10
    var1 := 11
    //下面正確,只是給 var2從新賦值
    var var2 int = 10
    var2 = 12
}
  • 特殊變量(棄用變量或者導入包不使用)ide

go 語言中沒有使用的包或者變量,會致使編譯失敗函數

//"net/http" 包導入不使用,若是包裏面有 init 方法,只執行 init 方法
import(
    "fmt"
    _ "net/http"
)
func main(){
    //函數 divede 返回值第一個放棄不使用
    _, remainder := divide(10, 3)
}
  • 分組定義ui

//導入包
import(
    "fmt"
    "os"
)
//常量定義
const(
    i = 100
    pi = 3.1415
    prefix = "Go_"
)
//變量
var(
    i int
    pi float32
    prefx string
)
//結構體
type(
    people struct{
        name string
        age int
    }
    animal struct{
        name string
        leg int
    }
)
  • 關鍵字 iota編碼

const(
    x = iota // x == 0
    y = iota // y == 1
    z = iota // z == 2
    w // 省略 iota ,w == 3
)
const(
    a = iota // a == 0
    b = 10
    c // c == 1
    d // d == 2
)
const v = iota //v ==0
const(
    e, f, g = iota, iota, iota // e==0, f==0, g==0 由於在同一行
)

基本數據類型的特性

  • 布爾類型操作系統

    • bool 表示布爾類型指針

    • bool 的值 只有 true 和 false 且默認值爲 falsecode

    • bool 的值不能轉換爲數字

  • 數字類型

    • 整形 int

      • 整形分爲有符號 int 和無符號 uint,它們具備相同的長度,具體長度取決於操做系統,32位操做系統爲32位,64位操做系統爲64

      • go語言也定義了 rune,byte,int(8,16,32,64),uint(8,16,32,64)

      • rune 是 int32的別名,byte 是 uint8的別名

      • go 語言不容許不一樣整型賦值

      var a int8 = 10
      var b int32 = 10
      //編譯報錯
      c := a+b
    • 浮點型

      • 只有 float32 和 float64, 沒有 float

    • 複數 complex

  • 字符串 string

    • go 使用 UTF-8 編碼

    • "" 或者 `` 包裹起來的就是字符串

    • string 不容許改變值

    • 改變一個字符串的方法

    s := "hello"
    c := []byte(s)
    c[0] = 'c'
    s2 := string(c)
    //思考下面的代碼 s1的地址是固定不變的仍是會變?
    //s1 的地址不會改變,string 底層是一個結構體,兩個字段
    //其中一個是指向數據的指針
    //另一個是數據的長度
    s1 := "hello"
    s1 = "sea"
    s1 = "aa" + s1[1:]
    • 使用 "+" 鏈接兩個字符串

    • `` 多行字符串,不會轉義任何字符

    m := `hello
    world`

錯誤類型Error types

go 沒有異常處理機制,內置 error 類型,用於處理 errors
go 要求咱們要麼顯式處理錯誤要麼忽略

array, slice, map

  • array 定義

var arr [n]type
a := [3]int{1, 2, 3}
//... 自動識別數組長度
a := [...]int{1,3,3}
d := [2][2]int{[2]int{0,0}, [2]int{2,2}}
d1 := [2][2]int{{1,1}, {22,22}}
  • slice 定義

var fslice []int
slice := []byte{'a', 'c', 'd'}
  • slice 操做

a := []int{1,2,3,5}
b := a[1:] // b 爲 2,3,5 可是 a  b 共享底層數據結構,修改 a 或者 b , a和 b 都會改變
b := a[:2] // b 爲 1, 2
  • 內置函數

    • len 獲取 slice 長度

    • cap 獲取 slice 最大容量

    • append 追加一個或者多個元素到 slice, 返回 slice

    • copy 複製一個 slice 到另一個,返回 copy的元素個數

  • map - 相似於 Ptyon 裏面的字典 key-value

    • map 不是有序的,每次打印輸出結果順序不同,使用 key 去獲取 value

    • map 沒有固定長度,和 slice 同樣是引用類型

    • len 函數能夠用在 map上,返回 map 如今包含多少個 key

    • map 能夠很容易根據 key 修改 value

    • delete 能夠刪除 map 中指定key 的元素

slice 的索引只能是 int,map 的索引能夠是任何你想要的類型

numbers := make(map[string]int)
numbers["one"] = 1

make new 區別

  • make 給內置類型分配內存,而且初始化它們,返回非零值

    • map

    • slice

    • channel

  • new(T) 返回零值

控制結構和函數

  • if 不須要括號

if test {
}
//分號隔開,賦值
if x := len(slice); x >0 {
}
  • goto

func my(){
    i := 0
Here:   //label goto
    i++
    goto Here //跳轉到 Here
}
  • for 可替代 while,do-while

    • break continue

  • switch

    • case 的值能夠有多個 逗號隔開

    • 只執行匹配的 case 不須要 break

    • default 若是沒有匹配的執行

  • func 定義函數

    • 函數有0-多個參數,參數名稱在參數類型前

    • 函數能夠返回多個值或者不返回值

    • 多變參數 ...

    • go 函數參數本質都是傳值

    • 函數能夠被當作值和參數類型

func funcName(p1 type1, p2 type2)(returnType1, returnType2{
    return a, b
}
func varFunc(arg1 ...int){
}
  • defer 延遲執行,先進後出 FILO

  • panic & recover

  • main & init 函數

    • main 包的 main 函數,是程序入口

    • 每一個包能夠有多個 init 函數,在 impprt 的時候執行,用於作一些初始化操做,包裏面每一個文件就只能一個 init 函數了

  • import 導入包

    • . 操做符,調用的仍是能夠忽略掉包名

    • 別名

    • _ 只導入不使用

import(
    . 」fmt" //忽略包名
    o "os"  //別名
    _ "net/http"    //導入包執行 init 方法不使用
)

未完待續

相關文章
相關標籤/搜索