GoLang

GoLang从小白到大牛基础必备（更新中）

一、基础语法

1.1注释

golang语法注释和java类似。//为单行注释，多行注释以/*开头 */结尾

• goland开发工具中，注释快捷键为 “ctrl+/” 以及 “ctrl+shift+/”

package main

import "fmt"

func main() {
	fmt.Println("HolleWord!") //在终端打印
    /*
    这是一个多行注释
    */
}

1.2变量

package main

func main(){
    //（1）声明一个变量，语法格式：var 变量名 变量类型
    var age int
    age = 22 //为变量赋值
    
    //（2）声明并赋值,语法格式：var 变量名 [变量类型] = 值
    var name string = "swl" 
    
    //（3）声明并赋值简单写法
    name1 := "rzk"  //这种方式在全局变量中，不能使用
    
    //(4)声明多个变量
    var(
    	a int 		 //0
        b string	 //""
        c bool		//false
    )
        
    //（5）一行中声明多个变量，并赋值
    var a,b = 23,"name"
}

• go在为变量声明空间时，变量会有默认值，如案例4

1.3值拷贝

package main

func main（）{
    var x = 10
    var y = x
    x = 20
    fmt.println(x)
    fmt.println(y)
}

• 结果是20，10

1.4 分隔符

//在go语言中以";"和 换行符 作为语句分隔符
var a = 1;var b = 10
//一般推荐使用换行符作为分隔符使用
var a = 1
var b = 10

1.5基本数据类型

基本数据类型包含整形、浮点型、布尔型以及字符串；

数据类型转换

（1）整型之间类型转换 int8、int16、int32

var int8 x = 10
var int16 y = 20
fmt.println(x+int8(y))

（2）字符串和整型之间的转换（strconv）

var ageStr = "32"		//string类型
var age,err = strconv.Atoi(ageStr)
fmt.println(age + 1)

Atoi：将字符串转整型

Itoa：将整型转字符串

（3）Parse系列函数

	/*
	将字符串转为整型（ParseInt），语法格式：strconv.ParseInt("字符"，进制位，整数范围)
    1.数字的字符串形式 		2.base,数字字符串的进制，比如：2进制、10进制 	
    3.bitSize的含义是⼤⼩限制，如果字符串转化的整形数据类型超过bitSize的最大值
    */
    i1, _ := strconv.ParseInt("1000", 10, 8)	//超出范围
    println(i1)
    i2, _ := strconv.ParseInt("1000", 10, 64)	//在范围内
    println(i2)
	
	//将字符串转为Float类型（ParseFloat）,语法格式：strconv.ParseFloat("",精度)
    f2, _ := strconv.ParseFloat("3.1415926", 64)	//双精度
    fmt.Println(f2, reflect.TypeOf(f2))
    f1, _ := strconv.ParseFloat("3.1415926", 32)	//单精度 
    fmt.Println(f1, reflect.TypeOf(f1))

    // 返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。
    b1, _ := strconv.ParseBool("true")
    fmt.Println(b1, reflect.TypeOf(b1))		//reflect.TypeOf 查看转换后的数据类型
    b2, _ := strconv.ParseBool("T")
    fmt.Println(b2, reflect.TypeOf(b2))
    b3, _ := strconv.ParseBool("1")
    fmt.Println(b3, reflect.TypeOf(b3))
    b4, _ := strconv.ParseBool("100")
    fmt.Println(b4, reflect.TypeOf(b4))
	//方式二
	a1,err := strconv.ParseBool("0")
	if err != nil {
    	fmt.println("err",err)
	}
	fmt.println("a1",a1)

string字符串

索引和切片

索引从0开始计数

go语言中没有负索引

var s string //默认""
s = "hello yuan"	
//索引		字符串[索引]
fmt.println(string(s[1]))		//获取字符e
//切片		字符串[start:end]
fmt.println(s[0:5])				//取数范围是左闭右开要往右再取一位
fmt.println(s[6:])

拼接

a = "holle"
b = "word"
//拼接
fmt.println(a + b)

