字数统计: 2.5k字   |   阅读时长: 10分

Go基础 - 条件，循环，函数，指针

Go语言学习笔记:

第一章：概述

Go语言的特点：

  • 与C99,C11相似之处颇多，它的主要目标是“兼具 Python 等动态语言的开发速度和 C/C++ 等编译型语言的性能与安全性”。
  • 是对类C语言的重大改进，它不但能访问底层操作系统，还提供了强大的网络编程和并发编程支持。Go语言的用途众多，可以进行网络编程、系统编程、并发编程、分布式编程。
  • 旨在不损失应用程序性能的情况下降低代码的复杂性，具有“部署简单、并发性好、语言设计良好、执行性能好”等优势
  • 因为Go语言没有类和继承的概念，所以它和 Java 或 C++ 看起来并不相同。但是它通过接口（interface）的概念来实现多态性。
  • Go是编译型语言，Go自带了编译器，因此无需单独安装编译器。
  • 将一切都并发化，运行时用 Goroutine 运行所有的一切，包括 main.main 入口函数。
  • 静态链接，只需要一个可执行文件，不需要依赖库

多个 goroutine 中，Go语言使用通道（channel）进行通信，通道是一种内置的数据结构，可以让用户在不同的 goroutine 之间同步发送具有类型的消息。这让编程模型更倾向于在 goroutine 之间发送消息，而不是让多个 goroutine 争夺同一个数据的使用权。

Go语言一个并发的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package main

import (
        "fmt"
        "math/rand"
        "time"
)

// 数据生产者
func producer(header string, channel chan<- string) {
     // 无限循环, 不停地生产数据
     for {
            // 将随机数和字符串格式化为字符串发送给通道
            channel <- fmt.Sprintf("%s: %v", header, rand.Int31())
            // 等待1秒
            time.Sleep(time.Second)
        }
}

// 数据消费者
func customer(channel <-chan string) {
     // 不停地获取数据
     for {
            // 从通道中取出数据, 此处会阻塞直到信道中返回数据
            message := <-channel
            // 打印数据
            fmt.Println(message)
        }
}

func main() {
    // 创建一个字符串类型的通道
    channel := make(chan string)
    // 创建producer()函数的并发goroutine,并发执行一个生产者函数，两行分别创建了这个函数搭配不同参数的两个 goroutine。
    go producer("cat", channel)
    go producer("dog", channel)
    // 数据消费函数
    customer(channel)
}

最终就是并行输出cat和dog及其对应的channel数据

从Hello，World开始

1
2
3
4
5
6
7
8
9
10
11
package main //表示文件中所有代码都属于main包

import "fmt"  //fmt包实现了格式化IO函数，类似于C语言中的scanf(),printf()等

func main() {
	fmt.Println("Hello,world")
	fmt.Println("你好,世界")
}
//math.Floor() 向下取整
//strings.Title() 将每个单词的首字母都大写
//reflect.Typeof() 返回参数的类型

Go语言的一些特点：

  1. Go是静态类型的，在程序运行之前就知道值的类型是什么。
  2. Go文件的三个部分：package子句，任何import语句，实际代码；
  3. Go语言不推荐使用分号隔开语句，Go语言格式很标准，缩进和间距都有固定要求
  4. Go语言必须只导入它引用的包，如果导入的有没用到的会自动优化；区分大小写，必须有main函数。
  5. println()函数可以有任意多的参数，参数之间用,分开；如果import包含多个包需要()；

字符串：字符串字面量用 “”包围，字符字面量用 ‘’包围；可以使用小数点来区分小数和整数。

声明变量：var关键词 + 变量名 + 类型，如var quantity int；如果声明时没有赋值，默认为零值；

声明常量：const关键词 + 常量名 + 类型，常量的值必须保持不变；

声明变量并声明的两种方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
var quantity int = 4；
quantity := 4;
//错误的方式
//声明变量a
var a int
//声明变量a并给变量a赋值
a := 1
//错误提示
no new variables on left side of :=
//说明
重复声明变量a
//Go也支持自动推断类型
var a=10 //默认a为整型
1
2
3
4
5
go build //将源代码文件编译为二进制文件
go run //编译并运行程序，不保留可执行文件
go fmt //整理代码格式，重新格式化源文件
go version //显示当前Go版本号

块和变量的作用域：和C++类似，比如一个if内定义的变量在if外就不能使用。

Head First Go：Chapter2的pass_fail案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// pass_fail reports whether a grade is passing or failing.
package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

func main() {
	fmt.Print("Enter a grade: ")
	reader := bufio.NewReader(os.Stdin)   //从键盘获取文本的缓存读取器
	input, err := reader.ReadString('\n') //返回用户输入的所有内容，直到按下ENTER为止
	fmt.Println(input)
	if err != nil { //nil可以暂时先理解为null，但是其实不一样，注意不要用error，error是一个数据类型
		log.Fatal(err)
	}

	input = strings.TrimSpace(input)            //删掉字符串开头和结尾的所有空白字符
	grade, err := strconv.ParseFloat(input, 64) //解析一个浮点数的字符串并返回其值，64指返回的是64位的浮点数，返回float64
	if err != nil {
		log.Fatal(err)
	}

	var status string //注意Go语言的作用域范围，status必须先声明，如果在if循环中声明就不能输出status了
	if grade == 100 {
		status = "Perfect!"
	} else if grade >= 60 {
		status = "Passing!"
	} else {
		status = "Failing!"
	}
	fmt.Println("A grade of", grade, "is", status)
	var languages = append([]string{}, "Espanol") //对string外面加上[];
	fmt.Println(languages)
}

