AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Go语言学习笔记（二）十分钟上手

2018-03-30 1340
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号：96933959

变量&常量

变量

　　变量名由字母、数字、下划线组成，不能以数字开头。

复制代码 
...
var (
    A int    //默认为0
    B string //默认为""
    C bool   //默认为false

    Name string = "suoning"
    Age         = 18 // 自动识别类型
)

func main() {
    sex := "man"          //等价于 var sex string = "man"
    var girlfriend string //声明变量
    girlfriend = "Dawn"   //变量赋值

    Name := "Nick" //正确
    //girlfriend := "Jenny"    //错误的！不能申明两次
    ...
}
复制代码

 

常量

常量使用const 修饰，代表永远是只读的，不能修改。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

语法：const identifier [type] = value，其中type可以省略。

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

复制代码 
...
const (
    A = 'a'    //97
    B = iota   //1
    C          //2
    D = "nick" //"nick"  iota += 1
    E          //"nick"  iota += 1
    F = 618    //618  iota +=1
    G          //618  iota +=1
    H = iota   //7
    I          //8
)
...
复制代码

 

基本数据类型

布尔型

布尔型的值只可以是常量 true 或者 false。

var a bool
var a bool = true
var a = false

 

数字类型

int：

  • uint8（无符号 8 位整型 (0 到 255)）
  • uint16（无符号 16 位整型 (0 到 65535)）
  • uint32（无符号 32 位整型 (0 到 4294967295)）
  • uint64（无符号 64 位整型 (0 到 18446744073709551615)）
  • int8（有符号 8 位整型 (-128 到 127)）
  • int16（有符号 16 位整型 (-32768 到 32767)）
  • int32（有符号 32 位整型 (-2147483648 到 2147483647)）
  • int64（有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)）

float：

  • float32（IEEE-754 32位浮点型数）
  • float64（IEEE-754 64位浮点型数）
  • complex64（32 位实数和虚数）
  • complex128（64 位实数和虚数）

其它：

  • byte（类似 uint8）
  • rune（类似 int32）
  • uint（32 或 64 位）
  • int（与 uint 一样大小）
  • uintptr（无符号整型，用于存放一个指针） 

类型转换

复制代码 
package main

func main() {
    var a int
    var b int32
    var c int64
    a = 15
    //b = a + a // compiler error
    b = int32(a + a) // ok
    b = b + 5 // ok: 5 is a constant
    c = c + 5 // ok
}
复制代码

 

字符类型

存储为ascii码

var a byte = 'a'
fmt.Println(a)    //97

 

字符串类型

字符串表示两种方式：

  1. 双引号 
  2. `` （反引号，不转义）

string底层就是一个byte的数组

string本身是不可变的，因此要改变string中字符，需要如下操作：

str := "hello world"
s := []byte(str)
s[0] = 'o'
str = string(s)

 

操作符

算术运算符

  • + 相加
  • - 相减
  • * 相乘
  • / 相除
  • % 求余
  • ++ 自增
  • -- 自减

 

关系运算符

  • == 检查两个值是否相等，如果相等返回 True 否则返回 False。
  • != 检查两个值是否不相等，如果不相等返回 True 否则返回 False。
  • > 检查左边值是否大于右边值，如果是返回 True 否则返回 False。
  • < 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
  • >= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
  • <= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

 

逻辑运算符

  • && 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。
  • || 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。
  • ! 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

 

位运算符

位运算符对整数在内存中的二进制位进行操作。

  • & 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
  • | 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或。
  • ^ 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
  • << 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
  • >> 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。

 

赋值运算符 

  • = 简单的赋值运算符，将一个表达式的值赋给一个左值
  • += 相加后再赋值 (C += A 等于 C = C + A)
  • -= 相减后再赋值 (C -= A 等于 C = C - A)
  • *= 相乘后再赋值 (C *= A 等于 C = C * A)
  • /= 相除后再赋值 (C /= A 等于 C = C / A)
  • %= 求余后再赋值 (C %= A 等于 C = C % A)
  • <<= 左移后赋值 (C <<= 2 等于 C = C << 2)
  • >>= 右移后赋值 (C >>= 2 等于 C = C >> 2)
  • &= 按位与后赋值 (C &= 2 等于 C = C & 2)
  • ^= 按位异或后赋值  (C ^= 2 等于 C = C ^ 2)
  • |= 按位或后赋值 (C |= 2 等于 C = C | 2)

 

