go语言的基础语法

基础语法

与python、vue等类似，go语言也分常量和变量等，常量用const(不可变)和变量var(可变)定义

 常量

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型，值不可更改，表达式只支持内置函数

const num int = 10
const str = "Hello world" //支持按值进行类型推导
const LENGTH = len(str) //表达式只支持内置函数
//定义枚举值
const (
    Unknown = 0
    Female = 1
    Male = 2
)

变量

func main() {
    var a = 100 // 支持类型推导
    var b int = 200   // 声明类型并初始化
    var (
        x,y,z string   //只声明
    )

    var a int 
    a = 150
    c := 300 //短变量声明并初始化，只能在函数体内使用
    x = "hello world"  //全局变量赋值
}

函数体内的变量一旦声明就一定要使用，不然会报编译出错，变量读取优先读取函数体内的，没找到再读取函数体外的

_特殊只写变量，例如 值 5 在：_, b = 5, 7 中被抛弃，常用于不需要从一个函数得到所有返回值

基础数据类型

go不支持隐式类型转换，需显示转换，要转换的类型(变量)

• 整型
  有符号按长度分为：int8、int16、int32、int64 ，对应的无符号整型：uint8、uint16、uint32、uint64，默认值为0

var x int8 = 8
var y int32 = 55
y = int32(x) //低位转高位
fmt.Println(x, y) //输出8,8
var a int8 = 9
var b int32 = 99
a = int8(b) //高位转低位 转成二进制截取
fmt.Println(a,b) //输出9，9

特殊整型
int/uint 32位操作系统上就是int32/uint32，64位操作系统上就是int64/uint64
uintptr 无符号整型，用于存放一个指针
byte 实际是一个uint8，代表了ASCII码的一个字符
rune 实际是一个int32，代表一个UTF-8字符

布尔型
true和false，默认值为false，无法参与数值运算，不允许将整型强制转换为布尔型

浮点型
支持两种浮点型数：float32和float64，默认类型是float64

复数
complex64和complex128

字符串

go语言字符串是一个任意字节的常量序列，底层是byte字节数组,len()方法计算的是字节总数，修改字符串必须先转成byte或者rune，多行字符串可以使用反引号``

func main(){
    var str = "Go入门教程!"
    fmt.Println(str[0:],str[0:5]) //按索引截取字符串
    fmt.Println(len(str)) //输出15, 一个中文三个字节
    fmt.Println(utf8.RuneCountInString(str))//输出7，代表7个字符
    var charArray = []rune(str) //转成字节切片
    fmt.Println(len(charArray))
    //range 遍历所有字符
    for _,s:= range str {
        fmt.Printf("%v\t",string(s))
    }
    //字符串比较==
    var str1= "Go入门教程" + "!"
    fmt.Println(str==str1)  

    str += "welcome" //字符串连接
    fmt.Println(str)
}

常用工具包strings

strings.ToUpper(str),strings.ToLower(str）
strings.Join([]string{"java", "go", "c++"},";")
strings.ContainsAny(str, "GW")
strings.Contains(str,"Go")
strings.Split(str,"")
strings.EqualFold(str,str1) //不区分大小比较
strings.Compare(str1,str) //区分大小写比较

字符串连接采用strings.Builder或者 bytes.Buffer，推荐strings.Builder 性能最高

func StringAppend(num int) {
    var now = time.Now()
    var str = ""
    for i := 0; i < num; i++ {
        str += "append" + strconv.Itoa(i)
    }
    fmt.Println(time.Since(now))
    fmt.Println(len(str))

    now = time.Now()
    var stringBuilder = strings.Builder{}
    for i := 0; i < num; i++ {
        stringBuilder.WriteString("append" + strconv.Itoa(i))
    }
    fmt.Println(time.Since(now))
    fmt.Println(len(stringBuilder.String()))

    now = time.Now()
    var bytebuffer bytes.Buffer
    for i := 0; i < num; i++ {
        bytebuffer.WriteString("append" + strconv.Itoa(i))
    }
    fmt.Println(time.Since(now))
    fmt.Println(len(bytebuffer.String()))
}

类型转换

基础数据类型转string，采用strconv包 或者fmt.Sprintf()

var x int = 99
var y float32= 88.88
fmt.Sprintf("%d,%.2f",x,y)

string转基础数据类型，利用strconv包

var x = "99";
var y = "88.88"

运算符

不支持三元运算符，支持赋值交换，比如a,b=b,a

控制语句

支持 if，for，case，表达式不需要()，支持goto 语言但不推荐使用

func main() {
    if x,y:=5,3; x+y > 10 {   //判断表达式前支持一个赋值表达式分号分隔
        fmt.Printf("%d + %d > 10",x, y)
    }else if x+y < 10{
        fmt.Printf("%d + %d < 10",x, y)
    }else{
        fmt.Printf("%d + %d = 10",x, y)
    }
}

// 冒泡算法
func BubbleSort(array []int){
    length := len(array)
    for i:= 0; i < length-1; i++ {
        for j := 0; j < length-i-1; j++{
            if array[j] > array[j+1]{
                array[j], array[j+1] = array[j+1],array[j]
            }
        }
    }
}
// 等同于while
for i < 100{  
}
//死循环
for{
}

表达式不需要（）， { 不能单独放在一行, 编译报错 ，代码行之间不需要分号也不能用分号