Go语言学习笔记

目录

Go语言变量定义：

1.使用语法糖var：

2.使用 " 变量名称 := 值 " 

3.变量组定义

4.全局变量和局部变量

5.变量定义未赋值会有默认值

6.定义常量

7.Go的数据类型：

数据的类型转换：

字符串和数值之间的转换：

1.数值转字符串：

2.字符串转化为数值类型：

输入和输出：

Go语言fmt包实现了类似C语言printf和scanf的格式化I/O

#输出函数

#输入函数

运算符：

算数运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

其它运算符

Go语言的流程控制 ：

选择结构 If

选择结构switch

循环结构for 

跳转语句：

break语句

continue语句

go to 和 return 语句

---

• Go语言变量定义：

1.使用语法糖var：

var a int //先定义后初始化
a = 10

var b int = 10 //定义同时初始化

var c = 10 //定义变量同时赋值，并省略变量的数据类型

var a1, b1, c1 = 10, 10, 10 //同时定义多个变量

2.使用 " 变量名称 := 值 " 

a := 10 //定义变量a并赋值

a, b := 10, 10 //连续定义多个变量

3.变量组定义

//变量组同时定义不同类型的变量
var(
    a=1
    b=1.1
)
//变量组同时定义多个不同类型变量
var(
    a, b = 1, 2
    c, d = 1.1, 2.2
)

4.全局变量和局部变量

package main

import "fmt"

//全局变量
var a int
var b int //作用域不同，可以存在同名变量

func main() {
    var a int //局部变量
}

5.变量定义未赋值会有默认值

6.定义常量

const + 常量名称 + 类型 = 值  或者 const + 常量名称 = 值

const A int = 1
const b = 1

常量组：

const (
    num1 = 100
    num2         //若没有赋值则默认和上一个值一样，这里是100
    num3 = 200
    num4         //200
    num5         //200
}

Go没有明确的枚举类型enum，但可以通过常量组和iota标识符实现

const (
    a = iota //首次出现iota，这里从0开始递增
    b        // 1
    c        // 2
    d = 100  //iota被中断
    e        //与上一行的值相同 100
    f = iota //iota恢复 3
    g        //4
)

7.Go的数据类型：

---

• 数据的类型转换：

格式： 数据类型（需要转换的数据）

package main

import "fmt"

func main() {
    var a int = 10
    var b int32
    b= int32(a)//数据转换
}

字符串和数值之间的转换：

1.数值转字符串：

通过 strconv.Formatxxx(num1,num2)  来进行转换

num1为int64类型的数值      num2为需要转换的进制

var a int = 10
//第一个参数为int64类型的数值，第二个参数为转化的进制

//转化为内容十进制表示的字符串
var a_2 string = strconv.FormatInt(int64(a),2) // a_2="1010"

//转化为内容二进制表示的字符串
var a_10 string = strconv.FormatInt(int64(a),10) // a_10="10"

2.字符串转化为数值类型：

通过 strconv.ParseInt(str, num1, num2)

str:需要转换的字符串

num1：转换的进制

num2：转化为多少位的整形

注意：函数会有两个返回值，第一个返回的是转化的结果，第二个返回的是错误

假如转换的数值超出了指定的范围或者不能被转换时，错误为nil，否则错误不为nil

var str string = "10"

num, err := strconv.ParseInt(str, 10, 8) //将str转化为十进制数据类型为int8的整数

if err != nil {
    fmt.Print(num)
}

---

• 输入和输出：

Go语言fmt包实现了类似C语言printf和scanf的格式化I/O

#输出函数

可以使用Print  Printf  Println   等等

package main

import "fmt"

func main() {
    var a int =10
    var b float32 =1.1
    var str string = "str"
    //格式化输出
    fmt.Printf("a=%d\nb=%f\nstr=%s\n", a, b, str)
    //新增%T控制符，用于输出值的类型
    fmt.Printf("a=%T\nb=%T\nstr=%T\n", a, b, str)
}

#输入函数

可以使用Scan、Scanf、Scanln

package main

import "fmt"

func main() {
    var a int
    var b float32
    //使用Scanf
    fmt.Scanf("%d%f", &a, &b)
    fmt.Printf("a=%d   b=%f\n", a, b)
    //使用Scan不用说明是什么类型
    fmt.Scan(&a, &b)
    fmt.Printf("a=%d   b=%f\n", a, b)
}