流程控制

If/else & for & range

注意 else if ／ else 位置

if condition1 {
} else if condition2 {
} else if condition3 {

} else {
}

for循环条件没有小括号

for i := 0; i < 10; i++ {
}

死循环

for true {
}
可以简写为：
for {
}

range

for i, v := range str {
}
  range栗子

 

switch case

Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch。

switch var {
case var1:
case var2:
case var3:
default:
}
  switch 栗子一
  switch 栗子二
  switch 栗子三

fallthrough

可以使用fallthrough强制执行后面的case代码。 

  fallthrough栗子

 

label & goto

label要写在for循环的开始而不是结束的地方。直接break退出到指定的位置。

复制代码 
func lab() {
LABLE:
    for i := 0; i < 10; i++ {
        for true {
            i++
            if i == 6 {
                break LABLE
            }
            fmt.Println(i)
        }
    }
}
复制代码

 goto语句可以跳转到本函数内的某个标签

复制代码 
func got() {
    i := 0
HERE:
    fmt.Println(i)
    i++
    if i == 5 {
        return
    }
    goto HERE
}
复制代码

 

select

select与switch类似，不过select有较多限制。

每个case语句里必须是一个channel操作；

复制代码 
select {
case ch <- 0:
    //如果0写入，则进行该case
case <- ch:
    //如果读到数据，则进行该case
default:
    //如果上面的都没有成功，则进入default处理
}
复制代码
  select栗子一
  select栗子二（channel超时处理）

 

函数

Go 语言最少有个 main() 函数。

函数声明告诉了编译器函数的名称，返回类型，和参数。

不支持重载，一个包不能有两个名字一样的函数。

func function_name( [parameter list] ) [return_types] {
   函数体
}

 

命名返回值的名字（return可以不指定变量）：

  栗子一
  栗子二

 

_标识符，用来忽略返回值：

  栗子

 

函数也是一种类型，一个函数可以赋值给变量

复制代码 
package main

import "fmt"

//申明一个函数类型
type add_func func(int, int) int

func add(a, b int) int {
    return a + b
}

func operator(op add_func, a int, b int) int {
    return op(a, b)
}

func main() {
    c := add
    fmt.Println(c)    //0x1087050
    sum := operator(c, 1, 2)
    fmt.Println(sum)    //300
}
复制代码

 

可变参数

其中arg是一个slice，我们可以通过arg[index]依次访问所有参数；通过len(arg)来判断传递参数的个数。

0个或多个参数
func add(arg…int) int {
}
1个或多个参数
func add(a int, arg…int) int {
}
2个或多个参数
func add(a int, b int, arg…int) int {
}
  多参数栗子

 

main & init & defer

main & init

init() 方法是在任何package中都可以出现；
main() 方法只能用在package main 中。
Go程序会自动调用init()和main()，所以你不需要在任何地方调用这两个函数。
每个package中的init函数都是可选的，但package main就必须包含一个main函数。
main()函数不能带参数，也不能定义返回值。命令行传入的参数在os.Args变量中保存。如果需要支持命令行开关，可使用flag包。 
 

defer

  1. 当函数返回时，执行defer语句；
  2. 多个defer语句，按先进后出的方式执行；
  3. defer语句中的变量，在defer声明时确定变量。
  4. 触发异常也会走defer语句。
  defer 栗子
  defer 栗子二
 

作用域

  1. 在函数内部声明的变量叫做局部变量，生命周期仅限于函数内部。
  2. 在函数外部声明的变量叫做全局变量，生命周期作用于整个包，如果是大写的，则作用于整个程序。
  作用域栗子

 

匿名函数 & 闭包

匿名函数

匿名函数是由一个不带函数名的函数声明和函数体组成。

复制代码 
package main

func main()  {

    f := func(x, y int) int {
        return x + y
    }
    f(1,1)

    ch := make(chan int)
    func (ch chan int)  {
        ch <- 9
    }(ch)
}
复制代码

 

闭包

闭包是一个函数和与其相关的引用环境组合而成的实体。

