golang语言学习笔记_1.1.1.1.1

键输入语句

1.1.1.1.1. 步骤：

1. 引入“fmt”包
2. 调用fmt包中的fmt.Scanln()或者fmt.Scanf(){按照格式输入}
   案例：从键盘中输入姓名、年龄、薪水、是否通过考试
   代码：

func main(){  
    var name string 
    var age int 
    var salary float64
    var isPass bool
    //1. 用fmt.Scanln()输入
    fmt.Scanln(&name)
    fmt.Scanln(&age)
    fmt.Scanln(&salary)
    fmt.Scanln(&isPass)
    //2.第二种方式：fmt.Scanf()
    fmt.Scanf("%s %d %f %t ",&name,&age,&salary,&isPass)
}//必须按照格式 + 顺序输入
   //两种方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14

进制

1. golang中不能使用二进制表示一个整数
2. golang中可以使用一个八进制表示一个数，但是要以 0 开头
3. golang中可以使用一个十六进制表示一个数，但是要以 0x 开头
4. 进制之间的转换，“权位法"(其他的进制转为十进制)
5. 十进制->其他进制：
   用十进制数除以2.8.16直到商为零，然后将余数倒过来

位运算

1.1.1.1.1. 二进制（Binary）：在计算机内部运算时用的是二进制

有符号：

• 二进制最高位数表示的是符号位
• 正数的反码、补码与原码相同
• 负数反码：符号位不变，其他的取相反
• 负数补码等于=反码+1
• 计算机运算时，用的都是数补码的形式进行的
  “&”两个全为1->1 or否则为 0
  “|”两个全为0 - >0 or否则为 1
  “^”异或，不相同为1，相同为 0

程序流程控制

1.1.1.1.1. 顺序结构

从上到下，没有任何的判断和跳转

1.1.1.1.2. 分支控制

有选择的执行：1）单分支 2）双分支 3）多分支
1）单分支：

if 条件判断 {
    执行代码块
}
1
2
3

2）双分支 ：
一般语法：

if 条件判断 {
    执行语句1
}else {
    执行语句2
}//双分支值会执行一个执行语句
1
2
3
4
5

3）多分支 ：
语句 ：

if 条件判断 {
      执1
}else if 条件判断 {
    执2
}else if 条件判断 {
    执3
}····else{
    执n
}
1
2
3
4
5
6
7
8
9

1.1.1.2. 嵌套分支架结构

在分支结构中有一个完整的分支结构

1.1.1.3. switch分支

基本介绍：

1. switch语句用于基于不同条件执行不同的动作，每一个case分支都是唯一的，从上到下，逐一测试，知道匹配为止
2. 匹配后不用加break（在golang中默认有break）
   基本语法：

switch 表达式 {
 case 表1，表2：
        语句块
 case 表3，表4：
        语句块
 ···
 default ：
        语句块   
}
1
2
3
4
5
6
7
8
9

1.1.1.3.1. switch注意事项：

1. golang中的case后的表达式可以有多个，但是要使用逗号隔开
2. golang中switch后不加break，因为默认加了
   细节讨论：

1.case后的表达式可以是常量、变量(一切有返回值的都可)甚至 可以是运算
2.case后表达式的数据类型要是和switch后的表达式相同
3.golang中，case后可以接多个表达式，用逗号隔开
4.case后假如是常量或者字面值，则要求不能重复（变量可以重复）
5.default是非必要的
6.switch（case）后面的表示式可以表达范围就是类似于if-else中的条件判断
7.switch后也可以直接定义一个变量直接分号结束（不推荐）
8."fallthrough"穿透一层，直接执行，不匹配
1
2
3
4
5
6
7
8

1.1.1.3.2. for循环控制：

基本介绍：
控制一段代码循环的执行
ex01：

for i:=1;i<=10;i++ {
    fmt.Println("hello world!")
}//输出9行“hello world！”
1
2
3

基本语法：

for 循环变量的出示换1；循环条件2；循环变量的矢代3 {
     循环操作4
}
1
2
3

4个要素：1/2/3/4
for循环的顺序说明：
1->2->4->3->2->3->4·······
直到2位false
for注意事项：

1. 循环条件返回的是一个bool值，不是true就是false
2. 也可以写成一下形式：

