😉P02 Go 快速上手😉

1 概要

• 初识包管理：知道项目中文件和文件、文件和文件夹之间的关系
• 输出：编码后在Go编译器运行时会在屏幕显示内容
• 初识数据类型
  • 字符串类型，文本，例如：“苹果”、“Apple”
  • 整型，数字，例如：1、2、3、4
  • 布尔类型，真假，例如：1 > 2是假的
• 变量&常量：当作是昵称
• 输入：让用户输入的内容
• 条件语句：开发一个猜数字的游戏，用户输入的数字与程序中定义好的数字进行比较

2 初识包管理

"""
关于包管理的总结
1、一个文件夹可以称之为一个包
2、在文件夹（包）中可以创建多个文件
3、在同一个包下的所有文件，必须指定包的名称，并且包名称是相同的

重点：关于包的分类
1、main包。如果是main包，则必须写一个main函数，此函数就是项目的入口（main主函数）。编译生成的是一个可执行文件
2、非main包，用来将代码分类
"""

3 输出

在终端将想要展示的数据显示出来，例如：欢迎登录、请输入用户名等。。。

• 内置函数（Golang官方说可能会在以后的版本中删除）
  • println
  • print
• fmt包（推荐）
  • fmt.Println
  • fmt.Print

扩展：进程里有stdin、stdout、stderr

"""
package main

import "fmt"

func main() {
    // 基于内置函数（不推荐）
    //print("Hello Golang
")
    //println("Hello Golang")

    // fmt包（推荐）
    //fmt.Print("Hello Golang
")
    //fmt.Println("Hello Golang")
    //fmt.Println("Hello", "Golang")

    // fmt包扩展：格式化输出
    fmt.Printf("%s你好，我喜欢%s。我%d岁了，身高%.2f，包你%d%%满意", "Golang", "Python", 18, 180.889, 100)
}
"""

4 注释

• 单行注释：//
• 多行注释：/**/
• 快捷键：ctrl（command） + /

5 初始数据类型

• 字符串类型，文本
• 整型，数字
• 布尔类型，真假

"""
package main

import "fmt"

func main() {
    // 整型
    fmt.Println(666)
    fmt.Println(16 + 9)
    fmt.Println(16 - 9)
    fmt.Println(16 * 9)
    fmt.Println(16 / 9) // 商
    fmt.Println(16 % 9) // 余

    // 字符串类型，特点：通过双引号引起来
    fmt.Println("Nagase Ren")
    fmt.Println("世界你好，别来无恙。")
    fmt.Println("于极迷处识迷，" + "则处处醒。")

    // 对比
    fmt.Println("1" + "2") // 结果："12"
    fmt.Println(1 + 2)     // 结果：3

    // 布尔类型，真假
    fmt.Println(1 > 2) // false
    fmt.Println(1 < 2) // true

    // 超前
    if 2 > 1 {
        fmt.Println("Bingo")
    } else {
        fmt.Println("you are fired")
    }
}

"""

 6 变量

变量可以理解为是一个“昵称”

6.1 声明变量的意义

• 方便省事，可以重复利用

// 文本，请将文本输出3次："于极迷处识迷，则处处醒；将难放怀一放，则万境宽。"
//var msg string = "于极迷处识迷，则处处醒；将难放怀一放，则万境宽。"
//fmt.Println(msg)
//fmt.Println(msg)
//fmt.Println(msg)

• 用于保存数据

// 存储数据
var v1 int = 99
var v2 int = 33
var v3 int = v1 + v2
var v4 int = v1 * v2
var v5 int = v1 + v2 + v3 + v4
fmt.Println(v1, v2, v3, v4, v5)

• 用于存储用户输入的数据

var name string

fmt.Scanf("%s", &name) // 用户输入字符串并赋值给name变量

if name == "samuel" {
    fmt.Println("用户名输入正确")
} else {
    fmt.Println("用户名输入错误")
}

6.2 变量名命名规范

• 【要求】变量名只能包含数字、字母和下划线

var %1 string 错误
var $ string 错误

• 【要求】变量名不可以以数字开头

var 1 string 错误
var 1name string 错误
var _ string 正确

