文章目錄

• • • • 1.基本熟悉，了解組成
      • 2.整型，浮點，字符串
      • 3.字符串格式化
      • 4.基礎數據類型的擴展
      • 5.流程控制
      • 6.函數
      • • 內置函數
      • 7.復合數據類型

1.基本熟悉，了解組成

package main //main特殊包名，表示是一個可執行程序 //導入代碼包，fmt import "fmt"//定于全局變量var var Pi float32 //顯式定義 var aname1="你好" var (a11=1a22="x" )//init函數是初始化實體 func init() {Pi=2+1 }//程序主體 func函數 main程序主函數 func main() { //注釋//單行注釋/*多行注釋*/fmt.Println("Hello word") //常量 定義使用const 數據類型智能判斷const name string = "你好" //顯式定義const age int =123const name2 = "你好" //隱式定義const age2 = 456const name3 = "你" +"好"//:=賦值運算符定義返回變量，但一定要被使用n := "hello"l := len(n)fmt.Println(l)//并行賦值const (Monday,Tuesday,Wednesday=1,2,3)//枚舉const (a = iota; //a===0bch="h")fmt.Println(c)//init函數使用DPi := Pifmt.Println(Pi,DPi) }

2.整型，浮點，字符串

package mainimport ("fmt""strings" )func main() {fmt.Println("你好")//數據類型//整形const value_int_1 int =132value_int :=4fmt.Println(value_int,value_int_1)//浮點const value_float float32 =123.123value_float_1 := 123.1234fmt.Println(value_float,value_float_1)//復數（無需要，暫不了解）//字符和字符串str1:="1234567"fmt.Println("字符串長度為：",len(str1))//遍歷獲取每個字符for i:=0;i<len(str1) ;i++ {//返回字節值fmt.Println("每個字符為",str1[i])fmt.Println("每個字符為",string(str1[i]))//獲取單個字符的值fmt.Printf("%d = %v\n",i+1,str1[i])}//非解釋字符串str2:="你好\n圣姑"fmt.Println(str2)str3:=`你好\n圣姑`fmt.Println(str3)//字符串修改 通過byte和rune類型str_a1 :="hello word"str_a2 :=[]byte(str_a1) //自動復制數據str_a2[5]=',' //修改下標為5的值為，fmt.Printf("%s\n",str_a2)str_a3:=[]rune(str_a1)//轉runestr_a3[5] =','fmt.Println(string(str_a3)) //注意輸出的Println 并使用了string函數方法fmt.Println(string(str_a3[2])) //獲取最后一個字符//string包//1）判斷//前后綴包含str_b1 :="There is dongxi 你好"is_bool := strings.HasPrefix(str_b1,"Th") //HasPrefix判斷fmt.Println(is_bool) //返回值//字符串包含is_bool_1 := strings.ContainsAny(str_b1,"T")fmt.Println(is_bool_1) //返回值is_bool_2 := strings.ContainsAny(str_b1,"T & e")//多個配fmt.Println(is_bool_2) //返回值is_bool_3 := strings.ContainsAny(str_b1,"") //falsefmt.Println(is_bool_3) //返回值is_bool_4 := strings.Contains(str_b1,"T")fmt.Println(is_bool_4) //返回值is_bool_5 := strings.Contains(str_b1,"T & e") //無法多個配fmt.Println(is_bool_5) //返回值is_bool_6 := strings.Contains(str_b1,"") //truefmt.Println(is_bool_6) //返回值//2）索引//索引，返回索引值，開頭索引值is_bool_7 := strings.Index(str_b1,"ere")fmt.Println(is_bool_7) //返回值fmt.Println("最后一次索引",strings.Index(str_b1,"x"))fmt.Println("最后一次索引",strings.Index(str_b1,"z"))fmt.Println("最后一次索引",strings.Index(str_b1,"你"))fmt.Println("最后一次索引",strings.IndexRune(str_b1,'你')) //非ASCII編碼配。一般無用 //3)替換str:="你好世界，世界good"println(strings.Replace(str,"你好","加油",1))//4)統計//出現頻率fmt.Printf("%d\n",strings.Count(str,"o"))//字符串數量fmt.Printf("%d\n",len([]rune(str)))//[]rune(str)轉字節fmt.Println(utf8.RuneCountInString(str)) //使用RuneCountInString函數做統計//5)大小寫轉換str_e :="here is my"fmt.Println(strings.ToLower(str_e)) //全轉為小寫fmt.Println(strings.ToUpper(str_e)) //全轉為大寫//6）修剪fmt.Println(strings.Trim("!!! golang !!!","! "))//Trim使用fmt.Println(strings.Trim("!!! golang !!!"," !"))fmt.Println(strings.Trim("!!! golang !!!","!"))fmt.Println(strings.TrimLeft("!!! golang !!!","! "))//TrimLeft使用fmt.Println(strings.TrimRight("!!! golang !!!","! "))//TrimRight使用//7）分割//返回的是一個切片results:=strings.Split("a,c,d",",")fmt.Println(results)fmt.Println(string(results[0]))//8)插入字符strSli:=strings.Fields("a b c d") //Fields轉為切片strSli_2:=strings.Fields("你 的 名 子")for _,val:=range strSli{fmt.Printf("%s",val) //獲取每個切片的值}strStr2:=strings.Join(strSli,";") //join的連接符號為;fmt.Println(strStr2)//得到結果值fmt.Println(strSli_2) //獲得 }

3.字符串格式化

含義格式化指令含義

%%	%字面量
%b	一個二進制整數，將一個整數格式化為二進制的表達方式
%c	一個Unicode的字符
%d	十進制數值
%o	八進制數值
%x	小寫的十六進制數值
%X	大寫的十六進制數值
%U	一個Unicode表示法表示的整型碼值，默認是4個數字字符
%s	輸出以原生的UTF-8字節表示的字符，如果console不支持UTF-8編碼，則會輸出亂碼
%t	以true或者false的方式輸出布爾值
%v	使用默認格式輸出值，或者如果方法存在，則使用類型的String()方法輸出的自定義值
%T	輸出值的類型

4.基礎數據類型的擴展

package mainimport "fmt"type (字符串 string )func main() {//1.強轉類型sum:=11count:=3mean:=float32(sum)/float32(count)fmt.Printf("mean值為%f\n",mean)//2.自定義類型。即結構體，后面有詳解//3.類型別名var b 字符串 //顯式聲明b="這是中文"fmt.Println(string(b))//4.指針//指針是一個內存位置，每個內存位置都有其定義的地址，可以使用&運算符訪問a:=10fmt.Printf("%x\n",&a)//*訪問指針變量的值a1:=14ap:=&a1fmt.Printf("a1的地址%x\n",&a1)fmt.Printf("ap的地址%x\n",ap)fmt.Printf("*ap的值%d\n",*ap)//nil指針var ptr *intfmt.Printf("ptr的值是%x\n",ptr)//指針的指針a_n:=10aP:=&a_n //指針aPP:=&aP //指針的指針fmt.Printf("aP: %x\n",aP)fmt.Printf("aPP: %x\n",*aPP)fmt.Printf("aPP: %d\n",**aPP)//指針的數據a_list:=[]int{10,100,200}var p_a [3]*int //聲明指針數組for i:=0; i<3;i++ {p_a[i]=&a_list[i] //存儲指針的的內存地址fmt.Printf("p_a[%d]的內存地址：%x\n",i,p_a[i])}for i:=0; i<3;i++ {fmt.Printf("p_a[%d]的實際值：%d\n",i,*p_a[i])}//傳遞給函數a3:=100b3:=200fmt.Printf("交換之前的a,b值為%d,%d\n",a3,b3)swap(&a3,&b3)fmt.Printf("交換之后的a,b值為%d,%d\n",a3,b3)} func swap(x *int,y *int) { //指針作為函數參數var temp inttemp=*x*x=*y*y=temp }

5.流程控制

package mainimport ("fmt""go/types""reflect" ) //空接口 var x interface{}func main() {//流程控制//1.條件語句a:=100if a>200 {fmt.Println("大于200")}else if a<200{fmt.Println("小于200")}else {fmt.Println("等于200")}//初始化子語句if b:=100;b<200{fmt.Println("小于200")}//2.選擇語句case_var:=90switch case_var {case 90:fmt.Println("是90")case 100:fmt.Println("是100")default:fmt.Println("啥也不是")}//switch二種用法switch {case case_var>100:fmt.Println("大于100")case case_var<100:fmt.Println("小于100")default:fmt.Println("啥也不是")}//switch三種用法，多表達switch_a:="A"switch_b:="B"switch {case switch_a=="A" && switch_b=="C":fmt.Println("等于A")case switch_a=="A" && switch_b=="B":fmt.Println("等于A和B")default:fmt.Println("啥也不是")}//類型switchx=1switch i := x.(type) { //x.(type)只能用在switch中case types.Nil:fmt.Printf("這里是nif類型,值是%T",i)case int:fmt.Printf("這里是int類型,值是%T",i)case float64:fmt.Printf("這里是float64類型,值是%T",i)case bool:fmt.Printf("這里是bool類型,值是%T",i)case string:fmt.Printf("這里是string類型,值是%T",i)default:fmt.Printf("未知類型")}fmt.Printf("\n")//附錄fmt.Printf("v1的數據類型為：%s\n", reflect.TypeOf(switch_a))//初始化語句switch case_var_1:=120;case_var_1 {case 90:fmt.Println("是90")case 120:fmt.Println("是120")default:fmt.Println("啥也不是")}//switch switch_c:="C"; {case switch_c=="A" :fmt.Println("等于A")case switch_c=="C" :fmt.Println("等于C")default:fmt.Println("啥也不是")}//select語句，暫時用不到，select隨機選擇一個case來判斷//3、循環語句for a:=0; a<5;a++ {fmt.Printf("當前數值為%d\n",a)}//for的子語句a1:=0b1:=5for a1<b1 {fmt.Printf("當前數值為%d\n",a1)a1++}//range子語句 類似迭代器 輪詢數組或者切片的每一個元素 輪詢字符串的每一個字符 字典的鍵值對 通道類型值元素str_a:="abcd"for i,char := range str_a{ //i為index char為具體值fmt.Printf("第%d個值是，具體值是%s\n",i,string(char))}for _,char := range str_a{ //_為忽略index char為具體值fmt.Printf("具體值是%s\n",string(char))}for i := range str_a{ //i為index 忽略獲取具體指fmt.Printf("第%d的下標\n",i)}for range str_a{fmt.Printf("遍歷字符串，不做任何操作\n")}//range的字典和數組嘗試map_a:=map[string]int{"a":1,"b":2}for k,v:=range map_a {fmt.Printf("k值為%s，v值為%d\n",k,v)}//定義一個數據number_list:=[]int{1,2,3,4}for i,num:=range number_list {fmt.Printf("下標值為%d,具體的值為%d\n",i,num)}number_list2:=[5]int{1,2,3,4}for i,num:=range number_list2 {fmt.Printf("下標值為%d,具體的值為%d\n",i,num)}//4,延遲語句//defer用于延遲調用的指定函數,defer關鍵字只出現在函數內部//特點：1.defer語句全部執行，函數才算真正結束 2.函數等待defer語句結束后，才執行returndefer fmt.Println("word")fmt.Println("hello")//5.標簽goto L1L1:for i:=0;i<5 ;i++ {fmt.Println("輸出內容")} }

注，range的返回值的輸出：

右邊表達式返回的類型第一個值第二個值

sting	index	str[index],返回的類型rune
array/slice	index	str[index]
map	key	m[key]
channel	element

6.函數

package mainimport ("fmt""time" )//定義一個函數，參數類型，以及返回值類型 func add(a int,b int)int{return a+b }//返回值變量預定義 func Max(a int,b int)(maxNum int) {if a>b{maxNum=a}else{maxNum=b}return maxNum }//2.函數基礎 //多返回值 func SumResult_A_B( a int,b int)(int,int) {return a,b } //函數作為參數 type FormatFunc func(s string,x,y int )string //定義函數類型 func pipe(ff func() int )int {return ff() } func format(ff FormatFunc,s string,x,y int )string {//定義返回的是ff函數的是三個值return ff(s,x,y) }//定義一個是否整除2的函數 func isEven(v int)bool{if v%2==0{return true}else {return false} }type boolFunc func(int) bool //聲明一個函數類型 int是函數的參數值，即isEven(v int)中的參數值，bool為返回值類型func filter(slice []int,f boolFunc)[] int{var result [] intfor _,value:=range slice{if f(value){ //這里f調用函數，根據傳參判斷，即，在本例子中即是isEvenresult=append(result,value)}}return result }//3.可變參數 不同數據類型 func int_change(args ...int){for _,i:=range args {fmt.Printf("數是%d\n",i)} }//閉包 func Adds()func(b int) int {return func(b int) int {return b+2} } func recursion(parse int){if parse>1{parse--recursion(parse)fmt.Println("當前獲得的遞歸數值為",parse)} } //panic的函數使用 panic終止后面的執行的代碼 func fullName(firstName *string, lastName *string) {if firstName == nil {panic("runtime error: first name cannot be nil")}if lastName == nil {panic("runtime error: last name cannot be nil")}fmt.Printf("%s %s\n", *firstName, *lastName)fmt.Println("returned normally from fullName") }//recover捕獲panic，從而影響應用的行為。獲取通過panic傳遞的error func genErr(){fmt.Println(time.Now(),"正常的語句") //輸出正常的語句//定義延時函數defer func(){fmt.Println(time.Now(),"defer正常的語句")panic("第二個錯誤") //只會輸出第二個panic的}()panic("第一個錯誤") //第一個雖然早已經發生，但是不輸出的 } func throwsPanic(f func())(b bool){defer func(){if r:=recover();r!=nil{fmt.Println(time.Now(),"捕獲到的異常：",r)b=true}}()f() //即調用了genErr，無panic，即判斷if條件不會成立的return b }func main() {//1.測試小例子result_num:=add(1,2)fmt.Println(result_num)result_max_num:=Max(1,3)fmt.Println(result_max_num)//函數做參數的函數調用s1:=pipe(func() int {return 100 //匿名函數當參數}) //注意這個怎么調用的偶fmt.Println(s1)s2:=format(func(s string, x, y int) string {return fmt.Sprintf(s,x,y) //格式化輸出返回},"值1為%d,值2位%d",10,20)fmt.Println(s2)slice :=[]int{3,3,4,5,6}//函數作為類型even:=filter(slice,isEven)fmt.Println("even:",even)//調用可變參數的函數int_change(1,2,3,4,5,6)//5.匿名函數與閉包return_x:=func(x1,x2 int) int{return x1+x2}(3,4)fmt.Println(return_x)//閉包。閉包允許調用定義在其他環境下的變量，使得某個函數捕捉一些外部狀態。//調用閉包adds_return:=Adds()(3)fmt.Println(adds_return)//6、遞歸函數recursion(5)//7錯誤與恢復//error的常見處理f, err := os.Open("/test.txt")if err != nil {fmt.Println("error:",err)return}fmt.Println(f.Name(), "open successfully")*///異常處理//需要注意的是，你應該盡可能地使用錯誤，而不是使用 panic 和 recover。只有當程序不能繼續運行的時候，才應該使用 panic 和 recover 機制。firstName := "foo"lastName:="zhang"fullName(&firstName, &lastName)fmt.Println("returned normally from main")//recover函數throwsPanic(genErr)}

內置函數

內置函數就是不需要進行導入操作就可以直接使用的函數，它們有些可以根據不包進行操作(例如len、cap和append),有些用于系統級的操作(例如panic)。常見內置函數如下所示。

內置函數詳解

close	用于管道通信。
len	用于返回某個類型的長度或數量(字符串、數組、切片、map和管道)。
cap	容量的意思，用于返回某個類型的最大容量(只能用于切片和map)。
new、make	均用于分配內存，不過new用于值類型和用戶定義的類型，如自定義結構，make 用于內置引用類型(切片、map和管道)。它們的用法就像是函數。但是將類型作為參數: new(type)、 make(type)。 new(T)分配類型 T的零值并返回其地址，也就是指向類型T的指針，它也可以用于基本類型: v := new(int)。返回類型T的初始化之后的值，因此它比new做更多的工作。new()是一 個不要忘記它的括號。
copy、 append	用于復制和連接切片。
panic、recover	兩者均用于錯誤處理機制。
print、println	底層打印函數(部署環境中建議使用fmt包) .
complex、 real imag	用于創建和操作復數。

7.復合數據類型

package mainimport "fmt"func main() { /* 1、數組的創建以及常見使用*///復合數據類型arrays:=[5]int{1,2,3,4,5} //固定長的數組for _,v:=range arrays { //輸出結果值fmt.Println(v)}arrays_a1:=[]int{1,2,3,4,5,6} //非固定長度的數組for _,v1:=range arrays_a1 {fmt.Print(v1)}//訪問與修改fmt.Println("\n")array_str1:=[5]string{"a","b","c","d","e"}for i:=0;i<len(array_str1) ;i++ {fmt.Printf("值的下標為：%d,值是%s\n",i,string(array_str1[i]))}//修改元素array_str2:=[5]string{"a","b","c","d","e"}array_str2[0]="a1"fmt.Println("值為",array_str2[0])//聲明與修改指針的數組array_str3:=[5]*int{0:new(int),1:new(int)} //聲明指針數組。初始化索引為0和1的數組元素*array_str3[0]=10*array_str3[1]=20fmt.Println("數組的值為：",*array_str3[0])array_str4:=[3]*string{new(string),new(string),new(string)} //字符串的指針的初始化這個數組*array_str4[0]="a1"fmt.Println(*array_str4[0])//多維數組//二維數組array_str1_a:=[4][2]int{{10,10},{20,21},{30,31},{40,41}}for i:=0;i<len(array_str1_a);i++ {for j:=0;j<len(array_str1_a[i]);j++ {fmt.Printf("每個的二維數組的值是%d\n",array_str1_a[i][j])}}//修改array_str1_aarray_str1_a[0][0]=100fmt.Println(array_str1_a)//數組傳遞給函數，最好聲明為數組指針，這樣在數組作為參數的時候會節省很大的開銷。 /* 2.切片操作*///創建切片。make切片量//slice:=make([]string,5) //切片長度為5，容量也是5//slice:=make([]string,3,5) //切片長度為3，容量是5。通過后期操作合并到切片中。注意容量不能小于長度//nil切片，又稱空切片。不做任何初始化，就會創建一個nil切片//sclice:=make([]int,0)//sclice:=[]int{}/* 3.切片的使用*///賦值與分割slice_array:=[]int{10,20,30,40,50}//創意長度為2個元素，容量為4個元素new_slice:=slice_array[1:3]for _,v:=range new_slice {fmt.Println(v)}fmt.Println(len(new_slice))//切片擴容new_slice=append(new_slice,60)fmt.Println(new_slice)//多維度切片array_str1_b:=[][]int{{10,10},{20,21},{30,31},{40,41},{410,123,111}}array_c1:=[]int{12,123}//切片追加切片slice_array=append(slice_array, array_c1...)fmt.Println(slice_array)//追加多維array_str1_b=append(array_str1_b,array_c1)fmt.Println(array_str1_b)//映射，即字典dict:=map[string]string{"a":"1","b":"2","c":"3"}//修改鍵的值dict["a"]="123"//刪除delete(dict,"c")//追加映射dict["d"]="4"for k,v:=range dict {fmt.Println(k,v)}//數組中添加mapGoods := []map[string]string{{"a":"1"},{"1":"23"}}fmt.Println(Goods)//map中添加數組（映射中添加數組）Goods_p:=map[string][]string{"a":{"1","2","3"},"b":{"4","5","6"}}fmt.Println(Goods_p)//挑戰，map中添加數組，數組中添加mapGoods_p_dic:=map[string][]map[string]string{"map":{{"a":"1"},{"b":"2"}}}fmt.Println(Goods_p_dic)}

總結

以上是生活随笔為你收集整理的golang学习之旅的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。