j := 1
for j<=10 {
    fmt.Println("hello world !")
    j++
}
//同ex01
1
2
3
4
5
6

字符遍历：
1>传统的方法：

str := "hello world !"
for i:= 0;i<len(str);i++{
    fmt.Printf("%c \n",str[i])
}//传统方法是按一个字节来的假如有中文会出现乱码现象，字节遍历
2>for—range类型
str :="ok~ok"
for index ,val :=range str{
    fmt.Printf("index = %d val = %c \n",index,val)
}//可以出现中文，字符遍历，有中文相同
1
2
3
4
5
6
7
8
9

1.1.1.3.3. while和do····while的实现

while：

for {
    if 循环条件 {
    break
    }
    循环操作语句
    循环操作矢代
}
1
2
3
4
5
6
7

do····while：

for {
    循环语句
    循环变量矢代
    if 条件 {
        break
    }
}
1
2
3
4
5
6
7

1.1.1.3.4. break：

break：终止，跳出for循环语句或者switch语句

1.1.1.3.5. 细节加注意事项：

1. break语句出现在多嵌套中，可以通过标签指明终止跳出哪一层，一般break会跳出最近的for循环
   举例：

lable2：
for j := 0;j <4 ;j++{
    if j==2 {
        break lable2
    }
    fmt.Println("j = ",j)
}//break后面接一个标签，跳出的就是相应的for循环
1
2
3
4
5
6
7

1.1.1.4. goto:

1. 无条件的转移到制定的行
2. 一般不推荐因为很容易造成程序混乱
3. 基本语法：
   goto: lable01
   label01:

1.1.1.5. return 说明

使用在方法或者函数中表示跳出所在方法或者函数
说明：
return普通函数->跳出函数，不在执行函数中的return后的代码；
如果出现在main中，则就表示瑞出程序，终止程序

函数

1.1.1.1. 基本语法：

func 函数名(形参列表)返回值列表 {
        `执行语句`
        return 返回值列表（不用加括号）
}
1
2
3
4

注意：

1. 返回值列表假如有一个可以不写，有多个必须要写（如果执行语句里面有多个return也要写一个）
2. 形参的形式是先写标识符再写数据类型
3. 函数的语句：为了实现某一目的的语句
4. 函数可以有返回值也可以没有返回值

1.1.1.2. 包的概念

在main.go中调用utils.go文件
包的本质就是创造不同的文件夹，并存放程序文件
包的三大作用：

1. 区别相同名字的函数，变量等标识符
2. 当程序文件很多时，可以很好的管理项目
3. 控制函数、变量、等访问范围，即作用域

1.1.1.3. 递归函数

在函数本身的函数执行语句有本身的函数

• 执行一个函数时，就创建一个新的受保护的独立空间
• 函数局部变量是独立的，不会相互影响
• 递归必须向退出的条件逼近，否则会无线递归
• 执行完毕或者遇到return，该函数本身会被系统销毁空间

1.1.1.3.1. 函数注意点：

1. 基本数据类型和数组都是值传递，即值拷贝，在函数内修改，不会影响原来的值

2. 如果希望函数内的变量能够修改函数外外的变量，可以传入变量的地址

3. golang与语言不支持函数重载
   小案例：（2. ）

func test (n *int) int{
    *n = *n + 10
    return *n 
}
func main(){  
    var num = 20
    fmt.Printf("num = %d",test(&num))//形参是指针，传的就是地址
    //这样函数内的变量就改变了函数外的变量
}
1
2
3
4
5
6
7
8
9

4. 在golang中，函数同样也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的标量了，通过变量可以对函数调用
   ex：

func getSum (a int ,b int) int{
    return a + b
}
func main(){  
    sum := getSum
    res := sum(10 , 20)
    fmt.Println(res)//等价于fmt.Println(getSum(10 , 20))
}
1
2
3
4
5
6
7
8

5. 利用标识符“_”,可以忽略返回值

6. Go支持课变参数

//支持0~多个参数
func sum (arges... int)sum int{
}
//支持1~多个参数
func sum(n int,arges... int) int {
}
//案例说明：
func sum(n int,arges... int) int {
    sum ：= n
    for i := 0;i <len(arges);i++{
        sum += arges[i]
    }
//这是一个累加器
}
func main(){  
    res := sum(10 , 20 ,30 ,50····)//会等于形参的和
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17