本文介紹一些Go語言的基礎語法。
創(chuàng)新互聯(lián)公司主要從事網(wǎng)站設計、網(wǎng)站建設、網(wǎng)頁設計、企業(yè)做網(wǎng)站、公司建網(wǎng)站等業(yè)務。立足成都服務壽光,10多年網(wǎng)站建設經(jīng)驗,價格優(yōu)惠、服務專業(yè),歡迎來電咨詢建站服務:13518219792
先來看一個簡單的go語言代碼：
go語言的注釋方法：
代碼執(zhí)行結果：
下面來進一步介紹go的基礎語法。
go語言中格式化輸出可以使用 fmt 和 log 這兩個標準庫，
常用方法：
示例代碼：
執(zhí)行結果：
更多格式化方法可以訪問中的fmt包。
log包實現(xiàn)了簡單的日志服務，也提供了一些格式化輸出的方法。
執(zhí)行結果：
下面來介紹一下go的數(shù)據(jù)類型
下表列出了go語言的數(shù)據(jù)類型：
int、float、bool、string、數(shù)組和struct屬于值類型，這些類型的變量直接指向存在內(nèi)存中的值；slice、map、chan、pointer等是引用類型，存儲的是一個地址，這個地址存儲最終的值。
常量是在程序編譯時就確定下來的值，程序運行時無法改變。
執(zhí)行結果：
執(zhí)行結果：
Go 語言的運算符主要包括算術運算符、關系運算符、邏輯運算符、位運算符、賦值運算符以及指針相關運算符。
算術運算符：
關系運算符：
邏輯運算符：
位運算符：
賦值運算符：
指針相關運算符：
下面介紹一下go語言中的if語句和switch語句。另外還有一種控制語句叫select語句，通常與通道聯(lián)用，這里不做介紹。
if語法格式如下：
if ... else ：
else if：
示例代碼：
語法格式：
另外，添加 fallthrough 會強制執(zhí)行后面的 case 語句，不管下一條case語句是否為true。
示例代碼：
執(zhí)行結果：
下面介紹幾種循環(huán)語句：
執(zhí)行結果：
執(zhí)行結果：
也可以通過標記退出循環(huán)：
--THE END--
printf("%f %f
",s,ave);}這是用指向一維數(shù)組的指針做的。 下面是用指針數(shù)組: #include "stdio.h" void main() {int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int *p[3]={a[0],a[1],a[2]};int i,j;float s=0.0,ave=0.0; for(i=0;ilt
題目: 給定兩個數(shù)組，編寫一個函數(shù)來計算它們的交集.(來自 leecode(349) )
示例 1：
輸入：nums1 = [1,2,2,1], nums2 = [2,2] 輸出：[2] 示例 2：
輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 輸出：[9,4]
說明：
我的解法:
題目同上,只不過在輸出的時候
輸出結果中每個元素出現(xiàn)的次數(shù)，應與元素在兩個數(shù)組中出現(xiàn)的次數(shù)一致。
示例 1：
輸入：nums1 = [1,2,2,1], nums2 = [2,2] 輸出：[2,2] 示例 2：
輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 輸出：[9,4]
解法
如果給定的數(shù)組是排好序的,
arr1 = [1,2,3,4,4,13]，arr2 = [1,2,3,9,10]
那這個返回值該如何獲取得兩個數(shù)組的交集呢?
解法
數(shù)組是一個由 固定長度 的 特定類型元素 組成的序列，一個數(shù)組可以由零個或多個元素組成。 數(shù)組是值類型
數(shù)組的每個元素都可以通過索引下標來訪問，索引下標的范圍是從0開始到數(shù)組長度減1的位置，內(nèi)置函數(shù) len() 可以返回數(shù)組中元素的個數(shù)。
2.類型的打印，結果的第二種打印方式
3.對元素的修改或者賦值
4.判斷數(shù)組是否相等：長度、類型
4.數(shù)組的地址：連續(xù)存儲的空間
5.數(shù)組的賦值、地址、取值
6.數(shù)組的默認值
7.數(shù)組的初始化
8.數(shù)組的逆置
9.求數(shù)組的最大值、最小值、平均值
10.對數(shù)組字符串進行連接
11.冒泡排序法的實現(xiàn)
12.數(shù)組做函數(shù)的參數(shù)
13.二維數(shù)組：賦值和地址
14.二維數(shù)組：打印和輸出
15. 指針數(shù)組，每一個元素都是地址
17.數(shù)組的內(nèi)存分配
1、數(shù)組是多個 相同類型 的數(shù)據(jù)的組合，一個數(shù)組一旦聲明/定義了，其 長度是固定的，不能動態(tài)變化 。
2、var arr []int? ? 這時arr就是一個slice 切片 。
3、數(shù)組中的元素可以是任何數(shù)據(jù)類型，包括值類型和引用類型，但是 不能混用 。
4、數(shù)組創(chuàng)建后，如果沒有賦值，有默認值如下：
? ? 數(shù)值類型數(shù)組：????默認值為 0
? ? 字符串數(shù)組：? ? ? ?默認值為 ""
? ? bool數(shù)組：? ? ? ? ? ?默認值為 false
5、使用數(shù)組的步驟：
? ? (1)聲明數(shù)組并開辟空間
? ? (3)給數(shù)組各個元素賦值
? ? (3)使用數(shù)組
6、數(shù)組的下標是從0開始的。
7、數(shù)組下標必須在指定范圍內(nèi)使用，否則報panic:數(shù)組越界，比如var arr [5]int的有效下標為0~4.
8、Go的數(shù)組屬于 值類型 ，在默認情況下是 值傳遞 ，因此會進行值拷貝。 數(shù)組間不會相互影響。
9、如想在其他函數(shù)中去修改原來的數(shù)組，可以使用 引用傳遞 (指針方式)。
10、長度是數(shù)組類型的一部分，在傳遞函數(shù)參數(shù)時，需要考慮數(shù)組的長度，看以下案例：
題1：編譯錯誤，因為不能把[3]int類型傳遞給[]int類型，前者是數(shù)組，后者是切片；
題2：編譯錯誤，因為不能把[3]int類型傳遞給[4]int類型；
題3：編譯正確，因為[3]int類型傳給[3]int類型合法。
、數(shù)組
與其他大多數(shù)語言類似，Go語言的數(shù)組也是一個元素類型相同的定長的序列。
（1）數(shù)組的創(chuàng)建。
數(shù)組有3種創(chuàng)建方式：[length]Type 、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN} 如下：
復制代碼代碼如下:
func test5() {
var iarray1 [5]int32
var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5}
iarray3 := [5]int32{1, 2, 3, 4, 5}
iarray4 := [5]int32{6, 7, 8, 9, 10}
iarray5 := [...]int32{11, 12, 13, 14, 15}
iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}
fmt.Println(iarray1)
fmt.Println(iarray2)
fmt.Println(iarray3)
fmt.Println(iarray4)
fmt.Println(iarray5)
fmt.Println(iarray6)
}
結果：
[0 0 0 0 0]
[1 2 3 4 5]
[1 2 3 4 5]
[6 7 8 9 10]
[11 12 13 14 15]
[[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]
我們看數(shù)組 iarray1，只聲明，并未賦值，Go語言幫我們自動賦值為0。再看 iarray2 和 iarray3 ，我們可以看到，Go語言的聲明，可以表明類型，也可以不表明類型，var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全沒問題的。
（2）數(shù)組的容量和長度是一樣的。cap() 函數(shù)和 len() 函數(shù)均輸出數(shù)組的容量（即長度）。如：
復制代碼代碼如下:
func test6() {
iarray4 := [5]int32{6, 7, 8, 9, 10}
fmt.Println(len(iarray4))
fmt.Println(cap(iarray4))
}
輸出都是5。
（3）使用：
復制代碼代碼如下:
func test7() {
iarray7 := [5]string{"aaa", `bb`, "可以啦", "叫我說什么好", "()"}
fmt.Println(iarray7)
for i := range iarray7 {
fmt.Println(iarray7[i])
}
}
二、切片
Go語言中，切片是長度可變、容量固定的相同的元素序列。Go語言的切片本質是一個數(shù)組。容量固定是因為數(shù)組的長度是固定的，切片的容量即隱藏數(shù)組的長度。長度可變指的是在數(shù)組長度的范圍內(nèi)可變。
（1）切片的創(chuàng)建。
切片的創(chuàng)建有4種方式：
1）make ( []Type ,length, capacity )
2) make ( []Type, length)
3) []Type{}
4) []Type{value1 , value2 , ... , valueN }
從3)、4)可見，創(chuàng)建切片跟創(chuàng)建數(shù)組唯一的區(qū)別在于 Type 前的“ [] ”中是否有數(shù)字，為空，則代表切片，否則則代表數(shù)組。因為切片是長度可變的。如下是創(chuàng)建切片的示例：
復制代碼代碼如下:
func test8() {
slice1 := make([]int32, 5, 8)
slice2 := make([]int32, 9)
slice3 := []int32{}
slice4 := []int32{1, 2, 3, 4, 5}
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
}
輸出為：
[0 0 0 0 0]
[0 0 0 0 0 0 0 0 0]
[]
[1 2 3 4 5]
如上，創(chuàng)造了4個切片，3個空切片，一個有值的切片。
（2）切片與隱藏數(shù)組：
一個切片是一個隱藏數(shù)組的引用，并且對于該切片的切片也引用同一個數(shù)組。如下示例，創(chuàng)建了一個切片slice0，并根據(jù)這個切片創(chuàng)建了2個切片 slice1 和 slice2：
復制代碼代碼如下:
func test9() {
slice0 := []string{"a", "b", "c", "d", "e"}
slice1 := slice0[2 : len(slice0)-1]
slice2 := slice0[:3]
fmt.Println(slice0, slice1, slice2)
slice2[2] = "8"
fmt.Println(slice0, slice1, slice2)
}
輸出為：
[a b c d e] [c d] [a b c]
[a b 8 d e] [8 d] [a b 8]
可見，切片slice0 、 slice1 和 slice2是同一個底層數(shù)組的引用，所以slice2改變了，其他兩個都會變。
（3）遍歷、修改切片：
復制代碼代碼如下:
func test10() {
slice0 := []string{"a", "b", "c", "d", "e"}
fmt.Println("\n~~~~~~元素遍歷~~~~~~")
for _, ele := range slice0 {
fmt.Print(ele, " ")
ele = "7"
}
fmt.Println("\n~~~~~~索引遍歷~~~~~~")
for index := range slice0 {
fmt.Print(slice0[index], " ")
}
fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")
for index, ele := range slice0 {
fmt.Print(ele, slice0[index], " ")
}
fmt.Println("\n~~~~~~修改~~~~~~")
for index := range slice0 {
slice0[index] = "9"
}
fmt.Println(slice0)
}
如上，前三種循環(huán)使用了不同的for range循環(huán)，當for后面，range前面有2個元素時，第一個元素代表索引，第二個元素代表元素值，使用 “_” 則表示忽略，因為go語言中，未使用的值會導致編譯錯誤。
只有一個元素時，該元素代表索引。
只有用索引才能修改元素。如在第一個遍歷中，賦值ele為7，結果沒有作用。因為在元素遍歷中，ele是值傳遞，ele是該切片元素的副本，修改它不會影響原本值，而在第四個遍歷——索引遍歷中，修改的是該切片元素引用的值，所以可以修改。
結果為：
~~~~~~元素遍歷~~~~~~
a b c d e
~~~~~~索引遍歷~~~~~~
a b c d e
~~~~~~元素索引共同使用~~~~~~
aa bb cc dd ee
~~~~~~修改~~~~~~
[9 9 9 9 9]
（4）、追加、復制切片：
復制代碼代碼如下:
func test11() {
slice := []int32{}
fmt.Printf("slice的長度為：%d,slice為：%v\n", len(slice), slice)
slice = append(slice, 12, 11, 10, 9)
fmt.Printf("追加后，slice的長度為：%d,slice為：%v\n", len(slice), slice)
slicecp := make([]int32, (len(slice)))
fmt.Printf("slicecp的長度為：%d,slicecp為：%v\n", len(slicecp), slicecp)
copy(slicecp, slice)
fmt.Printf("復制賦值后，slicecp的長度為：%d,slicecp為：%v\n", len(slicecp), slicecp)
}
追加、復制切片，用的是內(nèi)置函數(shù)append和copy，copy函數(shù)返回的是最后所復制的元素的數(shù)量。
（5）、內(nèi)置函數(shù)append
內(nèi)置函數(shù)append可以向一個切片后追加一個或多個同類型的其他值。如果追加的元素數(shù)量超過了原切片容量，那么最后返回的是一個全新數(shù)組中的全新切片。如果沒有超過，那么最后返回的是原數(shù)組中的全新切片。無論如何，append對原切片無任何影響。如下示例：
復制代碼代碼如下:
func test12() {
slice := []int32{1, 2, 3, 4, 5, 6}
slice2 := slice[:2]
_ = append(slice2, 50, 60, 70, 80, 90)
fmt.Printf("slice為：%v\n", slice)
fmt.Printf("操作的切片：%v\n", slice2)
_ = append(slice2, 50, 60)
fmt.Printf("slice為：%v\n", slice)
fmt.Printf("操作的切片：%v\n", slice2)
}
如上，append方法用了2次，結果返回的結果完全不同，原因是第二次append方法追加的元素數(shù)量沒有超過 slice 的容量。而無論怎樣，原切片slice2都無影響。結果：
slice為：[1 2 3 4 5 6]
操作的切片：[1 2]
slice為：[1 2 50 60 5 6]
操作的切片：[1 2]
重慶分公司
重慶分公司
