Tag-Go教程 - iStudy

Go教程 2020-03-02 12:30:07 69 0 0

1. 背景
2. slice
- 2.1 内部结构
- 2.2 覆盖前值
3. string
- 3.1 重新分配
- 3.2 二者转换
4. 逃逸分析
5. 版本差异
6. 结论
- 6.1 参考

1. 背景

上周四小伙伴发了Go社区一个帖子下hej8875的回复，如下：

package main
import "fmt"
func main() {
s := []byte("")
s1 := append(s, 'a')
s2 := append(s, 'b')
//fmt.Println(s1, "==========", s2)
fmt.Println(string(s1), "==========", string(s2))
}
// 出现个让我理解不了的现象, 注释时候输出是 b ========== b
// 取消注释输出是 [97] ========== [98] a ========== b

这个回复比原贴有意思，也很有迷惑性。作者测试了下，确实如此，于是和小伙伴们讨论深究下。开始以为应该挺简单的，理解后，发现涉及挺多知识点，值得跟大家分享下过程。

2. slice

2.1 内部结构

先抛去注释的这行代码//fmt.Println(s1, "==========", s2)，后面在讲。当输出 b ========== b时，已经不符合预期结果a和b了。我们知道slice内部并不会存储真实的值，而是对数组片段的引用，其内部结构是:

type slice struct {
    data uintptr
    len int
    cap int
}

其中data是指向数组元素的指针，len是指slice要引用数组中的元素数量。cap是指要引用数组中（从data指向开始计算）剩余的元素数量，这个数量减去len，就是还能向这个slice(数组)添加多少元素，如果超出就会发生数据的复制。slice的示意图：

s := make([]byte, 5)// 下图

s = s[2:4]  //会重新生成新的slice，并赋值给s。与底层数组的引用也发生了改变

2.2 覆盖前值

回到问题上，由此可以推断出：s := []byte("") 这行代码中的s实际引用了一个 byte 的数组。

其capacity 是32，length是 0：

