go 基础语法

基本语法规则

• 在go语言中，语句末尾的分号;是可以省略的
• 在go语言中，代码片段的起始花括号{不能换行，否则程序报错。
• bool类型不能和其他类型运算 ，整型也不能强行转为bool, bool 初始值是 false

基本语法

基本数据类型

类型 长度（字节） 说明
bool 1 true, false。 不能把非零值当做true
byte 1 uint8 别名
rune 4 int32 别名。代表一个Unicode字符
int/uint 4 依据所运行的平台，可能是32bit或64bit。
int8/uint8 1 1-128 ~ 127; 0 ~ 255
int16/uint16 2 -32768 ~ 32767; 0 ~ 65535
int32/uint32 4 -21亿 ~ 21亿；0 ~ 42亿
complex64 8 复数类型，即32位实数+32位虚数
complex128 16 复数类型，即64位实数+64位虚数
uintptr 能够保存指针的32位或64位整数
array 数组，值类型，如：[2]int
struct 结构体，值类型
string 值类型
slice 引用类型，如：[]int
map 引用类型
channel 引用类型
Interface 接口类型
function 函数类型

查看变量类型(typeof)

package main    // 声明 main 包
import (
    "fmt"       // 导入 fmt 包，打印字符串是需要用到
)
var name string = "jjj"
func main() {   // 声明 main 主函数
    fmt.Println(typeof(name))
}
func typeof(v interface{}) string {
    return fmt.Sprintf("%T", v)
}

声明变量

• 变量声明了，必须使用
• 常量必须赋初值

package main
import "fmt"

// int 可以表示 负数 ; uint 不能表示负数
// float32 float64 表示浮点型

func main() {
	var number1 int=123
	var str1 string = "123"
	var isTrue bool =false
	var float1 float32=1.2

	// 基本数据类型可以自动推导
	var number=18
	var str=19
	var bool1=false

	// 短变量声明 只能声明局部变量
	number2 := 156
	number3,str3 := 999,"kkk"

	const NUM="cONST"

	fmt.Println("hello word---",float1,NUM,number,str,bool1,number1,str1,isTrue,number2,number3,str3)
}

switch

• go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch，但是可以使用fallthrough强制执行后面的case代码，fallthrough相当于去掉了case后面默认的break。

func main(){
    i := 5
    switch i{
        case 1:
            fmt.Println("i is equal to 1")
        case 2:
            fmt.Println("i is equal to 2")
        case 3,4,5,6:
            fmt.Println("i is equal to 3,4,5 or 6")
            fallthrough
        default:
            fmt.Println("others")
    }
}

for

func main(){
    str := "Chain"
    for i, j := 0, len(str); i < j; i++{
        fmt.Println(string(str[i]))
    }}

函数

package main
import "fmt"

func main(){
    quotient, remainder := divide(5, 3)
    fmt.Println("商为：", quotient, "余数为：", remainder)
    
    result := sum(3,5,7,9)
    fmt.Println("结果为：", result)
}
// 定义一个多返回值函数
func divide(a, b int)(int, int){
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}
// 不定参数
func sum(aregs ...int) int {
    s := 0
    fmt.Println("aregs为：", aregs)  //aregs为： [3 5 7 9]
    for _, number := range aregs{
        s += number
    }
    return s
}

数组

• 值类型

package main

import (
    "fmt"
)

func main(){
    var a = [5]int{1,2,3,4,5}
    e := a
    e[2] = 10
    fmt.Printf("a:%v\n", a)   // a:[1 2 3 4 5]
    fmt.Printf("e:%v\n", e)       // e:[1 2 10 4 5]

    //下标遍历数组
    for i := 0; i < len(a); i++{
        fmt.Printf("a[%d] = %d\n", i, a[i])
    }
    fmt.Println("")
    // range关键字遍历
    for i, v := range a{
        fmt.Printf("a[%d] = %d\n", i, v)
    }
}

slice(数组的扩展–切片)

• 引用类型

package main

import "fmt"

// 引用类型
func main(){
   s1 := []int{1,2,3,4,5}
   s2 := s1
   s2[2] = 10
   fmt.Println("s1: ", s1)    // s1:  [1 2 10 4 5]
   fmt.Println("s2: ", s2)    // s2:  [1 2 10 4 5]
}

相关方法

package main

import "fmt"

func main() {
slice1:=[]int{1,2,3}

// 遍历
for _,val := range slice1 {
	fmt.Println(val)
}

// 获取一部分
slice2 :=slice1[1:2]

// 添加
// append 也可以合并切片
slice1=append(slice1,4,5)		// 末尾添加

// 复制
slice3:=make([]int,len(slice1),20)
copy(slice3,slice1)

// 删除
// 删除 index=2
slice1=append(slice1[:2],slice1[3:]...)
	
fmt.Println(slice1,slice2,slice3)
}

map

map是一个key-value的hash结构，是一个无序的数据的集合，通过键来进行索引得到对应的值。 这种方式可以加快查找速度。Map 通常称为 字典（dictionary） 或者哈希表(Hash table)。Map 现在是很多语言的标配

package main

import "fmt"

func main() {
	map1 :=map[string]string{
		"username": "hhh",
	}

	map1["age"]="18"
	fmt.Println(map1)
}

综合案例

package main

import "fmt"

func main() {
userInfo := []map[string]string{
	{
		"username": "wxj",
		"age":"26",
	},
	{
		"username": "wxj1",
		"age":"28",
	},
}

fmt.Println(userInfo)
}

对象

golang是面向过程的语言，go中没有类，但go支持面向对象的编程，go中的struct就像其他语言中的类；go里没有继承，但可以通过组合来实现。

结构体–类

基本使用

package main
import "fmt"

type Person struct {
	name string
	age int
}

func (p Person) printInfo(name string)string{
	p.name = name
	fmt.Println(p.name,"---",p.age)		// wxj123 --- 18

	return name
}

func main() {

	var person =Person{
		name :"wxj",
		age :18,
	}


	newname:=person.printInfo("wxj123") 
	fmt.Println(newname)		// wxj123
}

接口

接口是一系列操作的集合，是一种约束。我们可以把它看作与其他对象通讯的协议。任何非接口类型只要拥有某接口的全部方法，就表示它实现了该接口，go中无需显式的在该类上添加接口声明。

线程

1.12 错误及异常处理

package main

import (
"errors"
"fmt"
)

func main(){
   defer func(){
      if err := recover(); err != nil{ //捕捉异常并处理
         fmt.Println("err: ", err)
      }
   }()

   if num, err := delive(20, -5); err == nil{
      fmt.Printf("%f / %f = %f\n", 20.0, -5.0, num)
   }else{
      fmt.Println(err)
   }

   if num, err := delive(20, 0); err == nil{
      fmt.Printf("%f / %f = %f\n", 20.0, 0.0, num)
   }else{
      fmt.Println(err)
   }
}

func delive(numA, numB float32) (float32, error){
   if numB < 0{
      return 0, errors.New("被除数不能为负数")
   }else if numB == 0{
      panic("被除数不能为0") //抛出异常
   }else{
      return numA/numB, nil
   }
}

操作文件