• 【要求】变量名不可以是Go语言的内置关键字

var var string = "beijing" 错误

• Go语言内置的25个关键字

// 25个Go关键字
break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、return、var

• 变量名命名建议
  • 名字要见名知意，例如：name、age、gender
  • 使用驼峰式命名法，例如：userName、userPassword

6.3 变量的简写

• 声明 + 赋值

var name string = "Nagase"

var name = "Samuel"

name := "Matthew" // 推荐使用这种简写方式 

• 先声明后赋值

var name string
var addr string
var data string

var name addr data string

name = "Nagase"
addr = "xxx"
data = "xxx"

• 因式分解，声明5个不同数据类型的变量

var (
    name = "Nagase"
    age = 18
    hobby = "coding"
    salary = 15000
    gender string // 只声明但不赋值，有一个默认值：“”
    length int // 只声明但不赋值，有一个默认值：0
    flag bool // 只声明但不赋值，有一个默认值：false
)

6.4 变量的作用域

如果我们定义了一个大括号，在大括号里边定义的变量，则：

• 不可以被上一个层级调用
• 可以在同一个层级调用
• 可以被子层级调用

package main

import "fmt"

func main() {

    name := "nagase"
    fmt.Println(name)

    if true {
        age := 22
        name := "samuel"
        fmt.Println(age)
        fmt.Println(name)
    }

    fmt.Println(name)
}

全局变量和局部变量

• 全局变量，未写在函数中的变量称之为全局变量，并且不可以使用简写v1 := xx的方式定义变量，但是可以使用因式分解的方式
• 局部变量，编写在大括号{}内的变量称之为局部变量，可以使用简写方式定义，也可以使用因式分解的方式

package main

import "fmt"

// 全局变量（不能使用简写方式定义变量了）
//name := "全局变量" // 不可以
var variable = "全局变量" // 可以
//var variable string = "全局变量" // 可以

var (
    v1 int = 123
    v2 string = "hello"
    v3 int
)

6.5 变量的赋值以及内存相关

name := "Samuel"

变量在内存中的存储情况：

name := "Samuel"
nickName := "Samuel"

变量在内存中的存储情况：

那么从图中我们可以看出来，这一点与Python不同，Python而是将nickName指向name所指向的内存地址，而不是复制一份出来

name := "Samuel"
nickName := name

fmt.Println(name, &name)
fmt.Println(nickName, &nickName)

那么如果当我们修改了之前变量的值呢？会怎么样？如下：

name := "Samuel"
nickName := name

fmt.Println(name, &name)
fmt.Println(nickName, &nickName)

name = "Nagase"
fmt.Println(name, &name)
fmt.Println(nickName, &nickName)

结论：如果修改了之前的变量值，则会直接擦出原值，附上一个新值，定义的nickName不会受到影响

6.6 注意事项

使用int、string、bool这三种数据类型时，如果遇到变量赋值，则会重新copy一份【值类型】

类似于这样：

name := "samuel"

nickName := name

7 常量

概念：不可以被修改的变量称之为常量

package main

import "fmt"

func main() {
  // 定义变量
  //var name string = "Samuel"
  //var name = "Samuel"
  name := "Samuel"
  name = "nagase"
  fmt.Println(name)
  
  // 定义常量
  //const age int = 98
  const age = 98
  fmt.Println(age)
}

7.1 常量因式分解

package main

import "fmt"

func main() {
  // 常量因式分解
  const (
    c1 = 123
    c2 = 456
    pi = 3.1415926
  )
  fmt.Println(c1, c2, pi)
}

7.2 在全局作用域定义常量

package main

import "fmt"

const data = 999
const (
    pi = 3.1415926
  gender = "male"
)

func main() {
  ...
}

7.3 iota

iota就类似于一个在声明常量时候的计数器，用于生成连续的从0开始的数字