另外一个例子：另外一个例子，猜数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// guess challenges players to guess a random number.
package main

import (
	"bufio"
	"fmt"
	"log"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	seconds := time.Now().Unix()
	rand.Seed(seconds) //必须加上time.now()随机数才能更新
	target := rand.Intn(100) + 1
	fmt.Println("I've chosen a random number between 1 and 100.")
	fmt.Println("Can you guess it?")

	reader := bufio.NewReader(os.Stdin)
	success := false
	for guesses := 0; guesses < 10; guesses++ {
		fmt.Println("You have", 10-guesses, "guesses left.") //Println会自动换行，Print不会
		fmt.Print("Make a guess: ")
		input, err := reader.ReadString('\n')
		if err != nil {
			log.Fatal(err)
		}
		input = strings.TrimSpace(input)
		guess, err := strconv.Atoi(input) //字符串转换为整型
		if err != nil {
			log.Fatal(err)
		}

		if guess < target {
			fmt.Println("Oops. Your guess was LOW.")
		} else if guess > target {
			fmt.Println("Oops. Your guess was HIGH.")
		} else {
			success = true
			fmt.Println("Good job! You guessed it!,you have guessed", guesses+1, "times")
			break
		}
	}

	if !success {
		fmt.Println("Sorry, you didn't guess my number. It was:", target)
	}
}

第三个例子：计算面积

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main

import (
	"fmt"
	"log"
)

func paintNeeded(width float64, height float64) (float64, error) { //后面括号中的float64指的是参数的返回值是float64， error是错误信息
	if width < 0 {
		return 0, fmt.Errorf("a width of %0.2f is invalid", width) //如果需要格式化数字以便在错误信息中使用，可以用fmt.Errorf()函数
	}
	if height < 0 {
		return 0, fmt.Errorf("a height of %0.2f is invalid", height)
	}
	area := width * height
	return area / 10.0, nil
}

func main() {
	amount, err := paintNeeded(5.2, 3.5)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%.2f liters needed\n", amount) //%.2f和%0.2f一样
	amount, err = paintNeeded(4.2, -3.0)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%.2f liters needed\n", amount)
}

函数形参接收实参的副本：

Go语言是一种“值传递”语言，函数形参从函数调用中接收实参的副本，函数中改变的是副本的值，而不是原始的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func main(){
	amount := 6
	double(amount) //这时候输出为12
}
func double(number int){
	number = number * 2
	fmt.Println(number)
} 
/*
func main(){
	amount := 6
	double(amount) 
	fmt.Println(amount) //输出的是6!因为函数只改变了副本number的值
}
func double(number int){
	number = number * 2
} 
*/

为了解决函数保存的值是副本的值这个问题，引入了指针的概念；

Go语言使用&来获取变量的内存地址。

1
2
3
ptr := &v	//假设v的类型为T
v表示被取地址的变量，v的地址用ptr接收，ptr的类型为`*T`,即T的指针类型
val = *ptr //对ptr进行取址操作

用指针可以对上面的例子进行修改：

1
2
3
4
5
6
7
8
9
func main(){
	amount := 6
	double(&amount) 
	fmt.Println(amount) //输出的是6!因为函数只改变了副本number的值
}
func double(number *int){
	*number = *number * 2
} 
//这样就可以通过函数修改变量的值了。
第四讲 代码集

  • 工作区目录包括三个子目录：bin，pkg，src；其中bin保存可执行文件，pkg保存已编译的包代码，src保存源代码，注意src中的每个文件夹最多只能包括一个main函数。

  • Go语言默认的安装包在C盘Program Files/Go/src文件夹中，定义了一些常用库及其函数。

​ 这个安装包的路径可以通过cmd中go env命令查看，Goroot即为安装包的路径。

​ 如果自己新建一个包，需要将这个包放在文件夹中然后放在Goroot的src目录下或者Gopath的src目录下。

  • 将函数名的第一个字母大写，函数就是可导出的，也就是其他的包也能用这个包里的函数。如果函数名的第一个字母小写，它只能在自己的包里使用，其他的包不能使用这个函数。
  • Go语言命名规范：包名应该全部小写，并且尽量保持简洁。
  • 如果导入的数据包有重名的情况，应该注意import的时候将路径写全。
1
2
3
4
go build test.go #go build 命令编译文件,生成一个可执行二进制.exe文件
./test.exe #执行程序，输出结果
go get //可以下载和安装包
go doc //阅读包文档

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

这一定是一个<br><br>很长很长的一生啊