---

• 运算符：

• 算数运算符

Go语言的算数运算符与C语言的几乎一致 

其中需要值得注意的是：

1. 自增和自减运算符没有前置的，只有a++和a--是合法的
2. 只有相同类型的数据才可以进行运算
3. 字符串支持使用 +号 进行拼接

• 关系运算符

Go的关系运算符与C语言一致 

需要注意的是：和C语言不通的是, Go语言中关系运算符只能返回true和false

• 逻辑运算符

Go的逻辑运算符与C语言一致

 需要注意的是：

和C语言不同的是, Go语言中关系运算符只能返回true和false

逻辑非 ！只能用于true和false

• 位运算符

位运算符与C语言几乎一样，新增了一个&^运算符

• 赋值运算符

赋值运算符与C语言几乎一样，新增了一个&^=的赋值运算符

• 其它运算符

---

• Go语言的流程控制 ：

1. 顺序结构
2. 选择结构（ if  and switch ）
3. 循环结构（for）

• 选择结构 If

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200
	/* 判断条件 */
	if a == 100 {
		/* if 条件语句为 true 执行 */
		if b == 200 {
			/* if 条件语句为 true 执行 */
			fmt.Printf("a 的值为 100 ， b 的值为 200\n")
		}
	}

    //if else 结构
    //if 初始化语句;条件表达式  
    if age := 18; age >= 18{
        fmt.Println("他/她是成年人")
    }else{
        fmt.Println("他/她是未成年人")
    }

    //if else if else 结构
    if score := 88; score >= 90{
        fmt.Println("成绩为A")
    }else if score >= 80{
        fmt.Println("成绩为B")
    }else{
        fmt.Println("成绩为C")
    }

}

• 选择结构switch

package main

import "fmt"

func main() {
    switch grade := 2; grade{
        case 1:
            fmt.Println("高一")
        case 2:
            fmt.Println("高二")
        case 3:
            fmt.Println("高三")
        default:
            fmt.Println("毕业了")
    }


    //switch 语句不仅可以放常量还可以放变量和表达式
    switch num := 5; {
        case num >=0 && num <= 10:
            fmt.Println("num是一个小于等于10的正整数")
        case num > 10 && num <= 20:
            fmt.Println("num是一个大于10小于20的正整数")
        default :
            fmt.Println("num是一个大于20的正整数")
    }
}

• 循环结构for 

package main

import "fmt"

func main() {

    //循环输出0-9的所有整数
    for i:=0; i<10; i++{
        fmt.Println(i)
    }
}

 由于Go没有 while 和 do while，我们可以使用for进行模拟：

package main

import "fmt"

func main() {

    //等价于while（i--)
    for i:=10; i>0 ;{
        fmt.Println(i)
        i--
    }
}

• 跳转语句：

和C语言一样,Go语言中也有四大跳转语句,分别是return、break、continue、goto 

• break语句

Go语言中的break语句可以用于,立即跳出switch、for和select

但不同的是Go语言中的break语句可以指定标签

package main

import "fmt"

func main() {
	for i := 10; i > 0; i-- {
		fmt.Println(i)
		if i == 5 {
			break
		}
	}


    //利用break跳转到指定标签
    outer:
        for j := 10; j > 0; j-- {
            fmt.Printf("%d:\n",i)
            for k := 10; k > 0; k-- {
                fmt.Println(k)
                if k == 8 {
                    break outer //跳转到标签之后switch和循环不会再次被执行
                }
            }
        }
    '''
    输出结果：
    10:
    10 
    9  
    8 
    '''
    
}

• continue语句

Go语言中的continue语句可以用于,立即进入下一次循环

但不同的是Go语言中的continue语句可以指定标签

package main

import "main"

func main() {
    
     for i := 0; i < 10; i++ {
        fmt.Println(i)
        if i == 5 {
            continue
        }
    }

    //利用continue跳转到指定标签
    outer:
        for i := 0; i < 10; i++ {
            fmt.Printf("%d:\n",i)
            for j := 0; j < 10; j++ {
                fmt.Println(j)
                if j == 2 {
                    continue outer //对于多层循环,相当于跳到最外层循环继续判断条件执行
                }
            }
        }            
}

• go to 和 return 语句

Go语言中的go to和 return 与C语言中用法一样