函数可以存储到变量中作为参数传递给其它函数，能够被函数动态的创建和返回。

复制代码 
func Adder() func(int) int {
    var x int
    return func(d int) int {
        x += d
        return x
    }
}

f := Adder()
fmt.Println(f(1))    //1
fmt.Println(f(10))    //11
fmt.Println(f(100))    //111
复制代码
  闭包栗子二

 

值传递 & 引用传递

无论是值传递，还是引用传递，传递给函数的都是变量的副本；

值传递是值的拷贝，引用传递是地址的拷贝；

一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。

map、slice、chan、指针、interface默认以引用的方式传递。

new 内置函数 用来分配内存，主要用来分配值类型，比如int、struct，返回的是指针；

make 内置函数 用来分配内存，主要用来分配引用类型，比如chan、map、slice。

 

程序初始化与执行过程

程序的初始化和执行都起始于main包。
如果main包还导入了其它的包，那么就会在编译时将它们依次导入。
有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。
当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。
等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数。
 

 

指针类型（&*）  

普通类型，变量存的就是值，也叫值类型；

指针类型，变量存的是一个地址，这个地址存的才是值。

变量是一种占位符，用于引用计算机内存地址；

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

获取指针类型所指向的值，使用：*。

 

一个指针变量可以指向任何一个值的内存地址它指向那个值的内存地址。

申明如下：

var age *int           /／指向整型
var height *float32    /／指向浮点型

当一个指针被定义后没有分配到任何变量时，它的值为 nil。

nil 指针也称为空指针。

 

栗子

复制代码 
package main

import "fmt"

func main() {
    var ptr *int
    num := 100
    ptr = &num
    fmt.Println(ptr)    //0xc42000e1f8
    fmt.Println(*ptr)   //100
    *ptr = 200
    fmt.Println(num)    //200
}
复制代码
复制代码 
package main

import "fmt"

func change(num *int) {
    fmt.Println(num)    //0xc42000e1f8
    fmt.Println(*num)   //100
    *num = 1000
    fmt.Println(num)    //0xc42000e1f8
    fmt.Println(*num)   //1000
}