多行文本输出

info := `
	第一行：
	第二行：
	...
`
fmt.println(info)

strings包

方法	介绍
len(str)	求长度
strings.ToUpper,strings.ToLower	生成一个新的全部大写的字符串,生成一个新的全部小写的字符串
strings.ReplaceAll	生成一个新的原字符串被指定替换后的字符串
strings.Contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Trim、	去除字符串两端匹配的内容
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Split	分割，将字符串按指定的内容分割成数组
strings.Join(a[]string, sep string)	join操作，将数组按指定的内容拼接成字符串

name := "Swl"
//将所有字符转为小写
fmt.println(strings.ToLower(name))
//将所有字符转为大写
fmt.println(strings.ToUpper(name))

s := "Swl Mgt Rzk"
//判断字符串是否以字符开头
fmt.println(strings.HasPrefix(s,"Swl"))
//判断字符串是否包含字符
fmt.println(strings.Cotains(s,"Mgt"))
//判断字符串是否以字符结尾
fmt.println(strings.HasSuffix(s,"Rzk"))

//去除两边指定字符
fmt.println(strings.Trim(s,"k"))
/*
Trim操作还有其他方法：TrimSpace、Trimleft、TrimRight
*/

//索引
fmt.println(strings.Index(s,"k"))		//如果查不到就返回-1

//分割
ns = strings.Split(s," ")	//返回结果为[Swl Mgt Rzk]
fmt.println(ns[0])

//拼接
fmt.println(strings.Join(ns,"-"))	//返回结果为：Swl-Mgt-Rzk

二、运算符、分支、循环

2.1运算符优先级

2.2输入与输出函数

输出语句

//输出语句
	name := "rzk"
	age := 32
	dream := "买特斯拉"

	//输出方式
	fmt.Print(name, age, dream)
	fmt.Print("\n")
	//格式化输出,会直接将结果输出到控制台
	fmt.Printf("姓名%s,年龄%d，梦想是%s", name, age, dream)

	//Sprintf会将结果封装为字符串
	s := fmt.Sprintf("姓名%s,年龄%d，梦想是%s", name, age, dream)
	fmt.println(s)

%v：以默认的方式打印变量的值
%#v：相应值的Go语法表示
%T：打印对应值的类型
%+d ：带符号的整型,%d 不带符号的整型
%o ：不带零的八进制,%#o 带零的八进制
%x ：小写的十六进制，%X 大写的十六进制，%#x 带0x的十六进制
%b ：打印整型的二进制
%t ：打印true 或 false
%s：输出字符串表示，%-5s 最小宽度为5（左对齐）
%f 小数点而无指数，默认精度为6
%e 科学计数法，如-1234.456e+78
%p 带0x的指针，%#p 不带0x的指针

输入语句

//输入函数
var name string
fmt.Scan(&name)		//必须要加 & 取位符，需要传入地址
fmt.println(name)

//格式化输入函数		Scanf
var a,b int
fmt.println("请按格式化输入")
fmt.Scanf("%d+%d", &a, &b)
fmt.Println(a + b)

Sanln ：用户一旦换行换行，输入即结束

测试用例

	//将用户输入xx-xx-xx，转换为xx年-xx月-xx日
	fmt.Println("请输入您的生日，按照年-月-日格式")
	var birth string
	fmt.Scan(&birth)
	birthSlice := strings.Split(birth, "-")
	fmt.Printf("您的生日为：%s年-%s月-%s日", birthSlice[0], birthSlice[1], birthSlice[2])
	

	//输入一个英文名，判断是不是以 a和A 开头
	fmt.Println("请输入您的英文名")
	var name string
	fmt.Scan(&name)
	var b = strings.HasPrefix(name, "a") || strings.HasPrefix(name, "A")
	fmt.Println(b)

2.3流程控制语句

分支语句

//单分支语句  if
var name = "rzk"
if name == "rzk"{		//go语言判断条件不用加括号
    //判定条件为真
    fmt.println("条件成立")
}

