[code static]Go基础语法

//变量声明(声明常变量，把var改为const)空nil
//一般
var a, b, c int8
a, b, c = 10, 20, 30

var a, b, c = 10, 20, 30

var {
a int8
b int16
c int32
}

//全局专属
var a, b
a, b := 10, 20

//在函数体内
func main (){
//直接声明
g, h := 10, "string"
//局部变量必须被使用
fmt.Println("hello, world", g, h)
//iota用法
const (
a = iota   //0
b          //1
c          //2
d = "ha"   //独立值，iota += 1
e          //"ha"   iota += 1
f = 100    //iota +=1
g          //100  iota +=1
h = iota   //7,恢复计数
i          //8
)
}

//交换两个变量的值
a, b = b, a
//_ 实际上是一个只写变量，你不能得到它的值
//5将被抛弃
_, b = 5, 7

//使用 if 语句判断布尔表达式
if a < 20 {
//如果条件为 true 则执行以下语句
fmt.Printf("a 小于 20\n" )
} else {
//如果条件为 false 则执行以下语句
fmt.Printf("a 不小于 20\n" );
}

switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}

switch {
case grade == "A" :
fmt.Printf("优秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" );
}
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的类型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}

func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
case i3, ok := (<-c3):  // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}

for i,x:= range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
for true  {
fmt.Printf("这是无限循环。\n");
}
for i = 0; i < 10; i++ {
n[i] = i + 100 /* 设置元素为 i + 100 */
}
break continue goto

//函数
func swap(x, y string) (string, string) {
//声明
return y, x
}
func main() {
//调用
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}

//数组
//声明数组
var balance [10] float32
var ptr [MAX]*int //指针数组
//初始化数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance[4] = 50.0
//多维数组
a = [3][4]int{
{0, 1, 2, 3},   /*  第一行索引为 0 */
{4, 5, 6, 7},   /*  第二行索引为 1 */
{8, 9,10,11}   /*  第三行索引为 2 */
}
//数组传函数
func getAverage(arr []int, size int) float{
var i int
var sum float32
//声明
for i = 0; i < size; ++i{
sum += arr[i]
}
return sum / size
}
func main(){
var a = []int{1, 1, 1, 1, 1}
var b = getAverage(a, 5)//调用
fmt.println(b)
}

//指针
var a int = 20
var b *int
var c **int
b = &a //b指向数据a
c = &b //c指向指针b
fmt.Printf("%x\n", *b)

//结构体
type Books struct {
title string
id int
}
var book Books //声明
book.title = "a"
book.id = 0
//Bools当int等数据类型用

//切片
//声明
var slice1 []type = make([]type, len) //make([]T, length, capacity)
//初始化
s :=[] int {1,2,3 }
s := arr[:]
s :=make([]int,len,cap)
//len() cap()
fmt.Printf("len=%d cap=%d slice=%v\n", len(s), cap(s), s)
//**len=3 cap=5 slice=[0 0 0]
//append()追加, copy()
a = append(a, 2, 3, 4)
copy(b, a)//复制a给b

//接口
/* 定义接口 */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* 定义结构体 */
type struct_name struct {
/* variables */
}
/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
/* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* 方法实现*/
}

//********
import (
"fmt"
)
type Phone interface {
call()
}
type NokiaPhone struct {
}
func (nokiaPhone NokiaPhone) call() {
fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct {
}
func (iPhone IPhone) call() {
fmt.Println("I am iPhone, I can call you!")
}
func main() {
var phone Phone
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}

//range
func main() {
//这是我们使用range去求一个slice的和。使用数组跟这个很类似
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
//在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
//range也可以用在map的键值对上。
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
for i, c := range "go" {
fmt.Println(i, c)
}
}

//map
func main() {
var countryCapitalMap map[string]string
/* 创建集合 */
countryCapitalMap = make(map[string]string)
/* map 插入 key-value 对，各个国家对应的首都 */
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "New Delhi"

/* 使用 key 输出 map 值 */
for country := range countryCapitalMap {
fmt.Println("Capital of",country,"is",countryCapitalMap[country])
}
/* 查看元素在集合中是否存在 */
captial, ok := countryCapitalMap["United States"]
/* 如果 ok 是 true, 则存在，否则不存在 */
if(ok){
fmt.Println("Capital of United States is", captial)
}else {
fmt.Println("Capital of United States is not present")
}
/* 删除元素 */
delete(countryCapitalMap,"France");
}

//错误处理
// 定义一个 DivideError 结构
type DivideError struct {
dividee int
divider int
}
// 实现   `error` 接口
func (de *DivideError) Error() string {
strFormat := `
Cannot proceed, the divider is zero.
dividee: %d
divider: 0`
return fmt.Sprintf(strFormat, de.dividee)
}
// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
if varDivider == 0 {
dData := DivideError{
dividee: varDividee,
divider: varDivider,
}
errorMsg = dData.Error()
return
} else {
return varDividee / varDivider, ""
}
}
func main() {
// 正常情况
if result, errorMsg := Divide(100, 10); errorMsg == "" {
fmt.Println("100/10 = ", result)
}
// 当被除数为零的时候会返回错误信息
if _, errorMsg := Divide(100, 0); errorMsg != "" {
fmt.Println("errorMsg is: ", errorMsg)
}
}