func main() {
    num := 100
    fmt.Println(&num)    //0xc42000e1f8
    change(&num)
    fmt.Println(&num)    //0xc42000e1f8
    fmt.Println(num)     //1000
}
复制代码
文章标签：
云数据库 ClickHouse
Go
存储
编译器
关键词：
Go语言
Go学习笔记
Go语言学习笔记
nothingfinal
目录
相关文章
左诗右码
|
7天前
|
存储 JSON 监控
Viper，一个Go语言配置管理神器！
Viper 是一个功能强大的 Go 语言配置管理库，支持从多种来源读取配置，包括文件、环境变量、远程配置中心等。本文详细介绍了 Viper 的核心特性和使用方法，包括从本地 YAML 文件和 Consul 远程配置中心读取配置的示例。Viper 的多来源配置、动态配置和轻松集成特性使其成为管理复杂应用配置的理想选择。
左诗右码
25 2
听风de歌
|
5天前
|
Go 索引
go语言中的循环语句
【11月更文挑战第4天】
听风de歌
15 2
听风de歌
|
5天前
|
Go C++
go语言中的条件语句
【11月更文挑战第4天】
听风de歌
18 2
听风de歌
|
9天前
|
程序员 Go
go语言中的控制结构
【11月更文挑战第3天】
听风de歌
85 58
游客762btuqu5wybw666
|
8天前
|
监控 Go API
Go语言在微服务架构中的应用实践
在微服务架构的浪潮中，Go语言以其简洁、高效和并发处理能力脱颖而出，成为构建微服务的理想选择。本文将探讨Go语言在微服务架构中的应用实践，包括Go语言的特性如何适应微服务架构的需求，以及在实际开发中如何利用Go语言的特性来提高服务的性能和可维护性。我们将通过一个具体的案例分析，展示Go语言在微服务开发中的优势，并讨论在实际应用中可能遇到的挑战和解决方案。
游客762btuqu5wybw666
28 8
听风de歌
|
5天前
|
Go
go语言中的 跳转语句
【11月更文挑战第4天】
听风de歌
14 4
左诗右码
|
5天前
|
JSON 安全 Go
Go语言中使用JWT鉴权、Token刷新完整示例，拿去直接用！
本文介绍了如何在 Go 语言中使用 Gin 框架实现 JWT 用户认证和安全保护。JWT（JSON Web Token）是一种轻量、高效的认证与授权解决方案，特别适合微服务架构。文章详细讲解了 JWT 的基本概念、结构以及如何在 Gin 中生成、解析和刷新 JWT。通过示例代码，展示了如何在实际项目中应用 JWT，确保用户身份验证和数据安全。完整代码可在 GitHub 仓库中查看。
左诗右码
20 1
游客762btuqu5wybw666
|
9天前
|
Go 数据处理 API
Go语言在微服务架构中的应用与优势
本文摘要采用问答形式，以期提供更直接的信息获取方式。 Q1: 为什么选择Go语言进行微服务开发？ A1: Go语言的并发模型、简洁的语法和高效的编译速度使其成为微服务架构的理想选择。 Q2: Go语言在微服务架构中有哪些优势？ A2: 主要优势包括高性能、高并发处理能力、简洁的代码和强大的标准库。 Q3: 文章将如何展示Go语言在微服务中的应用？ A3: 通过对比其他语言和展示Go语言在实际项目中的应用案例，来说明其在微服务架构中的优势。
游客762btuqu5wybw666
33 6
游客762btuqu5wybw666
|
9天前
|
Go 数据处理 调度
探索Go语言的并发模型：Goroutines与Channels的协同工作
在现代编程语言中，Go语言以其独特的并发模型脱颖而出。本文将深入探讨Go语言中的Goroutines和Channels，这两种机制如何协同工作以实现高效的并发处理。我们将通过实际代码示例，展示如何在Go程序中创建和管理Goroutines，以及如何使用Channels进行Goroutines之间的通信。此外，本文还将讨论在使用这些并发工具时可能遇到的常见问题及其解决方案，旨在为Go语言开发者提供一个全面的并发编程指南。
游客762btuqu5wybw666
30 5
叫个什么名字
|
7天前
|
Go 调度 开发者
探索Go语言中的并发模式：goroutine与channel
在本文中，我们将深入探讨Go语言中的核心并发特性——goroutine和channel。不同于传统的并发模型，Go语言的并发机制以其简洁性和高效性著称。本文将通过实际代码示例，展示如何利用goroutine实现轻量级的并发执行，以及如何通过channel安全地在goroutine之间传递数据。摘要部分将概述这些概念，并提示读者本文将提供哪些具体的技术洞见。
叫个什么名字
9 2

热门文章

最新文章

  • 1
    golang开发:类库篇(四)配置文件解析器goconfig的使用
  • 2
    Go学习笔记-代码调试工具 dlv
  • 3
    基于类型系统的面向对象编程语言Go
  • 4
    go8---函数function
  • 5
    Grumpy：Google 用 Go 开发的 Python 运行时
  • 6
    Go——小白学习之接口
  • 7
    Serverless时代Rust即将称王，详解C、Java、Go、Rust高并发背后的技术？
  • 8
    Go语言之函数详解
  • 9
    Go语言之反射
  • 10
    GO 之MAP的使用
  • 1
    lucky - go 语言实现的快速开发平台
    53
  • 2
    Go 语言切片如何扩容？（全面解析原理和过程）
    118
  • 3
    使用Go语言构建高性能的Web服务器：协程与Channel的深度解析
    236
  • 4
    构建高可用的分布式数据库集群：使用Go语言与Raft共识算法
    99
  • 5
    基于Go语言的微服务架构实践
    165
  • 6
    使用Go语言进行并发编程
    55
  • 7
    深入理解Go的垃圾回收机制
    109
  • 8
    怎么获取客户端真实IP？GO
    98
  • 9
    你确定不学？Go标准库之 text/template
    54
  • 10
    Go语言并发编程：Goroutines和Channels的详细指南
    55

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Python语言基础 - 语法入门
  • Lua完全自学手册图文教程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 语言入门-1：环境构建
  • 高性能特性体验：ePQ 的详解与实战
  • Python新手入门
  • 1分钟部署经典小游戏
  • 基于小程序Serverless开发个人相册小程序
    • 下一篇
    阿里云OSS设置跨域访问