給別人看的，機器并不會執(zhí)行這行語句
創(chuàng)新互聯(lián)專注于企業(yè)網絡營銷推廣、網站重做改版、山海關網站定制設計、自適應品牌網站建設、H5建站、商城網站開發(fā)、集團公司官網建設、成都外貿網站建設、高端網站制作、響應式網頁設計等建站業(yè)務，價格優(yōu)惠性價比高，為山海關等各大城市提供網站開發(fā)制作服務。
重慶分公司
重慶分公司
// 我是單行注釋
/*
我是多行注釋
我是多行注釋
我是多行注釋
我是多行注釋
*/
// 這是一個main函數，這個是go語言啟動的入口
func main() {
//fmt.Println ：打印一句話，然后執(zhí)行完畢后，進行換行
fmt.Println("Hello,Word")
}
字面理解為變量就是會變化的量
package main
import "fmt"
func main() {
var name string = "DuPeng"
fmt.Println(name)
}
注意：如果在點擊這里執(zhí)行會出錯
出錯提示：項目里有多個main方法
正確執(zhí)行方式：鼠標單擊右鍵執(zhí)行，一定要在main方法外！ 一定要在main方法外 ！一定要在main方法外，重要事情說三遍
var name type
name
name 為變量，它指向的是地址，而這個地址指向內存空間，而內存空間的數據是可以更換的
var
聲明變量的關鍵字，固定的寫法，記住即可
type
代表變量的類型
定義多個變量
package main
import "fmt"
// “=” 賦值符號 將等號右邊的值賦值給等號左邊
func main() {
var (
//姓名
name string
//年齡
age int
//地址
addr string
)
//string 默認值：空
//int 默認值：0
fmt.Println(name, age, addr)
}
標準格式
var 變量名 類型 =值(表達式)
也可以先定義，再賦值
package main
import "fmt"
func main() {
// “=” 賦值符號
var (
//姓名
name string
//年齡
age int
//地址
addr string
)
name = "dupeng"
age = 22
addr = "成都"
//string 默認值：空
//int 默認值：0
fmt.Println(name, age, addr)
}
短變量聲明并初始化
import "fmt"
func main() {
// :=自動推導
name := "dupeng"
age := 18
fmt.Println(name, age)
//打印輸出name和age的類型
fmt.Printf("%T,%T", name, age)
}
打印輸出聲明類型
打印內存地址
import "fmt"
func main() {
var num int
num = 100
fmt.Printf("num：%d,內存地址：%p", num, &num)
}
不要忘記取地址符
值發(fā)生變換而內存地址不會發(fā)生改變，但每次重啟系統(tǒng)就會重新分配一個新的地址空間
package main
import "fmt"
func main() {
/*
在其他語言中 變量的交換為下列代碼
a=100
b=200
temp=0
temp=a
a=b
b=temp
*/
// 而在go語言中
var a int = 100
var b int = 200
b, a = a, b
fmt.Println(a, b)
}
特點是"_","_"本身就是一個特殊字符
被稱為空白標識符，任何賦值給這個標識符的值都會被拋棄，這樣可以加強代碼的靈活性
package main
import "fmt"
func test() (int, int) {
return 100, 200
}
func main() {
a, b := test()
fmt.Println(a, b)
}
當我們不想接收第二個值時可以廢棄掉
package main
import "fmt"
func test() (int, int) {
return 100, 200
}
func main() {
a,_ := test()
fmt.Println(a)
}
一個變量（常量、類型或函數)在程序中都有一定的作用范圍，稱之為作用域。
局部變量
在函數體聲明的變量，只作用在函數體內
全局變量
在函數體外聲明的變量為全局變量
全局變量必須以var關鍵字開頭，如果要在外部包使用全局變量的首字母必須大寫
是一個簡單值得標識符，在程序運行時，不會被修改的量
數據類型：布爾型，數字型，（整數型、浮點型和復數型）和字符串型
當定義完常量后，常量不允許被修改，否則會出錯
示例：
特殊常量，可以認為是一個被編譯器修改的常量
iota是go語言的常量計數器 從0開始 依次遞增
直至const出現(xiàn)之時將被重置
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "dd" // dd iota=3
e //4
f = 100 //100 iota=5
g //6
h = iota //haha iota=7
i //8
)
const (
j = iota
k
)
fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}
//輸出結果：0 1 2 dd dd 100 100 7 8 0 1
在Go編程語言中，數據類型用于聲明函數和變量。
數據類型的出現(xiàn)是為了把數據分成所需內存大小不同的數據，編程的時候需要用大數據的時候才需要申請大內存，就可以充分利用內存。
編譯器在進行編譯的時候，就要知道每個值的類型，這樣編譯器就知道要為這個值分配多少內存，并且知道這段分配的內存表示什么。
布爾型的值只可以是常量true或者false
布爾類型的值默認為false
package main
import "fmt"
func main() {
// var 變量名 數據類型
var isFlang bool
fmt.Println(isFlang)
}
//輸出結果為：false
整形int和浮點型float32、float64、Go語言支持整形和浮點型數字，并且支持負數，其中位 的運算采用補碼
| 序號 | 類型和描述 |
|---|---|
| 1 | uint8無符號8位整型(O到255) |
| 2 | uint16無符號16位整型(O到) |
| 3 | uint32無符號32位整型(O到) |
| 4 | uint64無符號64位整型(0到) |
| 5 | int8有符號8位整型(-128到127) |
| 6 | int16有符號16位整型(-到) |
| 7 | int32有符號32位整型(-到) |
| 8 | int64有符號64位整型(-到 ) |
package main
import "fmt"
func main() {
//定義一個整形
//byte uint8
//rune int32
//int int64
var age int = 18
fmt.Printf("%T,%d\n", age, age)
//定義一個浮點型
var money float32 = 300.15
//這里打印浮點數類型為%f
//默認是6位小數打印
fmt.Printf("%T,%f\n", money, money)
}
//輸出結果：int,18
//float32,300.
1、關于浮點數在機器中存放形式的簡單說明，浮點數=符號位+指數位+尾數位
2、尾數數部分可能丟失，造成精度損失。-123.0000901
| 序號 | 類型和描述 |
|---|---|
| 1 | float32 IEEE-754 32位浮點型數 |
| 2 | float64 lEEE-位浮點型數 |
| 3 | complex64 32位實數和虛數 |
| 4 | complex128 64位實數和虛數 |
類型別名
| 序號 | 類型和描述 |
|---|---|
| 1 | byte類似于uint8 |
| 2 | rune類似于int32 |
| 3 | uInt32或64位 |
| 4 | int與uint一樣大小 |
| 5 | uintprt無符號整形，用于存放一個指針 |
字符串就是一串固定長度的字符連接起來的字符序列。
Go的字符串是由單個字節(jié)連接起來的。
Go語言的字符串的字節(jié)使用UTF-8編碼標識Unicode文本。
package main
import "fmt"
func main() {
//字符串 雙引號
var str string
str = "hello,word"
//輸出打印的類型和值
fmt.Printf("%T,%s\n", str, str)
// 字符 單引號
//字符為數值類型，需要%d打印
//所有中國字的編碼表：GBK
//全世界的編碼表：Unicode編碼表
v1 := 'A'
v2 := "B"
v3 := '中'
//編碼表 ASCII字符嗎
fmt.Printf("%T,%d\n", v1, v1)
fmt.Printf("%T,%s\n", v2, v2)
fmt.Printf("%T,%d\n", v3, v3)
//字符串拼接
fmt.Printf("hello" + "學相伴\n")
//轉義字符 \
fmt.Printf("hello\"學相伴\"\n")
//間隔符 \t tab
fmt.Printf("hello\"學相伴\t")
}
在必要以及可行的情況下，一個類型的值可以被轉換成另一種類型的值。
由于Go語言不存在隱式類型轉換，因此所有的類型轉換都必須顯式的聲明
package main
import "fmt"
func main() {
a := 3 //int
b := 4.0 //float64
//需求：將a轉換為float64位
c := float64(a)
//boll 整形是不能轉換為bool的
//cannot convert a (variable of type int) to type bool
//e := bool(a)
fmt.Printf("%T\n", a)
fmt.Printf("%T\n", b)
fmt.Printf("%T\n", c)
//fmt.Printf("%T\n", e)
}
/*
輸出結果為：
int
float64
float64
*/
類型轉換只能在定義正確的情況下轉換成功，例如從一個取值范圍較小的類型轉換到一個取值范圍較大的類型(將int16轉換為int32)。
當從一個取值范圍較大的類型轉換到取值范圍較小的類型時(將int32轉換為int16或將 float32轉換為 int)，會發(fā)生精度丟失（截斷）的情況。
下表列出了所有Go語言的算術運算符。假定A值為10，B值為20。
| 運算符 | 描述 | 實例 |
|---|---|---|
| + | 相加 | A+B輸出結果30 |
| - | 相減 | A-B輸出結果-10 |
| * | 相乘 | A*B輸出結果為200 |
| / | 相除 | B/A輸出結果為2 |
| % | 求余 | B%A輸出結果為0 |
| ++ | 自增 | A++輸出結果11 |
| -- | 自減 | A--輸出結果為9 |
package main
import "fmt"
func main() {
var a int = 10
var b int = 3
// + - * / % ++ --
fmt.Println(a + b)
fmt.Println(a - b)
fmt.Println(a * b)
fmt.Println(a / b)
a++ //a=a+1
fmt.Println(a)
a-- //a=a-1
fmt.Println(a)
}
/*輸出結果為：
13
7
30
3
11
10
*/
下表列出了所有Go語言的關系運算符。假定A值為10，B值為20。
| 運算符 | 描述 | 實例 |
|---|---|---|
| == | 檢查兩個值是否相等，如果相等返回True否則返回false | A==B 為false |
| ！= | 檢查兩個值是否不相等，如果不相等返回True否則返回false | A！=B為true |
| > | 檢查左邊值是否大于右邊值，如果是返回True否則返回false | A>B 為false |
| < | 檢查左邊值是否小于右邊值，如果是返回True否則返回false | A |
| >= | 檢查左邊值是否大于等于右邊值，如果是返回True否則返回false | A>=B 為false |
| <= | 檢查左邊值是否小于等于右邊值，如果是返回True否則返回false | A<=B 為true |
package main
import "fmt"
func main() {
var A int = 10
var B int = 20
//關系運算符，結果都是bool
fmt.Println(A == B)
fmt.Println(A != B)
fmt.Println(A > B)
fmt.Println(A < B)
fmt.Println(A >= B)
fmt.Println(A <= B)
/*
輸出結果：
false
true
false
true
false
true
*/
}
下表列出了所有Go語言的邏輯運算符。假定A值為true，B值為false。
| 運算符 | 描述 | 實例 |
|---|---|---|
| && | 邏輯AND運算符，如果兩邊的操作數都是True，則條件True，否則為False。 | A&&B 為false |
| || | 邏輯OR運算符，如果兩邊的操作數有一個True，則條件True，否則為False。 | A||B為true |
| ！ | 邏輯NOT運算符，如果條件為True，則邏輯NOT條件False，否則為True。 | ?。ˋ&&B ）為true |
邏輯與&&
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
//如果a和b同時為真
if a && b {
//那么我們輸出為 true
fmt.Println(a)
} else {
//否則輸出為 false
fmt.Println(b)
// 輸出的結果為 ：false
}
}
邏輯或||
遇真則真，全假則假
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
//當a或者b其中一個為真那么結果為真，
if a || b {
//那么我們輸出為 true
fmt.Println(a)
}
//輸出結果： true
}
邏輯非！
非也，也可以理解取反，表示否定的意思
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
//非b 那么！b=ture
if !b {
//那么我們輸出為 a，因為a=true
fmt.Println(a)
}
//輸出結果： true
}
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 按位與運算符"&"是雙目運算符。都是1結果為1，否則是0 | (A&B)結果為12,二進制為0000 1100 |
| | | 按位或運算符"|"是雙目運算符。都是0結果為0，否則是1 | (A |B)結果為61，二進制0011 1101 |
| ^ | 按位異或運算符"A"是雙目運算符。不同則為1，相同為0 | (A^B)結果為49,二進制為0011 0001 |
| &^ | 位清空，a &^b，對于b上的每個數值，如果為0，則取a對應位上的數值，如果為1，則取0. | (A&^B)結果為48,二進制為0011 0000 |
| << | 左移運算符"<<"是雙目運算符。左移n位就是乘以2的n次方。其功能把"<<"左邊的運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補O。 | A<<2結果為240，二進制為1111 0000 |
| >> | 右移運算符">>"是雙目運算符。右移n位就是除以2的n次方。其功能是把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數。 | A>>2結果為15，二進制為0000 1111 |
package main
import "fmt"
func main() {
// 二進制 逢二進一
//位運算：二進制
// 60 0011 1100
// 13 0000 1101
//----------------進行&運算
// 12 0000 1100 我和你 同時滿足
//----------------進行|運算
// 61 0011 1101 我或你 一個滿足即可
// 49 0011 0001 不同為1 相同為0
var a uint = 60
var b uint = 13
//與運算結果
fmt.Printf("%d,二進制：%b\n", a&b, a&b)
//或運算結果
fmt.Printf("%d,二進制：%b\n", a|b, a|b)
//非運算結果
fmt.Printf("%d,二進制：%b\n", a^b, a^b)
//a向左移動兩位
// 60 0011 1100
// 移動之后 1111 0000
fmt.Printf("左移動后后的十進制：%d,左移動后的二進制：%b\n", a<<2, a<<2)
//a向右移動兩位
// 60 0011 1100
// 移動之后 0000 1111
fmt.Printf("右移動后后的十進制：%d,右移動后的二進制：%b\n", a>>2, a>>2)
/*
輸出結果：
12,二進制：1100
61,二進制：
49,二進制：
左移動后后的十進制：240,左移動后的二進制：
右移動后后的十進制：15,右移動后的二進制：1111
*/
}
下表列出了所有的Go語言的賦值運算符
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符，將一個表達式的值賦給一個左值 | C =A+B將A＋B表達式結果賦值給C |
| += | 相加后再賦值 | C +=A等于C=C+A |
| -= | 相減后再賦值 | C -=A等于C=C-A |
| *= | 相乘后再賦值 | C *=A等于C=C *A |
| /= | 相除后再賦值 | C/=A等于C=C/ A |
| %= | 求余后再賦值 | C%=A等于C=C%A |
| <<= | 左移后賦值 | C<<=2等于C=C<<2 |
| >>= | 右移后賦值 | C>>=2等于C=c>>2 |
| &= | 按位與后賦值 | C&=2等于C=C&2 |
| ^= | 按位異或后賦值 | C=2等于C=C2 |
| != | 按位或后賦值 | C|=2等于C=C|=2 |
package main
import "fmt"
func main() {
var A int = 10
var B int = 20
var C int
// 賦值運算符 =
C = A + B
fmt.Println(C) //結果為30
// 相加后再賦值
C += A //注意這里初始值為：C=30 C= C+A=30+10
fmt.Println(C)
/*
輸出結果：
30
40
*/
}
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 返回變量存儲地址 | &a;將給出變量的實際地址 |
| * | 指針變量 | *a；是一個指針變量 |
package main
import "fmt"
func main() {
var a int
var b float32
//定義了兩個變量，想用鍵盤來錄入這個兩個變量
//fmt.Println() 打印并換行
//fmt.Printf() 格式化輸出
//fmt.Printf() 打印輸出
fmt.Printf("請輸入兩個數：1.整數 2.浮點數\n")
fmt.Scanln(&a, &b)
fmt.Printf("輸出的兩個數的結果為：\n")
fmt.Println("a:", a, "b:", b)
// fmt.Scanln（） 接受輸入scan
// fmt.Scanf（） 接受輸入 格式化輸入 作業(yè)
// fmt.Scan（） 接受輸入 作業(yè)
}
命名規(guī)范
命名是代碼規(guī)范中很重要的一部分，統(tǒng)一的命名規(guī)則有利于提高的代碼的可讀性，好的命名僅僅通過命名就可以獲取到足夠多的信息。
包名：package
保持package的名字和目錄名保持一致，盡量采取有意義的包名，簡短，有意義，盡量和標準庫不要沖突。包名應該為小寫單詞，不要使用下劃線或者混合大小寫。
package model
package main
文件名
盡量采取有意義的文件名，簡短，有意義，應該為小寫單詞，使用下劃線分隔各個單詞(蛇形命名)。
