go 基础中的一些坑

类型转换

在 go 语言中，类型转换是显式的，不会自动转换

 

go
 

复制代码
 

func main(){ i := 100 var f float64 f = float64(i) } 
 

string 转换成 int 需要借助 strconv 包
 

使用 strconv.Atoi 函数将 string 转换成 int，转换后它会输出两个值：
 

  • 一个是转换后的值
  • 一个 error，如果转换出错了，第一个值是 0
 

 

go
 

复制代码
 

func main() { str := "100s" i, err := strconv.Atoi(str) if err != nil { fmt.Println(err) } fmt.Println(i) } 
 

这个包还提供了其他的类型的字符串转换方式
 

  • strconv.ParseBool，将字符串 bool 转换成 bool 类型
  • strconv.ParseFloat，将字符串 float 转换成 float 类型
  • strconv.ParseInt，将字符串 int 转换成 int 类型
  • strconv.ParseBool，将 bool 类型转成 string 类型
 

数组
 

go 中数组是定长的，也就是说你需要指定数组的长度，未初始化的项默认值是 0
 

数组需要注意一个越界问题，也就是说不能访问数组的长度之外的元素
 

 

go
 

复制代码
 

func main() { // 10 个元素的数组 arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} fmt.Println(arr[9]) // 10 fmt.Println(arr[10]) // 会报错 arr2 := [10]int{1, 2, 3}， // 从下标 4 开始到下标 9 的元素都是 0 } 
 

数组的长度是不可改变的
 

 

go
 

复制代码
 

func main() { arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} arr = [10]int{1, 2, 3} // 数组的长度是不能改变的 } 
 

slice
 

slice 是一种动态数组，它是由相同类型元素组成的序列
 

slice 底层由三部分组成：
 

  1. 指向底层数组的指针
  2. slice 的长度
  3. slice 的容量
 

在底层数组没有被扩展之前，slice 的长度和容量相等，当我们向 slice 中添加元素时，如果超过了 slice 的容量，那么 go 就会重新分配一个更大的底层数组，并将原始数组复制到心的数组中，这个过程被称为扩容
 

初始化一个 slice 有两种方式：
 

  1. 直接使用字面量的方式初始化一个 slice
 

 

go
 

复制代码
 

func main() { s := []int{1, 2, 3, 4} } 
 

  1. 使用 make 函数创建一个 slice，它接收三个参数：
 

  • 第一个参数是类型
  • 第二个参数是长度
  • 第三个参数是容量 
    • 第三个参数可以省略，也就是说如果不指定容量，那么容量等于长度
 

 

go
 

复制代码
 

func main() { s := make([]int, 3, 5) // 创建一个长度为 3，容量为 5 的切片 } 
 

slice 的访问方式和数组一样：
 

  1. 通过下标访问
 

 

go
 

复制代码
 

arr := [4]int{1, 2, 3, 4} fmt.Println(arr[0]) // 1 s := []int{1, 2, 3, 4} fmt.Println(s[0]) // 1 
 

  1. 通过区间访问（前闭后开）
 

 

go
 

复制代码
 

arr := [4]int{1, 2, 3, 4} fmt.Println(arr[0:2]) // 1,2 s := []int{1, 2, 3, 4} fmt.Println(s[0:2]) // 1,2 
 

  • 区间访问的时候，如果省略了开始的下标，那么默认是 0
  • 如果省略了结束的下标，那么默认是 slice 的长度
 

  1. 不能越界访问
 

删除 slice 中的某项元素，可以使用 append 函数，三个点是展开操作符，它会将 s 中的元素展开
 

 

go
 

复制代码
 

s := []int{1, 2, 3, 4, 5, 6, 7, 8} s = append(s[:1], s[2:]...) 
 

数组和 slice 最大的区别是，数组的长度是固定的，而 slice 的长度是可变的
 

 

go
 

复制代码
 

arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} // 数组 s := []int{1, 2, 3, 4, 5, 6, 7, 8} // 切片 
 

数组可以转变成切片
 

 

go
 

复制代码
 

arr := [8]int{1, 2, 3, 4, 5, 6, 7, 8} // 数组 s := arr[:] // 将数组转换成切片 
 

slice 是引用类型
 

如果一个函数接收的是切片，那么它接收的是切片的引用，也就是说它会改变原始切片的值
 

 

go
 

复制代码
 

func main() { s := []int{1, 2, 3, 4, 5, 6, 7, 8} fmt.Println(s) // [1 2 3 4 5 6 7 8] addOne(s) fmt.Println(s) // [2 3 4 5 6 7 8 9] } // 接收的事切片的引用 func addOne(n []int) { for i := 0; i < len(n); i++ { n[i] = n[i] + 1 } } 
 

如果函数接收的是数组，那么它接收的是数组的值，也就是说它不会改变原始数组的值
 

 

go
 

复制代码
 

func main() { s := [8]int{1, 2, 3, 4, 5, 6, 7, 8} fmt.Println(s) // [1 2 3 4 5 6 7 8] addOne(s) fmt.Println(s) // [1 2 3 4 5 6 7 8] } func addOne(n [8]int) { for i := 0; i < len(n); i++ { n[i] = n[i] + 1 } } 
 

那么数组要实现引用传递怎么办呢？可以使用指针
 

 

go
 

复制代码
 

func main() { s := [8]int{1, 2, 3, 4, 5, 6, 7, 8} fmt.Println(s) // [1 2 3 4 5 6 7 8] addOne(&s) fmt.Println(s) // [2 3 4 5 6 7 8 9] } func addOne(n *[8]int) { for i := 0; i < len(n); i++ { n[i] = n[i] + 1 } } 
 

最后，slice 如何传递指针？在函数内部需要使用 * 来解引用，然后在对 slice 进行操作
 

 

go
 

复制代码
 

func main() { s := []int{1, 2, 3, 4, 5, 6, 7, 8} fmt.Println(s) addOne(&s) fmt.Println(s) } func addOne(n *[]int) { // 先对 n 解引用 _n := *n for i := 0; i < len(_n); i++ { _n[i] = _n[i] + 1 } } 
 

map
 

map 未初始化，可以取值，但赋值会报错，
 

 

go
 

复制代码
 

func main() { var m1 map[string]int fmt.Println(m1["age"]) // 0 m1["age"] = 1 // 报错 } 
 

map 的初始化有两种方式：
 

 

go
 

复制代码
 

m1 := map[string]int{"age": 1} // 字面量的方式 m2 := map[string]int{} // 这种也是字面量 m3 := make(map[string]int) // 使用 make 函数 
 

如何判断一个属性在不在 map 中呢？可以使用 ok 来判断
 

 

go
 

复制代码
 

func main() { m2 := make(map[string]int) m2["age"] = 25 a, ok := m2["age"] fmt.Println(a, ok) // 25 true a, ok = m2["age2"] fmt.Println(a, ok) // 0 false } 
 

switch
 

go 中的 switch 如果命中某条 case 语句后，就不会命中其他 case 语句了
 

switch 可以使用 x.(type) 的方式类判断一个变量的类型，x.(type) 只能在 switch 语句中使用，不能在 if 语句中使用
 

 

go
 

复制代码
 

func typeof(x interface{}) { switch x.(type) { case int: fmt.Println("int") case string: fmt.Println("string") default: fmt.Println("unknown") } } 
 

for
 

在 for 循环中，如果操作指针的话，会有一个问题，如下所示：添加到 oddNumbers 中都是 7
 

因为 number 是一个变量，它的地址是不变的，所以 oddNumbers 中的元素都是 number 的地址，而 number 最后的值是 7
 

 

go
 

复制代码
 

func main() { numbers := []int{1, 2, 3, 4, 5, 6, 7} var oddNumbers []*int for _, number := range numbers { // number 的地址是不变的 oddNumbers = append(oddNumbers, &number) } for _, oddNumber := range oddNumbers { fmt.Println(*oddNumber) } } 
 

如何解决这个问题呢？可以使用一个临时变量，每一个循环进来的时候，都创建一个临时变量，然后将它的地址添加到 oddNumbers 中
 

 

go
 

复制代码
 

func main() { numbers := []int{1, 2, 3, 4, 5, 6, 7} var oddNumbers []*int for _, number := range numbers { // 每次循环都会创建一个新变量，然后将它的地址添加到 oddNumbers 中 tmp := number oddNumbers = append(oddNumbers, &tmp) } for _, oddNumber := range oddNumbers { fmt.Println(*oddNumber) } } 
 

error
 

任何一个实现了 Error() 方法的类型都可以作为错误类型
 

 

go
 

复制代码
 

type MyError struct { message string code int } func (e MyError) Error() string { return e.message } func add() (*int, error) { var myError = MyError{ message: "This is an error", code: 500, } return nil, myError // 使用自定义的错误 } 
 

判断一个 error 是什么类型最好使用 errors.Is 函数，不要用 == 来判断
 

 

go
 

复制代码
 

e1 := fmt.Errorf("error 1: %w", io.EOF) fmt.Println(errors.Is(e1, io.EOF)) // true fmt.Println(e1 == io.EOF) // false 
 

error 类型断言可以使用 errors.As 函数，不要使用 err.(xx)
 

因为 errors.As 和 errors.Is 函数是可以判断包装过的 error
 

package
 

在一个 package 中执行顺序：
 

  1. 先执行 const 常量
  2. 再执行 var 变量
  3. 然后再执行 init 函数
  4. 最后执行 main 函数
 

如果有引入其他的 package，那么它会先执行其他的 package 的 const，var，init，然后再执行当前 package 的 const，var，init，这是一个深度优先的顺序
 

go mod 是一个用于管理 go 的依赖模块，它会将依赖的模块下载到 go 的缓存目录中，然后在 go.mod 文件中记录下来，一般存储在 $GOPATH/pkg/mod 目录中
 

go mod 的命令：
 

  • go mod init：初始化一个 go.mod 文件
  • go mod tidy：根据 go.mod 文件整理依赖
  • go mod download：下载 go.mod 文件中的依赖，但不安装
  • go mod verify：验证依赖是否正确和完整
  • go mod graph：以图形化显示模块之间的依赖关系
  • go mod why：解释模块为什么需要特定的依赖
 

receiver
 

指针类型 receiver 使用指向该类型的指针作为接收者；值类型 receiver 使用该类型的值作为接收者
 

定义一个 Animal 接口，它有一个 Eat 方法，定义 Dog 结构体，它有一个 Say 方法，然后实现 Animal 接口
 

使用指针类型作为 receiver，实现接口需要使用指针类型的值
 

 

go
 

复制代码
 

type Animal interface { Eat() } type Dog struct { Name string } func (d *Dog) Say() { fmt.Printf("Name is %v", d.Name) } func main() { // 这里只能使用指针类型的值 var a Animal = &Dog{Name: "uccs"} a.Say() } 
 

使用值类型作为 receiver，实现接口可以使用值类型的值，也可以使用指针类型的值
 

 

go
 

复制代码
 

type Animal interface { Say() } type Dog struct { Name string } func (d Dog) Say() { fmt.Printf("Name is %v", d.Name) } func main() { // 这里可以使用指针类型的值 var a Animal = &Dog{Name: "uccs"} a.Say() // 也可以使用值类型的值 var a1 Animal = Dog{Name: "astak"} a1.Say() } 
 

interface
 

接口类型断言：
 

 

go
 

复制代码
 

func AnimalSleep(e Eater){ if s, ok := e.(Animal); ok { s.Sleep() } } 
 

对于 interface 类型的变量，不能使用指针类型的零值(指针类型的零值是 nil)：你会处理 go 中的 nil 吗
 

抽象接口的实现：
 

 

go
 

复制代码
 

type Worker interface { doWork() Start() } type BaseWorker struct { Worker } func (b *BaseWorker) Start() { fmt.Println("start") b.doWork() fmt.Println("end") } type NormalWorker struct { BaseWorker } func (n *NormalWorker) doWork() { fmt.Println("do work") } func NewNormalWorker() Worker { n := &NormalWorker{BaseWorker{}} // 这边需要赋值，不然会报错 n.Worker = n return n } func main() { NewNormalWorker().Start() } 
 

goroutine 中的竞态
 

当有多个 goroutine 对同一个变量进行读写操作时，就会出现竞态
 

因为写入一个变量的操作不是原子的，一般会分为三步：
 

  1. 读取变量的值：read counter
  2. 对变量的值进行操作：counter = counter + 1
  3. 将最新的值写入变量：write counter
 

 

go
 

复制代码
 

var counter int32 func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func(i int) { counter = counter + 1 wg.Done() }(i) } wg.Wait() fmt.Println(counter) // 不一定是 1000 } 
 

如何解决这个问题呢：
 

  1. 使用 atomic 包中的原子操作 
    • 在 x86 架构中，atomic.AddInt32 函数使用 lock xaddq 指令来实现原子加操作
     go 
    复制代码
     var counter int32 func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func(i int) { // 这个操作是原子的 atomic.AddInt32(&counter, 1) wg.Done() }(i) } wg.Wait() fmt.Println(counter) }  这两种方法是一样的，只是 atomic.AddInt32 的方法更加简洁 
     go 
    复制代码
     var counter = atomic.Int32{} func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func(i int) { counter.Add(1) wg.Done() }(i) } wg.Wait() fmt.Println(counter.Load()) } 
  2. atomic.CompareAndSwapInt64 函数是使用 CPU 的原子指令来实现的，它使用了 CPU 提供的 compare-and-swap 指令来保证原子性 
    • CAS 指令可以原子的比较并交换一个内存地址中的值，它有三个操作数：内存地址 addr，期望的旧值 old，新值 new
    • 如果内存地址 addr 中的值等于 old，那么将 new 的值写入 addr 中，否则不做任何操作
     go 
    复制代码
     var counter int32 func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func(i int) { for { if swaped := atomic.CompareAndSwapInt32(&counter, counter, counter+1); swaped { break } } wg.Done() }(i) } wg.Wait() fmt.Println(counter) } 
  3. 使用锁 
     go 
    复制代码
     var counter int32 var lock sync.Mutex func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func(i int) { lock.Lock() counter = counter + 1 lock.Unlock() wg.Done() }(i) } wg.Wait() fmt.Println(counter) }
 

 












本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/767483.shtml


如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！











相关文章










计算机组成原理-5-输入输出系统








计算机组成原理-5-输入输出系统




5. 输入输出系统 文章目录 5. 输入输出系统5.1 概述5.1.1 I/O系统的发展概况5.1.2 I/O系统的组成5.1.3 I/O设备与主机的连接5.1.4 I/O设备与主机传送信息的控制方式 5.2 I/O设备5.3 I/O接口5.4 控制方式5.4.1 程序查询方式5.4.2 程序中断方式5.4.3 DMA方式5.4.4 程序中断方式与…




阅读更多...

















vue 控制窗口禁止缩放，已解决








vue 控制窗口禁止缩放，已解决




注意&#xff1a;不是浏览器窗口禁止缩放 
1.vue框架中&#xff0c;index.html文件head标签中加上内容 
<meta name"viewport" content"widthdevice-width, initial-scale1, maximum-scale1, user-scalable0"><script>document.addEventListen…




阅读更多...

















RabbitMQ 01








RabbitMQ 01




01.定义  02.功能




阅读更多...

















apifox创建接口含中文字符报错的两种解决方案








apifox创建接口含中文字符报错的两种解决方案




针对apifox的含中文报错解决方法&#xff1a; 
方法一&#xff1a;创建相应接口后&#xff0c;在设置中URL自动编码为WHATING。 方法二&#xff1a;直接将浏览器的url复制到apifox中&#xff0c;浏览器会自动解析配置中文转换路径。




阅读更多...

















springboot297毕业生实习与就业管理系统的设计与实现








springboot297毕业生实习与就业管理系统的设计与实现




毕业生实习与就业管理系统 
摘 要 
使用旧方法对毕业生实习与就业管理系统的信息进行系统化管理已经不再让人们信赖了&#xff0c;把现在的网络信息技术运用在毕业生实习与就业管理系统的管理上面可以解决许多信息管理上面的难题&#xff0c;比如处理数据时间很长&#xff0c;数…




阅读更多...

















ADS版图优化方法---使用EM-Cosimulation对版图进行OPTIM








ADS版图优化方法---使用EM-Cosimulation对版图进行OPTIM




ADS版图优化方法—使用EM-Cosimulation对版图进行OPTIM 
一般来说&#xff0c;对原理图进行OPTIM优化的方法大伙用的都比较6了&#xff0c;跑起来也非常快。但是得到版图又可能和原理图的结果差的非常大&#xff0c;为了优化版图又不得不重新对原理图的参数进行调谐优化&#x…




阅读更多...

















这个国产原型设计工具，建议PM新人一定要用！








这个国产原型设计工具，建议PM新人一定要用！




Hello小伙伴们&#xff01;我是榛妮&#xff0c;原BAT大厂女产品经理一枚&#xff0c;目前在香港创业。 
一转眼&#xff0c;做产品经理已经8年&#xff0c;想想入行时的种种往事&#xff08;尴尬情况&#xff09;&#xff0c;至今仍然历历在目。 说起刚入行时遇到的那些问题&a…




阅读更多...

















qt拖拽事件重写








qt拖拽事件重写




1.qt中的拖拽事件步骤 
1设置接受拖拽 2重写事件就可以了 3其他的控件如何要可以套模板 
2.例子 
#include <QGroupBox>
#include <QObject>
#include <QDragEnterEvent>
#include <QFileInfo>
#include <QMimeData>//重写&#xff0c;指出拖拽指…




阅读更多...

















web蓝桥杯真题：布局切换








web蓝桥杯真题：布局切换




代码及注释&#xff1a; 
<!-- TODO&#xff1a;请在下面实现需求 -->
<div class"bar">    //动态添加类名<a class"grid-icon" :class"changeBar  0 ? active : " click"changeBar  0"></a><a class&qu…




阅读更多...

















蓝桥杯物联网Lora通信功能总结








蓝桥杯物联网Lora通信功能总结




1、LORA通信在函数LORA被初始化的时候就已经处于接收状态  即开机即能接收数据 
2、LORA数据的接收以及发送都通过FIFO数据线 3、LORA的收发同时进行会产生FIFO数据线的通信干扰 4、LORA_Rx在FIFO中有数据的时候才会取出数据&#xff0c;FIFO没有数据会直接跳过 
当LORA在发送数…




阅读更多...

















服务器运行一段时间后








服务器运行一段时间后




自己记录一下。 
一、查看目录占用情况 
df -h  命令查看磁盘空间 
du -ah --max-depth=1  /     查看根目录下各个文件占用情况  二、mysql日志清空 
这个日志是可以清空的 echo  > /usr/local/mysql/data/syzl-db2.log  #将文件清空 
说明：  这个文件这么大是因为，开启 …




阅读更多...

















自动驾驶国际标准ISO文件








自动驾驶国际标准ISO文件




Coordinate system&#xff1a;Road vehicles — Vehicle dynamics and road-holding ability — Vocabulary




阅读更多...

















一、springboot 集成 spring-boot-starter-data-redis








一、springboot 集成 spring-boot-starter-data-redis




文章目录 前言一、 springboot 版本二、引入 redis 依赖三、增加配置文件四、增加配置类1、 RedissonConfig2、RedisConfig 五、增加操作类&#xff0c;主要操作 string 总结 前言 
一、 springboot 版本 <spring-boot.version>2.3.5.RELEASE</spring-boot.version>…




阅读更多...

















TypeScript基础类型








TypeScript基础类型




string、number、bolean 
直接在变量后面添加即可。 
let myName: string  Tomfunction sayHello(person: string) {return hello,  person
}
let user  Tom
let array  [1, 2, 3]
console.log(sayHello(user))function greet(person: string, date: Date): string {console.lo…




阅读更多...

















基于python+vue城市交通管理系统的设计与实现flask-django-php-nodejs








基于python+vue城市交通管理系统的设计与实现flask-django-php-nodejs




此系统设计主要采用的是python语言来进行开发&#xff0c;采用django/flask框架技术&#xff0c;框架分为三层&#xff0c;分别是控制层Controller&#xff0c;业务处理层Service&#xff0c;持久层dao&#xff0c;能够采用多层次管理开发&#xff0c;对于各个模块设计制作有一…




阅读更多...

















数学建模综合评价模型与决策方法








数学建模综合评价模型与决策方法




评价方法主要分为两类&#xff0c;其主要区别在确定权重的方法上 
一类是主观赋权法&#xff0c;多次采取综合资讯评分确定权重&#xff0c;如综合指数法&#xff0c;模糊综合评判法&#xff0c;层次评判法&#xff0c;功效系数法等 
另一类是客观赋权法&#xff0c;根据各指标…




阅读更多...

















力扣HOT100 - 15. 三数之和








力扣HOT100 - 15. 三数之和




解题思路&#xff1a; 
排序  双指针 注意&#xff1a; 在nums[ k ]&#xff0c;nums[ i ]&#xff0c;nums[ j ]的值与自身重复时均会进行跳过&#xff0c;防止重复添加。 
如代码中&#xff1a; 防止nums[ k ]重复&#xff1a;if(k>0&&nums[k]nums[k-1]) continue…




阅读更多...

















Web前端全栈HTML5通向大神之路








Web前端全栈HTML5通向大神之路




本套课程共三大阶段&#xff0c;六大部分&#xff0c;是WEB前端、混合开发与全栈开发必须要掌握的技能&#xff0c;从基础到实践&#xff0c;是从编程小白成长为全栈大神的最佳教程&#xff01; 链接&#xff1a;https://pan.baidu.com/s/1S_8DCORz0N2ZCdtJg0gHsw?pwdtjyv 提取…




阅读更多...

















Java进阶—GC回收(垃圾回收)








Java进阶—GC回收(垃圾回收)




1. 什么是垃圾回收 
垃圾回收(Garbage Collection&#xff0c;GC)是Java虚拟机(JVM)的一项重要功能&#xff0c;用于自动管理程序中不再使用的内存。在Java中&#xff0c;程序员不需要手动释放内存&#xff0c;因为GC会自动检测并回收不再使用的对象&#xff0c;从而减少内存泄…




阅读更多...

















力扣|两数相加|链表








力扣|两数相加|链表




给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 
请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 
你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 …




阅读更多...


















最新文章


















Copyright @ 2022~2023