// 示例1
    //const (
    //    c1 = 1
    //    c2 = 2
    //    c3 = 3
    //    c4 = 4
    //    c5 = 5
    //)

    // 示例2
    //const (
    //    c1 = iota + 1
    //    c2
    //    c3
    //    c4
    //    c5
    //)
    //fmt.Println(c1, c2, c3, c4, c5) 最终结果就是12345

    // 示例3
    const (
        c1 = iota + 2 // c1 = 2
        _ // _ = 3，如果不想要显示3，则可以使用_来命名
        c2 // c2 = 4
        c3 // c3 = 5
        c4 // c4 = 6
        c5 // c5 = 7
    )
    fmt.Println(c1, c2, c3, c4, c5) 最终结果就是 24567

8 输入

让用户输入数据，完成项目的交互，有三种输入方式，分别是：

• fmt.Scan
• fmt.Scanln(推荐✅)
• fmt.Scanf

package main

import "fmt"

func main() {
    // 示例1 fmt.Scan
    //var name string
    //fmt.Println("请输入用户名：")
    //fmt.Scan(&name)
    //fmt.Println(name)

    // 示例2 fmt.Scan
    var name string
    var age int

    fmt.Println("请输入用户名和年龄（使用空格分开）：")
    // 当使用Scan的时候，会提示用户输入
    // 用户输入完之后会得到两个值，分别是：count，用户输入了几个值；err，用户输入错误，err里就包含了错误信息
    _, err := fmt.Scan(&name, &age) // 如果定义的变量实在是不想用，那就使用_来命名，那样的话就不会报错了。
    if err == nil {
        fmt.Println(name, age)
    } else {
        fmt.Println("用户输入错误，错误信息：", err)
    }

    // 特别说明：fmt.Scan要求输入2两个值，那就必须输入2个，否则就会一直等待

}

Scan和Scanln的区别：Scan是一直等待用户输入完整的信息才会结束，而Scanln是只要接收到了回车就会结束

package main

import "fmt"

func main() {
    // 示例1 fmt.Scan
    //var name string
    //fmt.Print("请输入用户名：")
    //fmt.Scanln(&name)
    //fmt.Printf(name)

    // 示例2 fmt.Scan
    var name string
    var age int

    fmt.Print("请输入用户名和年龄（使用空格分开）：")
    // 当使用Scan的时候，会提示用户输入
    // 用户输入完之后会得到两个值，分别是：count，用户输入了几个值；err，用户输入错误，err里就包含了错误信息
    count, err := fmt.Scanln(&name, &age) // 如果定义的变量实在是不想用，那就使用_来命名，那样的话就不会报错了。
    fmt.Println(count, err)
    fmt.Println(name, age)

    // 特别说明：fmt.Scan要求输入2两个值，那就必须输入2个，否则就会一直等待用户输入，回车也不管用。
    // fmt.Scanln只是等待回车，只要回车就代表输入完成了

}

Scanf如下：

package main

import "fmt"

func main() {
    var name string
    var age int

    fmt.Printf("请输入用户名：")
    count, err := fmt.Scanf("我叫%s 今年%d 岁", &name, &age) // 必须用空格隔开，否则会将后边所有的字符全都认为是名字

    fmt.Printf("用户输入的用户名是：%s，数量：%d，错误信息：%s", name, count, err)

}

无法解决的难题？？？如果输入的信息有空格，则不输出，如图所示：

解决办法如下：使用系统的io

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    reader := bufio.NewReader(os.Stdin)
    // line从stdin中读取一行的数据（字节集合 -> 转换成字符串）
    // reader默认一次读取4096个字节（4096 / 3个汉字）
    // 如果一次性读取完了，isPrefix = false
    // 先读取一部分，isPrefix = true，再次读取，如果读完了，isPrefix = false，否则还是true
    line, _, _ := reader.ReadLine()
    data := string(line)
    fmt.Println(data)
}

9 条件语句

9.1 最基本的条件语句

if 条件 {
  成立后，此代码块执行
} else {
  不成立后，此代码块执行
}

9.2 多条件判断

if 条件A {
  ...
} else if 条件B {
  ...
} else if 条件C {
  ...
} else {
  ...
}

9.3 if else的嵌套

if 条件A {
   if 条件B {
      ...
   } else {
      ...
   }
} else {
    ...  
}

建议：嵌套的层数不要太多，否则的话将会面临着被公司开除的风险。