s := []byte("

更多

Google资深工程师深度讲解Go语言视频最新版【百度网盘】

Go教程 2020-02-25 17:39:24 2693 0 0

最新版本的Google资深工程师深度讲解Go语言视频已经更新了，看到网上很多人在找，本人整理了一下最详细的Go语言深度讲解视频百度云分享给大家，内容比较多最好是直接保存，然后用手机在线观看。

Google资深工程师深度讲解Go语言视频

课程目录

第1章课程介绍

第2章基础语法

第3章内建容器

第4章面向“对象”

第5章面向接口

Google资深工程师深度讲解Go语言视频

第6章函数式编程

第7章错误处理和资源管理

第8章测试与性能调优

第9章Goroutine

第10章Channel

第11章http及其他标准库

第12章迷宫的广度优先搜索

第13章开始实战项目

Google资深工程师深度讲解Go语言视频

第14章单任务版爬虫

第15章并发版爬虫

第16章数据存储和展示

第17章分布式爬虫

第18章课程总结

Google资深工程师深度讲解Go语言视频

go语言的优点

原因 1：性能

Go 极其地快。其性能与 Java 或 C++相似。在我们的使用中，Go 一般比 Python 要快 30 倍。

原因 2：语言性能很重要

对很多应用来说，编程语言只是简单充当了其与数据集之间的胶水。语言本身的性能常常无关轻重。

但是 Stream 是一个 API 提供商，服务于世界 500 强以及超过 2 亿的终端用户。数年来我们已经优化了 Cassandra、PostgreSQL、Redis 等等，然而最终抵达了所使用语言的极限。

原因 3：开发者效率&不要过于创新

如果你是一个新手，看到这段代码你并不会感到吃惊。它展示了多种赋值、数据结构、指针、格式化以及内置的 HTTP 库。

当我第一次编程时，我很喜欢使用 Python 的高阶功能。Python 允许你创造性地使用正在编写的代码，比如，你可以：

在代码初始化时，使用 MetaClasses 自行注册类别

置换真假

添加函数到内置函数列表中

通过奇妙的方法重载运算符

毋庸置疑这些代码很有趣，但也使得在读取其他人的工作时，代码变得难以理解。

Go 强迫你坚持打牢基础，这也就为读取任意代码带来了便利，并能很快搞明白当下发生的事情。

原因 4：并发性&通道

Go 作为一门语言致力于使事情简单化。它并未引入很多新概念，而是聚焦于打造一门简单的语言，它使用起来异常快速并且简单。其唯一的创新之处是 goroutines 和通道。Goroutines 是 Go 面向线程的轻量级方法，而通道是 goroutines 之间通信的优先方式。

创建 Goroutines 的成本很低，只需几千个字节的额外内存，正由于此，才使得同时运行数百个甚至数千个 goroutines 成为可能。你可以借助通道实

更多

Go 语言 select 语句

Go Go教程 2019-04-29 13:38:54 17 0 0

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

语法

Go 编程语言中 select 语句的语法如下：

select {
  case communication clause :
statement(s);
  case communication clause :
statement(s);
  /* 你可以定义任意数量的 case */
  default : /* 可选 */
statement(s);
}

以下描述了 select 语句的语法：

每个 case 都必须是一个通信
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
否则：
1. 如果有 default 子句，则执行该语句。
2. 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

实例

select 语句应用演示：

实例

package main

import "fmt"

func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
  case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
  case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
  case i3, ok := (<-c3):  // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\

更多

Go 语言 switch 语句

Go Go教程 2019-04-29 13:38:01 21 0 0

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。

语法

Go 编程语言中 switch 语句的语法如下：

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

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

流程图：

实例

package main

import "fmt"

func main() {
/* 定义局部变量 */
var grade string = "B"
var marks int = 90

switch marks {
  case 90: grade = "A"
  case 80: grade = "B"
  case 50,60,70 : grade = "C"
  default: grade = "D"
}

switch {
  case grade == "A" :
fmt.Printf("优秀!\n" )
  case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
  case grade == "D" :
fmt.Printf("及格\n" )
  case grade == "F":
fmt.Printf("不及格\n" )
  default:
fmt.Printf("差\n" );
}
fmt.Printf("你的等级是

更多

Go 语言 if 语句嵌套

Go Go教程 2019-04-29 13:37:09 25 0 0

你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。

语法

Go 编程语言中 if...else 语句的语法如下：

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

你可以以同样的方式在 if 语句中嵌套 else if...else 语句

实例

嵌套使用 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" );
}
}
fmt.Printf("a 值为 : %d\n", a );
fmt.Printf("b 值为 : %d\n", b );
}

以上代码执行结果为：

a 的值为 100 ， b 的值为 200
a 值为 : 100
b 值为 : 200

-----------------------------

判断用户密码输入：

package main 

import"fmt"

func main(){
    var a int 
    var b int
    fmt.Printf("请输入密码：   \n")
    fmt.Scan(&a)
    if a == 5211314 {
    fmt.Printf("请再次输入密码：")
    fmt.Scan(&b)
        if b == 5211314 {
            fmt.Printf("密码正确，门锁已打开")
        }else{
            fmt.Printf("非法入侵，已自动报警")
        }
    }else{
        fmt.Printf("非法入侵，已自动报警")
    }

更多

Go 语言 if…else 语句

Go Go教程 2019-04-29 13:36:12 44 0 0

if 语句后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

语法

Go 编程语言中 if...else 语句的语法如下：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则执行 else 语句块。

流程图如下：

实例

使用 if else 判断一个数的大小：

实例

package main

import "fmt"

func main() {
/* 局部变量定义 */
var a int = 100;

/* 判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n" );
} else {
/* 如果条件为 false 则执行以下语句 */
fmt.Printf("a 不小于 20\n" );
}
fmt.Printf("a 的值为 : %d\n", a);

}

以上代码执行结果为：

a 不小于 20
a 的值为 : 100

-------------------------------------

寻找到 100 以内的所有的素数:

package main