//双分支语句		if-else
var age int
fmt.println("请输入您的年龄")
fmt.Scan(&age)
if age < 18 {
    fmt.println("对不起，您不能观看该类型影视作品")
} else {
    fmt.println("请控制观看时长")
}

switch多分支语句

switch var {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

switch和if-else的区别：

switch基于跳转表完成哈希定位，牺牲空间提升了速度；类似字典目录

1、switch比if else更为简洁

2、执行效率更高。switch…case会生成一个跳转表来指示实际的case分支的地址，而这个跳转表的索引号与switch变量的值是相等的。从而，switch…case不用像if…else那样遍历条件分支直到命中条件，而只需访问对应索引号的表项从而到达定位分支的目的。

3、到底使用哪一个选择语句，代码环境有关，如果是范围取值，则使用if else语句更为快捷；如果是确定取值，则使用switch是更优方案。

分支嵌套

	//星座问题		另一种方式可以通过将日期改为folat类型进行范围比较
	var month, day int
    fmt.Print("请输入生日的月和日：")
    fmt.Scan(&month, &day)

    var xingZuo string

    if day < 1 || day > 31 {
        fmt.Println("输入的日有问题")
        os.Exit(0)
    }

    switch month {
    case 1:
        // 日判断
        if day >= 1 && day <= 19 {
            xingZuo = "摩羯座"
        } else {
            xingZuo = "水瓶座"
        }

    case 2:
        // 日判断
        if day >= 1 && day <= 18 {
            xingZuo = "水瓶座"
        } else {
            xingZuo = "双鱼座"
        }
    case 3:
        // 日判断
        if day >= 1 && day <= 20 {
            xingZuo = "双鱼座"
        } else {
            xingZuo = "白羊座"
        }
    case 4:
        // 日判断
        if day >= 1 && day <= 19 {
            xingZuo = "白羊座"
        } else {
            xingZuo = "金牛座"
        }
    case 5:
        // 日判断
        if day >= 1 && day <= 20 {
            xingZuo = "金牛座"
        } else {
            xingZuo = "双子座"
        }
    case 6:
        // 日判断
        if day >= 1 && day <= 21 {
            xingZuo = "双子座"
        } else {
            xingZuo = "巨蟹座"
        }
    case 7:
        // 日判断
        if day >= 1 && day <= 22 {
            xingZuo = "巨蟹座"
        } else {
            xingZuo = "狮子座"
        }
    case 8:
        // 日判断
        if day >= 1 && day <= 22 {
            xingZuo = "狮子座"
        } else {
            xingZuo = "处女座"
        }
    case 9:
        // 日判断
        if day >= 1 && day <= 22 {
            xingZuo = "处女座"
        } else {
            xingZuo = "天秤座"
        }
    case 10:
        // 日判断
        if day >= 1 && day <= 23 {
            xingZuo = "天秤座"
        } else {
            xingZuo = "天蝎座"
        }
    case 11:
        // 日判断
        if day >= 1 && day <= 22 {
            xingZuo = "天蝎座"
        } else {
            xingZuo = "射手座"
        }
    case 12:
        // 日判断
        if day >= 1 && day <= 21 {
            xingZuo = "射手座"
        } else {
            xingZuo = "摩羯座"
        }
    default:
        fmt.Println("输入的月份有问题")
    }

    fmt.Println("您的星座是：", xingZuo)

2.4循环

for 初始化语句;判断条件;步进语句 { 
    // 循环体语句
}

• init： 初始化语句,一般为赋值表达式，给控制变量赋初值;
• condition：条件判断，一般是关系表达式或逻辑表达式，循环控制条件;
• post： 步进语句，一般为赋值表达式，给控制变量增量或减量。

for i := 1; i < 10; i++ {
        fmt.Println(i)
    }

如果想提前结束循环（在不满足结束条件的情况下结束循环），可以使用break或continue关键字。

• break 用来跳出整个循环语句，也就是跳出所有的循环次数；
• continue 用来跳出当次循环，也就是跳过当前的一次循环。

三、指针、数组、切片