Goang基础

Last updated on a year ago

语法注意事项

每句语句的后面不需要有分号，区分大小写，导入了包但不使用里面的函数会报错，定义了变量不使用也会报错

Hello World

1
2
3
4
5
package main//包声明每个程序的开头都有一个package声明，表示文件所属代码包
import "fmt"//导入所需要的代码包，导入包后不使用会报错
func main(){//func声明一个函数
    fmt.Println("Hello World")//使用fmt包中的Println()函数
}

引用包

1
2
3
4
5
6
7
8
9
10
import "包名"

//引用多个包
import{
    "包1"
    "包2"
}

//实例
import "fmt"

关键字

25个关键字或保留字

breakdefaultfuncinterfaceselect
casedefergomapstruct
chanelsegotopackageswitch
constfallthroughifrangetype
continueforimportreturnvar

36个预定义字符

append bool byte cap close complex complex64 complex128 uint16
copy false float32 float64 imag int int8 int16 uint32
int32 int64 iota len make new nil panic uint64
print println real recover string true uint uint8 uintptr

数据类型

类型 描述
布尔类型 布尔类型的值只能是true或false
数字类型 整型int、浮点型float32、float63
字符串类型 Go语言的字符串编码使用UTF-8或Unicode
字符类型 Go语言没有专门的字符类型，通常用byte类型：var c byte = ‘a’
派生类型 包括
  • 指针类型
  • 数组类型
  • 结构化类型(struct)
  • Channel类型
  • 函数类型
  • 切片类型
  • 接口类型
  • Map类型

数字类型

类型 描述
uint8 无符号8位整型(0-255)
uint16 0 到 65535
unit32 0 到 4294967295
unit64 0 到 18446744073709551615
int8 -128 到 127
int16 -32768 到 32767
int32 -2147483648 到 2147483647
int64 -9223372036854775808 到 9223372036854775807

浮点型

类型 描述
float32 IEEE-754 32位浮点型数
float64 IEEE-754 64位浮点型数
complex64 32 位实数和虚数
complex128 64 位实数和虚数

其他数字类型

类型 描述
byte 类似uint8
rune 类似int32
uint 32或64位
int 同unit大小
uintptr 无符号整型，用于存放一个指针

类型转换

Golang中的类型转换与Java不同，没有类型提升，不能自动转换数据类型，在进行类型转换时必须手动，哪怕是不同位数的同类型

1
2
3
var a int32 = 10
var b int64 = int64(a)//b=>a
var c float32 = float32(b)c=>b

其他类型转spring

  • 使用fmt包中的Spfintf()函数：

    Sprintf()可以将参数根据指定的格式转换为字符串，并返回结果

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import "fmt"
    var a int8 = 10
    var str string
    str = fmt.Sprintf("%d",a)
    fmt.Printf("type:%T\nstr = %v",str,str)

    //输出结果：
    type:string
    str = 10

变量

变量声明

声明变量一般使用关键字var

单变量声明

  • **指定变量类型，若没有初始化则为默认值 **：

    1
    2
    3
    4
    5
    6
    var v_name v_type
    //实例
    var num int
    //声明了整型变量num，默认值为0
    var num int = 10
    //声明的同时赋值

  • 根据值自动判断变量类型

    1
    2
    3
    4
    var v_name = value
    //实例
    var a = false
    //声明了a=false，自动判断为布尔类型

  • 使用:=声明变量

    这种写法只能在函数体内使用

    1
    2
    3
    4
    v_name :=value
    //实例
    num :=10
    //注意，若是在使用:=之前就已经使用var声明变量，则报错

多变量声明

和单变量类似，三种方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//类型相同，非全局变量
var vname1,vname2,vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1,vname2,vname3 = v1, v2, v3//不需要声明类型，自动判断

vname1, vname2, vname3 :=v1, v2, v3//变量没有被声明过


//这种写法一般用于声明全局变量
var{
    vname1 v_type1
    vname2 v_type2
}

常量

常量是一个简单值得标识符，在程序运行时，不会被修改的量，常量的定义格式：

1
2
3
4
5
const identifier [type] = value
//type可省略
//实例
const b string = "abc"
const c = 1

多个相同类型的声明可以简写为：

1
const c_name1, c_name2, = value1, value2

控制语句

  • if:

    1
    2
    3
    4
    5
    6
    if 条件{
        
    }
    else{
        
    }

    条件不需要使用括号括起来，if后面必须跟着大括号不能单独一行，否则报错。

  • switch：

    1
    2
    3
    4
    5
    6
    7
    8
    switch 表达式;{
        case 表达式1:
        	语句
        case 表达式2:
        	语句
        default :
        	语句
    }

    在golang中执行完一个case后自动退出switch，不需要使用break，若想执行一个case后继续往下执行，可以使用fallthrough

    1
    2
    3
    4
    5
    6
    7
    switch 表达式{
        case 表达式1:
        	语句
        	fallthrough
        case 表达式2:
    		语句
    }

    golang的case后的表达式可以有多个表达式用逗号隔开，只要满足其中一个就会执行case语句

    1
    2
    3
    4
    switch 表达式{
        case 表达式1,表达式2:
        	执行语句
    }

    switch后也可以不带表达式，可以当作if使用

    1
    2
    3
    4
    5
    6
    7
    var a = 10;
    switch {
        case 0<a<10:
        	语句
        case 10<=a<20:
        	语句
    }

  • for循环

    golang的for循环与C语言类似，但少了括号

    1
    2
    3
    for 循环变量初始化; 循环条件; 循环变量迭代{
        语句
    }

    for循环的第二种使用方式

    1
    2
    3
    for 循环判断条件{
    	语句
    }

    第三种使用方法

    1
    2
    3
    for{
        语句
    }

    这种写法会无限循环，一般配合break使用。

    后两种写法相当于while，所以golang中并没有while语句

    • 使用for循环遍历字符串的两种方法

      1
      2
      3
      4
      5
      6
      7
      8
      //传统方式
      for i := 0; i < len(str); i++{
          fmt.Printf("%c",str[i])
      }
      //使用range
      for index, val := range str{   	
          fmt.Printf("index=%d,val=%c",index,val)
      }

      第二种方法把下标赋值给index，把值赋值给val，如果字符串含有中文，第一种方式会出现乱码，因为它是按字节遍历的，而一个汉字的utf8编码占3个字节，所以会乱码。如果用第二种方式则不会乱码，因为range是按照字符的方式遍历