import "fmt"
func main(){
    // var count,c int   //定义变量不使用也会报错
    var count int
    var flag bool
    count=1
    //while(count<100) {    //go没有while
    for count < 100 {
        count++
        flag = true;
        //注意tmp变量  :=
        for tmp:=2;tmp<count;tmp++ {
            if count%tmp==0{
                flag = false
            }
        }

更多

Go 语言 goto 语句

Go Go教程 2019-04-29 12:26:28 37 0 0

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。

但是，在结构化程序设计中一般不主张使用 goto 语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。

语法

goto 语法格式如下：

goto label;
..
.
label: statement;

goto 语句流程图如下：

实例

在变量 a 等于 15 的时候跳过本次循环并回到循环的开始语句 LOOP 处：

实例

package main

import "fmt"

func main() {
/* 定义局部变量 */
var a int = 10

/* 循环 */
LOOP: for a < 20 {
  if a == 15 {
/* 跳过迭代 */
a = a + 1
goto LOOP
  }
fmt.Printf("a的值为 : %d\n", a)
a++
}
}

以上实例执行结果为：

a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

更多

Go 语言 continue 语句

Go Go教程 2019-04-29 12:25:50 24 0 0

Go 语言的 continue 语句有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

for 循环中，执行 continue 语句会触发for增量语句的执行。

语法

continue 语法格式如下：

continue;

continue 语句流程图如下：

实例

在变量 a 等于 15 的时候跳过本次循环执行下一次循环：

实例

package main

import "fmt"

func main() {
/* 定义局部变量 */
var a int = 10

/* for 循环 */
for a < 20 {
  if a == 15 {
/* 跳过此次循环 */
a = a + 1;
continue;
  }
fmt.Printf("a 的值为 : %d\n", a);
a++;
}
}

以上实例执行结果为：

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19

更多

Go 语言 break 语句

Go Go教程 2019-04-29 12:25:10 36 0 0

Go 语言中 break 语句用于以下两方面：

用于循环语句中跳出循环，并开始执行循环之后的语句。
break 在 switch（开关语句）中在执行一条case后跳出语句的作用。

语法

break 语法格式如下：

break;

break 语句流程图如下：

实例

在变量 a 大于 15 的时候跳出循环：

实例

package main

import "fmt"

func main() {
/* 定义局部变量 */
var a int = 10

/* for 循环 */
for a < 20 {
fmt.Printf("a 的值为 : %d\n", a);
a++;
if a > 15 {
/* 使用 break 语句跳出循环 */
break;
}
}
}

以上实例执行结果为：

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 15

更多

Go 语言循环嵌套

Go Go教程 2019-04-29 12:24:20 22 0 0

Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。

语法

以下为 Go 语言嵌套循环的格式：

for [condition | ( init; condition; increment ) | Range]
{
for [condition | ( init; condition; increment ) | Range]
{
statement(s);
}
statement(s);
}

实例

以下实例使用循环嵌套来输出 2 到 100 间的素数：

实例

package main

import "fmt"

func main() {
/* 定义局部变量 */
var i, j int

for i=2; i < 100; i++ {
  for j=2; j <= (i/j); j++ {
if(i%j==0) {
  break; // 如果发现因子，则不是素数
}
  }
  if(j > (i/j)) {
fmt.Printf("%d 是素数\n", i);
  }
}
}

以上实例运行输出结果为:

2  是素数
3  是素数
5  是素数
7  是素数
11  是素数
13  是素数
17  是素数
19  是素数
23  是素数
29  是素数
31  是素数
37  是素数
41  是素数
43  是素数
47  是素数
53  是素数
59  是素数
61  是素数
67  是素数
71  是素数
73  是素数
79  是素数
83  是素数
89  是素数
97  是素数

-------------------------

九九乘法表：

package main 

import "fmt"

func main() {
    for m := 1; m < 10; m++ {
    /*    fmt.Printf("第%d次：\n",m) */
        for n := 1; n <= m; n++ {
            fmt.Printf("%dx%d=%d ",n,m,m*n)
        }
        fmt.Println("")
    }
}

更多

Arthur's Blog

标签 - Go教程

1. 背景

2. slice

2.1 内部结构

2.2 覆盖前值

课程目录

go语言的优点

语法

实例

实例

语法

实例

语法

实例

实例

语法

实例

实例

语法

实例

实例

语法

实例

实例

语法

实例

实例

语法

实例

实例

导航

最近发布

友情链接