一 panic机制 　　panic会将这个异常不断向上抛出，直到有地方处理它，如果有处理，则不会再向上抛出。倘若没有处理，那么最终会导致main挂掉. 　golang虽然没有try catch机制，却有一种类似的recover机制，后续demo我们可以观测到它的用法和作用 二 实例 　　 2.1 main用recover func main() { defer func() { if err := recover(); err != nil { log.Println("err:", err) } }() go test1() time.Sleep(time.Second * 3) panic(errors.New("stop test1")) log.Println("123") select {} } func test1() { for { tm := time.NewTicker(time.Second) select { case <-tm.C: log.Println("test1") } } } 2.2 func用recover func main() { defer func() { if err := recover(); err != nil { log.Println("err:", err) } }() go test1() time.Sleep(time.Second * 3) makeerr() log.Println("123") select {} } func test1() { for { tm := time.NewTicker(time.Second) select { case <-tm.C: log.Println("test1") } } } func makeerr() { defer func() { if err := recover(); err != nil { log.Println("makeerr:", err) } }() panic(errors.New("stop")) } 此时我们在func中用recover，那么挂掉的只是func，他不会抛到main中，所以main能继续运行，继而main开辟的go test1也能继续运行 2.3 func用recover且开创goroutine func main() { defer func() { if err := recover(); err != nil { log.Println("err:", err) } }() time.Sleep(time.Second * 3) makeerr() log.Println("123") select {} } func test1() { for { tm := time.NewTicker(time.Second) select { case <-tm.C: log.Println("test1") } } } func makeerr() { defer func() { if err := recover(); err != nil { log.Println("makeerr err:", err) } }() go test1() panic(errors.New("stop test")) } 我们发现，func虽然挂掉了，但是他开创的go没挂掉，因为即使是这个函数退出了，新开的协程是相当于基于main下的一个子程，只要main不退出，他依然会“存活” 2.4 goroutine中panic func main() { defer func() { if err := recover(); err != nil { log.Println("err:", err) } }() go test1() time.Sleep(time.Second * 3) log.Println("123") select {} } func test1() { log.Println("test1 start") panic(errors.New("stop test1")) log.Println("test1 end") } 协程中如果没recover，那么error就会抛向main，main就会挂掉，从而没有执行到后面的log打印。 ---> 这种情况，main中做defer recover是没用的 2.5 func1内嵌func2中panic且func2做处理 func main() { test1() time.Sleep(time.Second * 3) log.Println("123") } func test1() { log.Println("test1 start") test2() log.Println("test1 end") } func test2() { defer func() { if err := recover(); err != nil { log.Println("test2 err:", err) } }() log.Println("test2 start") panic(errors.New("stop test2")) log.Println("test2 end") } 2.6 func1内嵌func中panic且func1做处理 func main() { test1() time.Sleep(time.Second * 3) log.Println("123") } func test1() { defer func() { if err := recover(); err != nil { log.Println("test? err:", err) } }() log.Println("test1 start") test2() log.Println("test1 end") } func test2() { log.Println("test2 start") panic(errors.New("stop test2")) log.Println("test2 end") } func2异常，执行终止，向调用者func1抛出进而本身退出，func1得到异常，执行终止，本身退出时recover进行处理，从而保活了main 到此这篇关于golang panic及处理机制的文章就介绍到这了,更多相关golang panic内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

互斥锁简单粗暴，谁拿到谁操作。今天给大家介绍一下读写锁，读写锁比互斥锁略微复杂一些，不过我相信我们今天能够把他拿下! golang读写锁，其特征在于 读锁：可以同时进行多个协程读操作，不允许写操作 写锁：只允许同时有一个协程进行写操作，不允许其他写操作和读操作 读写锁有两种模式。没错！一种是读模式，一种是写模式。当他为写模式的话，作用和互斥锁差不多，只允许有一个协程抢到这把锁，其他协程乖乖排队。但是读模式就不一样了，他允许你多个协程读，但是不能写。总结起来就是： 仅读模式： 多协程可读不可写 仅写模式： 单协程可写不可读 在32位的操作系统中，针对int64类型的值的读和写操作都不可能仅由一个CPU指令来完成。如若一个写操作刚刚执行完第一个指令，就去进行另一个读的协程，这样就会读到一个错误的数据。 下面看个例子吧： 先看主函数： func main() { for i:=0;i<5;i++{ wg06.Add(1) go write(i) ​ wg06.Add(1) go read(i) }    wg06.Wait() } 每次开辟两条协程，一条协程执行写函数，另一条执行读函数。然后放入等待组。共开辟五次。 在来看一看写函数 func write(i int) { //锁定为仅写模式，其他协程被阻塞 rwm.Lock() ​ fmt.Println(i,"writing...") <- time.After(10*time.Second) fmt.Println("write over!") ​ rwm.Unlock() //解锁仅写模式 wg06.Done() } 这个Lock()就是执行读写锁的写模式，当这个模式进行时，只有这条协程能写，其他协程都被阻塞。Unlock()就是解锁这个仅锁模式，等待组中的其他协程不再被阻塞。 再看一看读模式： func read(i int) { rwm.RLock() ​ fmt.Println(i,"reading...") <-time.After(10 * time.Second) fmt.Println(i,"read over!") ​ rwm.RUnlock() wg06.Done() } RLock()就是执行读写锁的读模式，执行这个模式其他协程也能读，但是都不能写。 如果程序运行，写协程先抢到锁，所有协程就不能读，只有这条写协程能写，其他人都等着。如果是读协程抢到锁，所以写协程就不可能了，但是读协程仍然可以抢。 现在你知道我们应该什么时候使用读写锁了吗？ 在并发进行读写操作时，当读的次数远远超过写的次数的情况下，应该使用读写锁来进行读写并发操作。 Golang读写锁底层原理 在加读锁和写锁的工程中都使用atomic.AddInt32来进行递增，而该指令在底层是会通过LOCK来进行CPU总线加锁的，因此多个CPU同时执行readerCount其实只会有一个成功，从这上面看其实是写锁与读锁之间是相对公平的，谁先达到谁先被CPU调度执行，进行LOCK锁cache line成功，谁就加成功锁 底层实现的CPU指令 底层的2条指令，通过LOCK指令配合CPU的MESI协议，实现可见性和内存屏障，同时通过XADDL则用来保证原子性，从而解决可见性与原子性问题 // atomic/asm_amd64.s TEXT runtime∕internal∕atomic·Xadd(SB) LOCK XADDL AX, 0(BX) 可见性与内存屏障、原子性， 其中可见性通常是指在cpu多级缓存下如何保证缓存的一致性，即在一个CPU上修改了了某个数据在其他的CPU上不会继续读取旧的数据，内存屏障通常是为了CPU为了提高流水线性能，而对指令进行重排序而来，而原子性则是指的执行某个操作的过程的不可分割 总结 到此这篇关于Golang并发操作中常见读写锁的文章就介绍到这了,更多相关Golang并发读写锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

与其他主流语言如 Javascript、Java 和 Python 相比，Golang 的错误处理方式可能和这些你熟悉的语言有所不同。所以才有了这个想法根大家聊一聊 golang 的错误处理方式，以及实际开发中应该如何对错误进行处理。因为分享面对 Golang有一个基本的了解 developers, 所以一些简单地方就不做赘述了。 如何定义错误 在 golang 语言中，无论是在类型检查还是编译过程中，都是将错误看做值来对待，和 string 或者 integer 这些类型值并不差别。声明一个 string 类型变量和声明一个 error 类型变量是没什么区别的。 你可以定义接口作为 error 的类型，有关 error 能够提供什么样信息都是由自己决定的，这是 error 在 golang 作为值的好处，不过这样做也自然有其坏处，有关 error 定义好坏就全由其定义开发人员所决定，也就是有关 error 融入过多人为的主观因素。 package main import ( "fmt" "io/ioutil" ) func main(){ dir, err := ioutil.TempDir("","temp") if err != nil{ fmt.Errorf("failed to create temp dir: %v",err) } } 错误在语言中的重点地位 在 Go 语言中错误处理设计一直大家喜欢讨论的内容，错误处理是该语言的核心，但该语言并没有规定如何处理错误。社区已经为改进和规范错误处理做出了努力，但许多人忽略了错误在我们应用程序领域中的核心地位。也就是说，错误与客户和订单类型一样重要。 Golang中的错误 错误表示在应用程序中发生了不需要的情况。比方说，想创建一个临时目录，在那里可以为应用程序存储一些文件，但这个目录的创建失败了。这是一个不期望的情况，就可以用错误来表示。 通过创建自定义错误可以将更丰富错误信息传递给调用者。个返回值返回将错误交给调用函数人来处理错误。Golang 本身允许函数具有多个返回值，所以通常把错误作为函数最后一个参数返回给调用者来处理。 errors 是 I/O 有时候开发人员是 error 的生产者(写 error) 有时候开发人员又是 error 的消费者(读 error) 也就是我们开发程序一部分工作是读取和写入 error errors 的上下文 什么是 error 的上下文呢? 如何定义 error 需要考虑一些因素，例如在不同程序我们定义 error 和处理 error 方式也不仅相同 CLI 工具 库 长时间运行的系统 而且我们需要考虑使用程序的人群，他们是什么方式来使用系统，这些因素都是我们设计也好定义错误信息要考虑的因素。 错误的类型 就错误核心，那么错误可能是我们预料之中的错误，错误也可能是我们没有考虑到，例如无效内存，数组越界，也就是单靠代码自身暂时是解决不了的错误 ，这样的误差往往让代码恐慌，所以 Panic。通常这样错误对于程序是灾难性的失败，无法修复的。 自定义错误 如前所述，错误使用内置的错误接口类型来表示，其定义如下。 type error interface { Error() string } 下面举了 2 例子来定义 error ，分别定义两个 struct 都实现了 Error() 接口即可 type SyntaxError struct { Line int Col int } func (e *SyntaxError) Error() string { return fmt.Sprintf("%d:%d: syntax error", e.Line, e.Col) } type InternalError struct { Path string } func (e *InternalError) Error() string { return fmt.Sprintf("parse %v: internal error", e.Path) } 该接口包含一个方法 Error() ，以字符串形式返回错误信息。每一个实现了错误接口的类型都可以作为一个错误使用。当使用 fmt.Println 等方法打印错误时，Golang 会自动调用 Error() 方法。 在 Golang 中，有多种创建自定义错误信息的方法，每一种都有自己的优点和缺点。 基于字符串的错误 基于字符串的错误可以用 Golang 中两个开箱即用方法来自定义错误，适用哪些仅返回描述错误信息的相对来说比较简单的错误。 err := errors.New("math: divided by zero") 将错误信息传入到 errors.New() 方法可以用来新建一个错误 err2 := fmt.Errorf("math: %g cannot be divided by zero", x) fmt.Errorf 通过字符串格式方式，可以将错误信息包含你错误信息中。也就是为错误信息添加了一些格式化的功能。 自定义数据结构的错误 可以通过在你的结构上实现 Error 接口中定义的 Error() 函数来创建自定义的错误类型。下面是一个例子。 Defer, panic 和 recover Go 并不像许多其他编程语言（包括 Java 和 Javascript ）那样有异常，但有一个类似的机制，即 "Defer, panic 和 recover"。然而，panic 和 recover 的使用情况与其他编程语言中的异常非常不同，因为代码本身无法应对时候和不可恢复的情况下使用。 Defer 有点类似析构函数，在函数执行完毕后做一些资源释放等收尾工作，好处其执行和其在代码中位置并没有关系，所以可以将其写在你读写资源语句后面，以免随后忘记做一些资源释放的工作。关于 defer 输出也是面试时，面试官喜欢问的一个问题。 package main import( "fmt" "os" ) func main(){ f := createFile("tmp/machinelearning.txt") defer closeFile(f) writeFile(f) } func createFile(p string) *os.File { fmt.Println("creating") f, err := os.Create(p) if err != nil{ panic(err) } return f } func closeFile(f *os.File){ fmt.Println("closing") err := f.Close() if err != nil{ fmt.Fprintf(os.Stderr, "error:%v\n",err) os.Exit(1) } } func writeFile(f *os.File){ fmt.Println("writing") fmt.Fprintln(f,"machine leanring") } defer 语句会将函数推入到一个栈结构中。同时栈结构中的函数会在 return 语句执行后被调用。 package main import "fmt" func main(){ // defer fmt.Println("word") // fmt.Println("hello") fmt.Println("hello") for i := 0; i <=3; i++ { defer fmt.Println(i) } fmt.Println("world") } hello world 3 2 1 0 可以通过在你的结构上实现 Error 接口中定义的 Error() 函数来实现自定义错误类型，下面是一个例子。 Panic panic 语句向 Golang 发出信号，这时通常是代码无法解决当前的问题，所以停止代码的正常执行流程。一旦调用了 panic，所有的延迟函数都会被执行，并且程序会崩溃，其日志信息包括 panic 值（通常是错误信息）和堆栈跟踪。 举个例子，当一个数字被除以0时，Golang会出现 panic。 package main import "fmt" func main(){ divide(5) } func divide(x int){ fmt.Printf("divide(%d)\n",x+0/x) divide(x-1) } divide(5) divide(4) divide(3) divide(2) divide(1) panic: runtime error: integer divide by zero goroutine 1 [running]: main.divide(0x0) /Users/zidea2020/Desktop/mysite/go_tut/main.go:10 +0xdb main.divide(0x1) /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc main.divide(0x2) /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc main.divide(0x3) /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc main.divide(0x4) /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc main.divide(0x5) /Users/zidea2020/Desktop/mysite/go_tut/main.go:11 +0xcc main.main() /Users/zidea2020/Desktop/mysite/go_tut/main.go:6 +0x2a exit status 2 Recover Go语言提供了recover内置函数，前面提到，一旦panic，逻辑就会走到defer那，那我们就在defer那等着，调用recover函数将会捕获到当前的panic，被捕获到的panic就不会向上传递了。然后，恢复将结束当前的 Panic 状态，并返回 Panic 的错误值。 package main import "fmt" func main(){ accessSlice([]int{1,2,5,6,7,8}, 0) } func accessSlice(slice []int, index int) { defer func() { if p := recover(); p != nil { fmt.Printf("internal error: %v", p) } }() fmt.Printf("item %d, value %d \n", index, slice[index]) defer fmt.Printf("defer %d \n", index) accessSlice(slice, index+1) } 包装错误 Golang 也允许对错误进行包裹，通过错误嵌套，在原有错误信息上添加一个额外信息帮助调用者对问题判断以及后续应该如何处理信息。以通过使用 %w 标志和 fmt.Errorf 函数来对原有的错误进行保存提供一些特定的信息，如下例所示。 package main import ( "errors" "fmt" "os" ) func main() { err := openFile("non-existing") if err != nil { fmt.Printf("error running program: %s \n", err.Error()) } } func openFile(filename string) error { if _, err := os.Open(filename); err != nil { return fmt.Errorf("error opening %s: %w", filename, err) } return nil } 上面已经通过代码演示如何包装一个错误，程序会打印输出使用 fmt.Errorf 添加文件名的包装过的错误，也打印了传递给 %w 标志的原有错误信息。这里再补充一个 Golang 还提供的功能，通过使用 error.Unwrap 来还原错误信息，从而获得原有的错误信息。 package main import ( "errors" "fmt" "os" ) func main() { err := openFile("non-existing") if err != nil { fmt.Printf("error running program: %s \n", err.Error()) // Unwrap error unwrappedErr := errors.Unwrap(err) fmt.Printf("unwrapped error: %v \n", unwrappedErr) } } func openFile(filename string) error { if _, err := os.Open(filename); err != nil { return fmt.Errorf("error opening %s: %w", filename, err) } return nil } 错误的类型转换 有时候需要在不同的错误类型之间进行转换，有情况需要通过类型转换来为错误添加信息，或者换一种表达方式，。 errors.As 函数提供了一个简单而安全的方法，通过寻找错误链中匹配错误类型进行转化输出。如果没有找到匹配的，该函数返回 false 。 package main import ( "errors" "fmt" "io/fs" "os" ) func main(){ // Casting error if _, err := os.Open("non-existing"); err != nil { var pathError *os.PathError if errors.As(err, &pathError) { fmt.Println("Failed at path:", pathError.Path) } else { fmt.Println(err) } } } 在这里，试图将通用错误类型转换为 os.PathError ，这样就可以访问该特定的错误信息，这些信息保存在结构体中的 Path 属性上。 错误类型检查 Golang 提供了 errors.Is 函数来用于检查错误类型是否为指定的错误类型，该函数返回一个布尔值值来表示是否为指定错误类型。 package main import ( "errors" "fmt" "io/fs" "os" ) func main(){ // Check if error is a specific type if _, err := os.Open("non-existing"); err != nil { if errors.Is(err, fs.ErrNotExist) { fmt.Println("file does not exist") } else { fmt.Println(err) } } } 到此这篇关于golang 语言中错误处理机制的文章就介绍到这了,更多相关golang 错误处理内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

死锁 死锁的4个条件 不可剥夺 线程已经获得的资源，在未使用完之前，不能被其他线程剥夺，只能在使用完后自己释放。请求保持 线程 T1 保持了一个资源 R1 占用，但是又提出另外一个资源 R2 请求，此时，资源 R2 被线程 T2 占用，于是 T1 线程必须等待，但又对自己保持的 R1 资源不释放。 循环等待 死锁发生时，必然存在一个 “进程-资源环形链”，例如 进程p0 等待 p1 占用资源，p1 等待 p2 占用的资源， p2 等待 p0 占用的资源，形成了一个环形链。 互斥 线程对资源访问是排斥的，如果一个线程占用了资源，那么其他线程必须处于等待状态，直到资源释放。 如何避免死锁 如果并发的查询多个表，要约定好访问顺序 不能线程 T1 先访问表 A 后访问表 B，线程T2 先访问 表B 后访问 表A, 这个情况极容易死锁。 在同一个事务中，尽可能一次锁定获取所需要的资源 对于容易产生死锁的业务场景， 尝试升级锁的力度 采用分布式锁或者使用乐观锁 死锁代码 package sync import ( "fmt" "runtime" "sync" "testing" "time" ) type value struct { memAccess sync.Mutex value int } func TestDeadLock(t *testing.T) { runtime.GOMAXPROCS(3) var wg sync.WaitGroup sum := func(v1, v2 *value) { defer wg.Done() v1.memAccess.Lock() // 锁 v1 time.Sleep(2 * time.Second) v2.memAccess.Lock() //锁 v2 fmt.Printf("sum = %d\n", v1.value+v2.value) v2.memAccess.Unlock() v1.memAccess.Unlock() } product := func(v1, v2 *value) { defer wg.Done() v2.memAccess.Lock() // 锁 v2 time.Sleep(2 * time.Second) v1.memAccess.Lock() // 锁 v1 fmt.Printf("product = %d\n", v1.value*v2.value) v1.memAccess.Unlock() v2.memAccess.Unlock() } var v1, v2 value v1.value = 1 v2.value = 1 wg.Add(2) go sum(&v1, &v2) go product(&v1, &v2) wg.Wait() } 运行结果 === RUN   TestDeadLock fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan receive]: testing.(*T).Run(0xc000122480, 0x116dd2c, 0xc, 0x1176e68, 0x1084de6)  /usr/local/go/src/testing/testing.go:1240 +0x2da testing.runTests.func1(0xc000122300)  /usr/local/go/src/testing/testing.go:1512 +0x78 testing.tRunner(0xc000122300, 0xc00012dde0)  /usr/local/go/src/testing/testing.go:1194 +0xef testing.runTests(0xc0001320d8, 0x12540e0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x116e218)  /usr/local/go/src/testing/testing.go:1510 +0x2fe testing.(*M).Run(0xc00014c080, 0x0)  /usr/local/go/src/testing/testing.go:1418 +0x1eb main.main()  _testmain.go:51 +0x138 可以看到上述运行结果中出现 fatal error: all goroutines are asleep - deadlock!  线程T1 先获得v1 ,然后获得v2, 线程T2 先获得v2，然后获得v1。这样满足了死锁循环等待等条件，会造成死锁。 到此这篇关于Go 语言中的死锁问题解决的文章就介绍到这了,更多相关Go 死锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

强类型语言有它的优势，但也有不便利的地方，最典型的就是类型转换。Golang 作为一门强类型语言，而且不支持隐式类型转换，因此这个问题更突出。虽然 Go 提供了不少方式进行类型转换，包括相关的标准库，比如 strconv 包。 然而，strconv 包使用没那么方便，比如 "8" 转为 int 类型： s := "8" i, err := strconv.Atoi(s) 你必须对 err 进行处理，因为返回两个值，没法直接将结果传递给接收 int 参数的函数，使用不方便。 今天给大家介绍一个第三方库，专门处理类型转换的问题。 01 为什么需要类型转换 有一些场景会需要使用类型转换： 从 yaml、toml、json 等配置文件中读取数据； 从网络接收请求数据； 其他通过 interface{} 处理数据的情况； 。。。 转换为正确的类型，能充分利用强类型的好处，让程序更健壮、更安全。 02 spf13/cast 第三方包 github.com/spf13/cast 专门解决类型转换的问题，这个包产生于 hugo。当时主要用于处理 yaml 等配置文件数据的转换。该包不会 panic。 该包目前有 1.6k+ 的 Star，有超过 4000 多个开源项目使用了该包。 这个包使用很简单，主要有两套函数： 1）To_ 形式函数 这些函数始终返回所需的类型。如果无法正确转换为对应的类型，则返回目标类型的零值。 支持的类型包括所有的基本数据类型，还支持 time.Time、time.Duration、slice、map 等常用类型。 比如： cast.ToString("mayonegg") // "mayonegg" cast.ToString(8) // "8" cast.ToString(8.31) // "8.31" cast.ToString([]byte("one time")) // "one time" cast.ToString(nil) // "" cast.ToTime("2021-08-10 22:00:00") // 2021-08-10 22:00:00 +0000 UTC 注意，转换为 time.Time 时，需要注意时区问题。ToTime 默认使用 UTC，如果想用其他时区，得类似这么做： secondsEastOfUTC := int((8 * time.Hour).Seconds()) beijing := time.FixedZone("Beijing Time", secondsEastOfUTC) fmt.Println(cast.ToTimeInDefaultLocation("2021-08-10 22:00:00", beijing)) 当然，你也可以这样： fmt.Println(cast.ToTimeInDefaultLocation("2021-08-10 22:00:00", time.Local)) 不过，Local 表示本地时区，要明确这个本地是不是你想要的。 2）To_E 形式函数 E 表示 error，也就是说，这一系列函数会返回 error。在无法进行类型转换时，会将错误原因返回。To_ 形式内部调用的是 To_E 形似，只是它忽略了错误。 这种形式就不举例了。一般地，除非你需要区分零值是因为出错导致的还是本身就是零值，否则应该使用 To_ 系列函数，毕竟更省事。 03 总结 大概率，不少公司都有自己类似的库。如果没有，可以考虑使用该库，这样的轮子，没太多必要造。不过这个库有一点我不太喜欢，就是没法指定默认值。 比如，我想在转换失败时，返回我的默认值，而不是默认零值，这个包做不到。常见的场景就是，处理用户可选输入，如果用户没输入，给一个默认值。 配置文件也有这样的场景，比如某个配置项如果没有配置，我希望硬编码一个默认值。因为 cast 不支持，依赖 cast 的 github.com/spf13/viper 库也不支持默认值，导致我会写出这样的繁琐代码： viper.SetDefault("listen.port", "2021") port := viper.GetString("listen.port") 我更希望的是这样的代码： port := viper.GetString("listen.port", "2021") // listen.port 没设置时，返回 2021 到此这篇关于Go 第三方库之类型转换问题的文章就介绍到这了,更多相关Go 第三方库类型转换内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言 先来看一道面试题： 对已经关闭的 chan 进行读写，会怎么样？为什么？ 在上一篇学习 Go 协程的文章中，知道 go关键字可以用来开启一个 goroutine 进行任务处理，但多个任务之间如果需要通信，就需要用到通道（channel）了。 一、Channel的定义 声明并初始化一个通道，可以使用 Go 语言的内建函数 make，同时指定该通道类型的元素类型，下面声明了一个 chan int 类型的 channel: ch := make(chan int) 二、Channel的操作 发送（写）：发送操作包括了“复制元素值”和“放置副本到通道内部”这两个步骤。即：进入通道的并不是操作符右边的那个元素值，而是它的副本。 ch := make(chan int) // write to channel ch <- x 接收（读）：接收操作包含了“复制通道内的元素值”、“放置副本到接收方”、“删掉原值”三个步骤。 ch := make(chan int) // read from channel x <- ch // another way to read x = <- ch 关闭：关闭 channel 会产生一个广播机制，所有向 channel 读取消息的 goroutine 都会收到消息。 ch := make(chan int) close(ch) 从一个已关闭的 channel 中读取消息永远不会阻塞，并且会返回一个为 false 的 ok-idiom，可以用它来判断 channel 是否关闭： v, ok := <-ch 如果 ok 是false，表明接收的 v 是产生的零值，这个 channel 被关闭了或者为空。 三、Channel发送和接收操作的特点 一个通道相当于一个先进先出（FIFO）的队列：也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。 对于同一个通道，发送操作之间和接收操作之间是互斥的：同一时刻，对同一通道发送多个元素，直到这个元素值被完全复制进该通道之后，其他针对该通道的发送操作才可能被执行。接收也是如此。 发送操作和接收操作中，对元素值的处理是不可分割的：前面我们知道发送一个值到通道，是先复制值，再将该副本移动到通道内部，“不可分割”指的是发送操作要么还没复制元素值，要么已经复制完毕，绝不会出现只复制了一部分的情况。接收也是同理，在准备好元素值的副本之后，一定会删除掉通道中的原值，绝不会出现通道中仍有残留的情况。 发送操作和接收操作在完全完成之前会被阻塞：发送操作包括了“复制元素值”和“放置副本到通道内部”这两个步骤。在这两个步骤完全完成之前，发起这个发送操作的那句代码会一直阻塞在那里，在它之后的代码不会有执行的机会，直到阻塞解除。 四、Channel的类型 channel 分为不带缓存的 channel 和带缓存的 channel。 使用 make 声明一个通道类型变量时，除了指定通道的元素类型，还可以指定通道的容量，也就是通道最多可以缓存多少个元素值，当容量为 0 时，该通道为非缓冲通道，当容量大于 0 时，该通道为带有缓冲的通道。 ch := make(chan int) //无缓冲的channel ch := make(chan int, 3) //带缓冲的channel 非缓冲通道和缓冲通道有着不同的数据传递方式： 非缓冲通道：无论是发送操作还是接收操作，一开始执行就会被阻塞，直到配对的操作也开始执行，才会继续传递。即：只有收发双方对接上了，数据才会被传递。数据直接从发送方复制到接收方。非缓冲通道传递数据的方式是同步的。 缓冲通道：如果通道已满，对它的所有发送操作都会被阻塞，直到通道中有元素值被接收走。反之，如果通道已空，那么对它的所有接收操作都会被阻塞，直到通道中有新的元素值出现。元素值会先从发送方复制到缓冲通道，之后再由缓冲通道复制给接收方。缓冲通道传递数据的方式是异步的。 五、Channel的源码学习 Channel 的主要实现在 src/runtime/chan.go 中，go 版本为 go version go1.14.6 darwin/amd64这里主要看 chansend 如何实现的。 func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool { if c == nil { if !block { return false } gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2) throw("unreachable") } if debugChan { print("chansend: chan=", c, "\n") } if raceenabled { racereadpc(c.raceaddr(), callerpc, funcPC(chansend)) } // Fast path: check for failed non-blocking operation without acquiring the lock. // // After observing that the channel is not closed, we observe that the channel is // not ready for sending. Each of these observations is a single word-sized read // (first c.closed and second c.recvq.first or c.qcount depending on kind of channel). // Because a closed channel cannot transition from 'ready for sending' to // 'not ready for sending', even if the channel is closed between the two observations, // they imply a moment between the two when the channel was both not yet closed // and not ready for sending. We behave as if we observed the channel at that moment, // and report that the send cannot proceed. // // It is okay if the reads are reordered here: if we observe that the channel is not // ready for sending and then observe that it is not closed, that implies that the // channel wasn't closed during the first observation. if !block && c.closed == 0 && ((c.dataqsiz == 0 && c.recvq.first == nil) || (c.dataqsiz > 0 && c.qcount == c.dataqsiz)) { return false } var t0 int64 if blockprofilerate > 0 { t0 = cputicks() } lock(&c.lock) if c.closed != 0 { unlock(&c.lock) panic(plainError("send on closed channel")) } if sg := c.recvq.dequeue(); sg != nil { // Found a waiting receiver. We pass the value we want to send // directly to the receiver, bypassing the channel buffer (if any). send(c, sg, ep, func() { unlock(&c.lock) }, 3) return true } if c.qcount < c.dataqsiz { // Space is available in the channel buffer. Enqueue the element to send. qp := chanbuf(c, c.sendx) if raceenabled { raceacquire(qp) racerelease(qp) } typedmemmove(c.elemtype, qp, ep) c.sendx++ if c.sendx == c.dataqsiz { c.sendx = 0 } c.qcount++ unlock(&c.lock) return true } if !block { unlock(&c.lock) return false } // Block on the channel. Some receiver will complete our operation for us. gp := getg() mysg := acquireSudog() mysg.releasetime = 0 if t0 != 0 { mysg.releasetime = -1 } // No stack splits between assigning elem and enqueuing mysg // on gp.waiting where copystack can find it. mysg.elem = ep mysg.waitlink = nil mysg.g = gp mysg.isSelect = false mysg.c = c gp.waiting = mysg gp.param = nil c.sendq.enqueue(mysg) gopark(chanparkcommit, unsafe.Pointer(&c.lock), waitReasonChanSend, traceEvGoBlockSend, 2) // Ensure the value being sent is kept alive until the // receiver copies it out. The sudog has a pointer to the // stack object, but sudogs aren't considered as roots of the // stack tracer. KeepAlive(ep) // someone woke us up. if mysg != gp.waiting { throw("G waiting list is corrupted") } gp.waiting = nil gp.activeStackChans = false if gp.param == nil { if c.closed == 0 { throw("chansend: spurious wakeup") } panic(plainError("send on closed channel")) } gp.param = nil if mysg.releasetime > 0 { blockevent(mysg.releasetime-t0, 2) } mysg.c = nil releaseSudog(mysg) return true } 从代码中可以看到： 有 goroutine 阻塞在 channel recv 队列上，此时缓存队列为空，直接将消息发送给 reciever goroutine,只产生一次复制。 当 channel 缓存队列有剩余空间时，将数据放到队列里，等待接收，接收后总共产生两次复制。 当 channel 缓存队列已满时，将当前 goroutine 加入 send 队列并阻塞。 所以，开头的面试题就有了答案： 读： 读已经关闭的 chan，能一直读到内容，但是读到的内容根据通道内关闭前是否有元素而不同。 如果 chan 关闭前，buffer 内有元素还未读，会正确读到 chan 内的值，且返回的第二个 bool 值为 true； 如果 chan 关闭前，buffer 内有元素已经被读完，chan 内无值，返回 channel 元素的零值，第二个 bool 值为 false。 写： 写已经关闭的 chan 会 panic。 总结 到此这篇关于Go中Channel发送和接收操作的文章就介绍到这了,更多相关Go Channel发送和接收内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

Switch简介 Go的switch的基本功能和C、Java类似： switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。 匹配项后面也不需要再加 break。 特点： switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case 重点介绍Go当中的Switch的两个特别点:** 表达式判断为true还需要执行后面的 case，可以使用 fallthrough type-switch 来判断某个 interface 变量中实际存储的变量类型 fallthrough 特点： 强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。 示例： package main ​ import "fmt" ​ func main() { switch { case true: fmt.Println("1、case条件语句为false!") fallthrough case false: fmt.Println("2、case条件语句为true!") default: fmt.Println("默认的case") } } 代码分析： 正常来说当执行完第一条语句以后不会执行第二个case，因为第二个case为false而且已经执行完了第一个true的case fallthrough关键字存在会强制执行第二个case Type Switch 特点： 判断某个 interface 变量中实际存储的变量类型 可以枚举类型，值类型和引用类型都可以 语法格式： switch x.(type){ case type: statement(s); case type: statement(s); /* 你可以定义任意个数的case */ default: /* 可选 */ statement(s); } 示例： package main ​ import ( "fmt" "go/types" ) ​ func main() { var inter interface{} = true ​ //使用变量去代替接口当中的值并且判断类型 switch i := inter.(type) { case types.Nil: fmt.Println("x的类型是:", i) case int: fmt.Println("x是int类型") case float64: fmt.Println("x是float64类型") case func(int2 int): fmt.Println("x是func(int)类型") case bool, string: fmt.Println("x是bool或string类型") default: fmt.Println("未知类型") } 可以直接判断接口当中的数据的数据类型 到此这篇关于Go中的条件语句Switch详解的文章就介绍到这了,更多相关Go条件语句Switch内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

说明         在golang中，时间转换都会通过Time类型做一系列转换。主要包含，时间戳和时间字符串，时间字符串转换成另外的格式。总之所有的转换都是通过Time类型做中间转换。参考文档：https://golang.org/pkg/time/ 操作 1，获取当前时间 t1 := time.Now() // 返回的是时间Time类型 fmt.Println(t1, reflect.TypeOf(t1)) 2，获取指定时间 t4 := time.Date(2019, 9, 30, 14, 28, 26, 23, time.Local) // 返回时间格式Time fmt.Println(t4) 3，获取当前时间戳 t1 := time.Now() t1Second := t1.Unix() // 获取秒的时间戳 fmt.Println(t1Second) t1Nano := t1.UnixNano() // 获取毫秒时间戳 fmt.Println(t1Nano) 4，时间戳转时间time.Time timeStamp := 1569826535 t := time.Unix(int64(timeStamp), 0) // time.Time strTime := t.Format("2006-01-02 15:04:05") fmt.Println(strTime) // 2019-09-30 14:55:35 5，时间字符串转时间time.Time s := "2019年9月30日 15:10:30" // ---> 2019-09-30 15:10:30 t, err := time.Parse("2006年1月2日 15:4:5", s) if err != nil { fmt.Println(err.Error()) } result := t.Format("2006-01-02 15:04:05") fmt.Println(result) 注意：这个地方需要注意两点 1，时间模板必须是 2006年1月2日 15点4分5秒，不论怎么表述，都会是这个时间。 2，在转换的时候，传入的时间格式是什么样子，模板时间也必须写成什么样子。例如： 带转换的时间：2019-09-30 15:12:14  那么模板时间就应该是 2006-01-30 15:04:05 时间转换         通常转换的过程都是通过time.Time来做中间转换的，不论是时间戳格式转成时间格式，还是时间字符串转换成时间格式/时间其他格式/时间戳，都是通过time.Time格式来做的中转。 1，时间Time格式转时间戳，直接转换，因为Time类型可以转换成时间的任何格式和类型 t1 := time.Now() timeStamp := t1.Unix() 2，时间戳转时间字符串 timeStamp := 1569826535 t := time.Unix(int64(timeStamp), 0) // time.Time strTime := t.Format("2006-01-02 15:04:05") fmt.Println(strTime) // 2019-09-30 14:55:35 3，获取时间中的年月日时分秒星期 无论是给的时间戳还是时间格式，都先转换成time.Time timeStamp := 1569826535 // 2019-09-30 14:55:35 t := time.Unix(int64(timeStamp), 0) // time.Time year, month, day := t.Date() hour, minute, second := t.Clock() fmt.Println(year, month, day, hour, minute, second) // 同样可以根据时间格式提供的方法 // 可以获取星期几，还可以获取当前是一年的多少天 fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Weekday(), t.YearDay()) 4，时间加减法 timeStamp := 1569826535 // 2019-09-30 14:55:35 t := time.Unix(int64(timeStamp), 0) // time.Time // 时间年月日加减，如果是负数，怎表示减去多少 t2 := t.AddDate(0, -1, 0) fmt.Println(t2.Format("2006/01/02 15:04:05")) // 第二种写法，同样的是负数表示减法 t3 := t.Add(-time.Hour * 24) fmt.Println(t3.Format("2006/01/02 15:04:05")) 5，判断时间大小 // 判断某个时间是不是在某个时间之前/之后/相等，传入的参数必须是时间格式 t4 := t.After(time.Now()) t5 := t.Before(time.Now()) t6 := t.Equal(t) // 返回的是bool值 fmt.Println(t4, t5, t6) // false true true 到此这篇关于golang time常用方法详解的文章就介绍到这了,更多相关golang time常用方法内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

1. 需求 要求统计1-200000的数字中，哪些是素数？这个问题在本章开篇就提出来了，可以使用goroutine和channel来完成2.分析思路 传统的方法，就是使用一个循环，循环的判断各个数是不是素数【ok】 使用并发/并行的方式，将统计素数的任务分配给多个（x个）goroutine去完成，完成任务时间短 分析思路图：  代码实现： package main import ( "fmt" "time" ) // 需求： // 要求统计1-200000的数字，哪些是素数？这个问题在本章开篇就提出了，现在我们有goroutine和channel的知识后，就可以完成了【测试数据：80000】 // 分析思路： // 传统的方法，就是使用一个循环，循环的判断各个数是不是素数【ok】 // 使用并发/并行的方式，将统计素数的任务分配给多个（x个）goroutine去完成，完成任务时间短 // 1. 向intChan放入1-8000的数字 func putNum(intChan chan int) { for i := 1; i <= 20000; i++ { intChan <- i } // 关闭intChan close(intChan) } // 从intChan中取出数据，并判断是否为素数，如果是，就放入到primeChan func primeNum1(intChan chan int, primeChan chan int, exitChan chan bool) { // 使用for循环 var flag bool for { time.Sleep(time.Millisecond * 10) num, ok := <- intChan if !ok { //intChan取不到，且关闭了管道 break } flag = true // 假设是素数 // 判断num是不是素数 for i := 2; i < num; i++ { if num % i == 0 { // 说明该num不是素数 flag = false break } } if flag { // 将这个数放到primeChan primeChan<- num } } fmt.Println("有一个prieNum 协程因为取不到数据，退出") // 这里我们还不能关闭primeChan // 向exitChan写入true exitChan <- true } func main() { var intChan chan int = make(chan int, 1000) var primeChan chan int = make(chan int,2000) // 标识退出的管道 exitChan := make(chan bool,4) // 开启一个协程，向intChan放入 1-8000个数 go putNum(intChan) // 开启4个协程，从 intChan中取出数据，并判断是否为素数，如果是就放入到primeChan for i := 0; i < 10000; i++ { go primeNum1(intChan,primeChan,exitChan) } // 这里我们主线程，进行处理 go func() { for i := 0; i < 4; i++ { <-exitChan } // 当我们从exitChan中取出了4个结果，就可以放心的关闭primeChan close(primeChan) }() // 遍历我们的primeChan，把结果取出 for { res, ok := <- primeChan if !ok { break } // 将结果取出 fmt.Printf("素数=%d\n",res) } fmt.Println("main线程退出") } 结论：使用go协程结合channel后，执行的速度，会大大 提高 go中可以轻松开启1万个协程  到此这篇关于golang利用channel和goroutine完成统计素数的文章就介绍到这了,更多相关golang统计素数内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

一、需求 实现二级缓存 程序运行起来后提示：“请输入命令：”，如果输入getall，查询并显示所有人员的信息 第一次时查询mysql并将结果缓存在redis，设置60秒的过期时间 以后的每次查询，如果redis有数据就从redis加载，没有则重复上一步的操作 二、实现连接Mysql并执行查询语句 先实现需求二，当输入命令getall时，查询并显示所有人员的信息。 package main ​ import ( "fmt" _"github.com/go-sql-driver/mysql" "github.com/jmoiron/sqlx" ) ​ type Human struct { Name string `db:"name"` Age int `db:"age"` } func main() { var cmd string for{ fmt.Println("请输入命令：") fmt.Scan(&cmd) ​ switch cmd{ case "getall": //显示所有人的信息 GetAllPeople() case "exit": //退出程序 goto GAMEOVER default: fmt.Println("输入的命令有误，请重新输入！") } } GAMEOVER: fmt.Println("GAME OVER") ​ } ​ func GetAllPeople() { fmt.Println("allPeople") //先尝试拿缓存 GetPeopleFromRedis() db, _ := sqlx.Connect("mysql", "root:123456@tcp(localhost:3306)/mydb") defer db.Close() ​ var people []Human err := db.Select(&people, "select name,age from person") if err!=nil{ fmt.Println("查询失败!err=",err) } fmt.Println(people) CachePeople2Redis(people) } 第一步还是导包，需要在mysql驱动包前面加上下划线_，因为它只是一个驱动文件，并不需要在代码中调用它的有关API接口. 接下来的这个结构体中后面的db:"name" db:"age"一定要加反单引号，否则运行时会报错。（傻傻的编者刚开始这里就出现问题啦~） type Human struct { Name string `db:"name"` Age int `db:"age"` } 然后main函数里面都是一些基本语法知识，用了switch和goto这两个内容。 接下来就是连接数据库了，这里要用到数据库扩展包Sqlx，Sqlx包其实最大最大的优点是在查询方面，也就是使用select时优化得比较好。比原来的使用查询方便了不止一点。 db, _ := sqlx.Connect("mysql", "root:123456@tcp(localhost:3306)/mydb") driverName:mysql,表示驱动器的名称是mysql也就上面"github.com/go-sql-driver/mysql"导入的驱动器。 dataSourceName是root:123456@tcp(localhost:3306)/mydb 它的含义是 账户名:密码@tcp(ip:端口)/数据库名称。 将缓存查询结果到Redis,就是通过这个函数CachePeople2Redis(people)。 三、写一个错误处理函数 func HandleError(err error,why string) { if err != nil{ fmt.Println(err,why) os.Exit(1) } } 因为后面需要处理很多错误，而错误处理也是GO的一个特性，所以我们这先写一个错误处理函数。 四、设置二级缓存 func CachePeople2Redis(people []Human) { conn, _ := redis.Dial("tcp", "localhost:6379") defer conn.Close() for _,human := range people{ humanStr := fmt.Sprint(human) _, err := conn.Do("rpush", "people", humanStr) if err != nil{ fmt.Println("缓存失败(rpush people),err=",err) return } } _, err := conn.Do("expire", "people", 66) if err!=nil{ HandleError(err,"@expire people 60") } fmt.Println("缓存成功！") } redis.Dial()这个函数是用来连接redis的，需要给定网络协议和IP地址及端口号，redis的端口号默认为6379. defer conn.Close()表示延时结束与redis的连接，为了节省系统的io资源，需要及时关闭连接！刚入门时我们很容易忘记这个，需要我们养成习惯！ conn.Do()是用来执行数据库命令的，第一个参数是命令名，后面的参数是数据库命令的参数。它返回的结果中reply是字节数组[]byte类型，需要根据具体的业务类型进行数据类型转换。 这段代码先将people数组中的每一个human放入到redis的people列表中。然后再执行expire命令，将列表设置过期时间。 执行成功！下面是运行结果： 请输入命令： getall allPeople [{大扬 21} {小飞 21} {大红袍 1} {小芳 18}] 缓存成功！ 请输入命令： 然后去看看数据库里面存进去没有。 127.0.0.1:6379> lrange people 0 -1 1) "{\xe5\xa4\xa7\xe6\x89\xac 21}" 2) "{\xe5\xb0\x8f\xe9\xa3\x9e 21}" 3) "{\xe5\xa4\xa7\xe7\xba\xa2\xe8\xa2\x8d 1}" 4) "{\xe5\xb0\x8f\xe8\x8a\xb3 18}" 过了一分钟之后，再查看redis数据库内的数据。 127.0.0.1:6379> lrange people 0 -1 (empty list or set) 已经消失了。 再写一个函数： func GetPeopleFromRedis() (peopleStrs []string) { //连数据库 conn, _ := redis.Dial("tcp", "localhost:6379") //延迟关闭 defer conn.Close() //执行命令 reply, err := conn.Do("lrange", "people", 0, -1) //处理错误 HandleError(err,"@lrange people 0 -1") //类型转换 peopleStrs, err = redis.Strings(reply, err) //打印结果 fmt.Println("缓存拿取结果：",peopleStrs,err) return } 如果redis里面有就不需要从mysql里面取数据了。直接从redis里面利用lrange命令来获取people的所有值。 到此这篇 一、需求 实现二级缓存 程序运行起来后提示：“请输入命令：”，如果输入getall，查询并显示所有人员的信息 第一次时查询mysql并将结果缓存在redis，设置60秒的过期时间 以后的每次查询，如果redis有数据就从redis加载，没有则重复上一步的操作 二、实现连接Mysql并执行查询语句 先实现需求二，当输入命令getall时，查询并显示所有人员的信息。 package main ​ import ( "fmt" _"github.com/go-sql-driver/mysql" "github.com/jmoiron/sqlx" ) ​ type Human struct { Name string `db:"name"` Age int `db:"age"` } func main() { var cmd string for{ fmt.Println("请输入命令：") fmt.Scan(&cmd) ​ switch cmd{ case "getall": //显示所有人的信息 GetAllPeople() case "exit": //退出程序 goto GAMEOVER default: fmt.Println("输入的命令有误，请重新输入！") } } GAMEOVER: fmt.Println("GAME OVER") ​ } ​ func GetAllPeople() { fmt.Println("allPeople") //先尝试拿缓存 GetPeopleFromRedis() db, _ := sqlx.Connect("mysql", "root:123456@tcp(localhost:3306)/mydb") defer db.Close() ​ var people []Human err := db.Select(&people, "select name,age from person") if err!=nil{ fmt.Println("查询失败!err=",err) } fmt.Println(people) CachePeople2Redis(people) } 第一步还是导包，需要在mysql驱动包前面加上下划线_，因为它只是一个驱动文件，并不需要在代码中调用它的有关API接口. 接下来的这个结构体中后面的db:"name" db:"age"一定要加反单引号，否则运行时会报错。（傻傻的编者刚开始这里就出现问题啦~） type Human struct { Name string `db:"name"` Age int `db:"age"` } 然后main函数里面都是一些基本语法知识，用了switch和goto这两个内容。 接下来就是连接数据库了，这里要用到数据库扩展包Sqlx，Sqlx包其实最大最大的优点是在查询方面，也就是使用select时优化得比较好。比原来的使用查询方便了不止一点。 db, _ := sqlx.Connect("mysql", "root:123456@tcp(localhost:3306)/mydb") driverName:mysql,表示驱动器的名称是mysql也就上面"github.com/go-sql-driver/mysql"导入的驱动器。 dataSourceName是root:123456@tcp(localhost:3306)/mydb 它的含义是 账户名:密码@tcp(ip:端口)/数据库名称。 将缓存查询结果到Redis,就是通过这个函数CachePeople2Redis(people)。 三、写一个错误处理函数 func HandleError(err error,why string) { if err != nil{ fmt.Println(err,why) os.Exit(1) } } 因为后面需要处理很多错误，而错误处理也是GO的一个特性，所以我们这先写一个错误处理函数。 四、设置二级缓存 func CachePeople2Redis(people []Human) { conn, _ := redis.Dial("tcp", "localhost:6379") defer conn.Close() for _,human := range people{ humanStr := fmt.Sprint(human) _, err := conn.Do("rpush", "people", humanStr) if err != nil{ fmt.Println("缓存失败(rpush people),err=",err) return } } _, err := conn.Do("expire", "people", 66) if err!=nil{ HandleError(err,"@expire people 60") } fmt.Println("缓存成功！") } redis.Dial()这个函数是用来连接redis的，需要给定网络协议和IP地址及端口号，redis的端口号默认为6379. defer conn.Close()表示延时结束与redis的连接，为了节省系统的io资源，需要及时关闭连接！刚入门时我们很容易忘记这个，需要我们养成习惯！ conn.Do()是用来执行数据库命令的，第一个参数是命令名，后面的参数是数据库命令的参数。它返回的结果中reply是字节数组[]byte类型，需要根据具体的业务类型进行数据类型转换。 这段代码先将people数组中的每一个human放入到redis的people列表中。然后再执行expire命令，将列表设置过期时间。 执行成功！下面是运行结果： 请输入命令： getall allPeople [{大扬 21} {小飞 21} {大红袍 1} {小芳 18}] 缓存成功！ 请输入命令： 然后去看看数据库里面存进去没有。 127.0.0.1:6379> lrange people 0 -1 1) "{\xe5\xa4\xa7\xe6\x89\xac 21}" 2) "{\xe5\xb0\x8f\xe9\xa3\x9e 21}" 3) "{\xe5\xa4\xa7\xe7\xba\xa2\xe8\xa2\x8d 1}" 4) "{\xe5\xb0\x8f\xe8\x8a\xb3 18}" 过了一分钟之后，再查看redis数据库内的数据。 127.0.0.1:6379> lrange people 0 -1 (empty list or set) 已经消失了。 再写一个函数： func GetPeopleFromRedis() (peopleStrs []string) { //连数据库 conn, _ := redis.Dial("tcp", "localhost:6379") //延迟关闭 defer conn.Close() //执行命令 reply, err := conn.Do("lrange", "people", 0, -1) //处理错误 HandleError(err,"@lrange people 0 -1") //类型转换 peopleStrs, err = redis.Strings(reply, err) //打印结果 fmt.Println("缓存拿取结果：",peopleStrs,err) return } 如果redis里面有就不需要从mysql里面取数据了。直接从redis里面利用lrange命令来获取people的所有值。 到此这篇Go语言 ......查看全文

哈希算法  md5 128bit，16字节 如：md5 (“hello world!”) = fc3ff98e8c6a0d3087d515c0473f8677 // 32位16进制数字 func Test(t *testing.T) { //方法一 str := "hello world!" has := md5.Sum([]byte(str)) md5str1 := fmt.Sprintf("%x", has) //将[]byte转成16进制 t.Log(md5str1) //方法二 w := md5.New() io.WriteString(w, str) md5str2 := fmt.Sprintf("%x", w.Sum(nil)) t.Log(md5str2) } SHA1 160bit，20字节 如：SHA1 (“hello world!”) = 430ce34d020724ed75a196dfc2ad67c77772d169 // 40位16进制数字 func Test(t *testing.T) { str := "hello world!" //产生一个散列值得方式是 sha1.New()，sha1.Write(bytes)，然后 sha1.Sum([]byte{})。 h := sha1.New() //写入要处理的字节。 h.Write([]byte(str)) //SHA1 值经常以 16 进制输出，例如在 git commit 中。 t.Log(hex.EncodeToString(h.Sum(nil))) } RIPEMD-160 160bit，20字节 如：RIPEMD-160 (“hello world!”) = dffd03137b3a333d5754813399a5f437acd694e5 // 40位16进制数字 func Test(t *testing.T) { str := "hello world!" h := ripemd160.New() h.Write([]byte(str)) t.Log(hex.EncodeToString(h.Sum(nil))) } SHA256 256bit，32字节 如：SHA256 (“hello world!”) = 7509e5bda0c762d2bac7f90d758b5b2263fa01ccbc542ab5e3df163be08e6ca9 // 64位16进制数字 func Test(t *testing.T) { str := "hello world!" // 第一种调用方法 sum := sha256.Sum256([]byte(str)) t.Logf("%x\n", sum) // 第二种调用方法 h := sha256.New() io.WriteString(h,str) t.Log(hex.EncodeToString(h.Sum(nil))) } SHA256实现原理 SHA-256算法输⼊报⽂的最⼤⻓度不超过2^64 bit，输⼊按512bit分组进⾏处理，产⽣的输出是⼀个256bit的报⽂摘要。 SHA256算法包括以下⼏步： 附加填充⽐特 对报⽂进⾏填充，使报⽂⻓度与448 模512 同余（⻓度=448 mod512）,填充的⽐特数范围是1 到512，填充⽐特串的最⾼位为1,其余位为0。就是先在报⽂后⾯加⼀个 1，再加很多个0，直到⻓度满⾜mod512=448。为什么是448，因为448+64=512。第⼆步会加上⼀个64bit的原始报⽂的 ⻓度信息。附加⻓度值 将⽤64bit 表示的初始报⽂（填充前）的位⻓度附加在步骤1的结果后（低位字节优先）初始化缓存 使⽤⼀个256bit 的缓存来存放该散列函数的中间及最终结果。该缓存表示为： A=0x6A09E667 B=0xBB67AE85 C=0x3C6EF372 D=0xA54FF53A E=0x510E527F F=0x9B05688C G=0x1F83D9AB H=0x5BE0CD19处理512bit（16 个字）报⽂分组序列 该算法使⽤了六种基本逻辑函数，由64 步迭代运算组成。每步都以256bit 缓存ABCDEFGH 为输⼊，然后更新缓存内容。每步使⽤⼀个32bit 常数值Kt 和⼀个32bit Wt。 SHA512 512bit，64字节 如：SHA512 (“hello world!”) = db9b1cd3262dee37756a09b9064973589847caa8e53d31a9d142ea2701b1b28abd97838bb9a27068ba305dc8d04a45a1fcf079de54d607666996b3cc54f6b67c // 128位16进制数字 func Test(t *testing.T) { str := "hello world!" // 第一种调用方法 sum := sha512.Sum512([]byte(str)) t.Logf("%x\n", sum) // 第二种调用方法 h := sha512.New() io.WriteString(h,str) t.Log(hex.EncodeToString(h.Sum(nil))) } 加密模式 加密一般分为对称加密(Symmetric Key Encryption)和非对称加密(Asymmetric Key Encryption)。 对称加密又分为分组加密和序列密码。 分组密码，也叫块加密(block cyphers)，一次加密明文中的一个块。是将明文按一定的位长分组，明文组经过加密运算得到密文组，密文组经过解密运算（加密运算的逆运算），还原成明文组。 序列密码，也叫流加密(stream cyphers)，一次加密明文中的一个位。是指利用少量的密钥（制乱元素）通过某种复杂的运算（密码算法）产生大量的伪随机位流，用于对明文位流的加密。 解密是指用同样的密钥和密码算法及与加密相同的伪随机位流，用以还原明文位流。 分组加密算法中，有ECB,CBC,CFB,OFB这几种算法模式。 加密模式 解释 ECB 最基本的加密模式，也就是通常理解的加密，相同的明⽂将永远加密成相同的密⽂，⽆初始向量，容易受到密码本重放攻击，⼀般情况下很少⽤ CBC 明⽂被加密前要与前⾯的密⽂进⾏异或运算后再加密，因此只要选择不同的初始向量，相同的密⽂加密后会形成不同的密⽂，这是⽬前应⽤最⼴泛的模式。CBC加密后的密⽂是上下⽂相关的，但明⽂的错误不会传递到后续分组，但如果⼀个分组丢失，后⾯的分组将全部作废(同步错误) CFB 类似于⾃同步序列密码，分组加密后，按8位分组将密⽂和明⽂进⾏移位异或后得到输出同时反馈回移位寄存器，优点最⼩可以按字节进⾏加解密，也可以是n位的，CFB也是上下⽂相关的，CFB模式下，明⽂的⼀个错误会影响后⾯的密⽂(错误扩散)。 OFB 将分组密码作为同步序列密码运⾏，和CFB相似，不过OFB⽤的是前⼀个n位密⽂输出分组反馈回移位寄存器，OFB没有错误扩散问题 对称加密 最常用的对称加密算法DES、3DES（TripleDES）和AES，常采用的填充⽅式是NoPadding（不填充）、Zeros填充（0填充）、PKCS5Padding填充。 加密算法要求明文需要按一定长度对齐，叫做块大小(BlockSize)，比如8字节，那么对于一段任意的数据，加密前需要对最后一个块填充到8 字节，解密后需要删除掉填充的数据。 填充⽅式 解释 ZeroPadding 数据长度不对齐时使用0填充，否则不填充 PKCS7Padding 假设数据长度需要填充n(n>0)个字节才对齐，那么填充n个字节，每个字节都是n;如果数据本身就已经对齐了，则填充一块长度为块大小的数据，每个字节都是块大小 PKCS5Padding PKCS7Padding的子集，块大小固定为8字节 由于使用PKCS7Padding/PKCS5Padding填充时，最后一个字节肯定为填充数据的长度，所以在解密后可以准确删除填充的数据，而使用ZeroPadding填充时，没办法区分真实数据与填充数据，所以只适合以\0结尾的字符串加解密。 对称加密需要的填充函数 func PKCS5Padding(data []byte, blockSize int) []byte { padding := blockSize - len(data)%blockSize padtext := bytes.Repeat([]byte{byte(padding)}, padding) return append(data, padtext...) } func PKCS5UnPadding(data []byte) []byte { length := len(data) // 去掉最后⼀个字节 unpadding 次 unpadding := int(data[length-1]) return data[:(length - unpadding)] } func ZeroPadding(data []byte, blockSize int) []byte { padding := blockSize - len(data)%blockSize padtext := bytes.Repeat([]byte{0}, padding) return append(data, padtext...) } func ZeroUnPadding(data []byte) []byte { return bytes.TrimRightFunc(data, func(r rune) bool { return r == rune(0) }) } DES //DES加密字节数组，返回字节数组 func DesEncrypt(originalBytes, key []byte) ([]byte, error) { block, err := des.NewCipher(key) if err != nil { return nil, err } originalBytes = PKCS5Padding(originalBytes, block.BlockSize()) blockMode := cipher.NewCBCEncrypter(block, key) cipherArr := make([]byte, len(originalBytes)) blockMode.CryptBlocks(cipherArr, originalBytes) return cipherArr, nil } //DES解密字节数组，返回字节数组 func DesDecrypt(cipherBytes, key []byte) ([]byte, error) { block, err := des.NewCipher(key) if err != nil { return nil, err } blockMode := cipher.NewCBCDecrypter(block, key) originalText := make([]byte, len(cipherBytes)) blockMode.CryptBlocks(originalText, cipherBytes) originalText = PKCS5UnPadding(originalText) return originalText, nil } //DES加密⽂本，返回加密后⽂本 func DesEncryptString(originalText string, key []byte) (string, error) { cipherArr, err := DesEncrypt([]byte(originalText), key) if err != nil { return "", err } base64str := base64.StdEncoding.EncodeToString(cipherArr) return base64str, nil } //对加密⽂本进⾏DES解密，返回解密后明⽂ func DesDecryptString(cipherText string, key []byte) (string, error) { cipherArr, _ := base64.StdEncoding.DecodeString(cipherText) cipherArr, err := DesDecrypt(cipherArr, key) if err != nil { return "", err } return string(cipherArr), nil } 3DES // 3DES加密字节数组，返回字节数组 func TripleDesEncrypt(originalBytes, key []byte) ([]byte, error) { block, err := des.NewTripleDESCipher(key) if err != nil { return nil, err } originalBytes = PKCS5Padding(originalBytes, block.BlockSize()) // originalBytes = ZeroPadding(originalBytes, block.BlockSize()) blockMode := cipher.NewCBCEncrypter(block, key[:8]) cipherArr := make([]byte, len(originalBytes)) blockMode.CryptBlocks(cipherArr, originalBytes) return cipherArr, nil } // 3DES解密字节数组，返回字节数组 func TripleDesDecrypt(cipherBytes, key []byte) ([]byte, error) { block, err := des.NewTripleDESCipher(key) if err != nil { return nil, err } blockMode := cipher.NewCBCDecrypter(block, key[:8]) originalArr := make([]byte, len(cipherBytes)) blockMode.CryptBlocks(originalArr, cipherBytes) originalArr = PKCS5UnPadding(originalArr) // origData = ZeroUnPadding(origData) return originalArr, nil } // 3DES加密字符串，返回base64处理后字符串 func TripleDesEncrypt2Str(originalText string, key []byte) (string, error) { block, err := des.NewTripleDESCipher(key) if err != nil { return "", err } originalData := PKCS5Padding([]byte(originalText), block.BlockSize()) // originalData = ZeroPadding(originalData, block.BlockSize()) blockMode := cipher.NewCBCEncrypter(block, key[:8]) cipherArr := make([]byte, len(originalData)) blockMode.CryptBlocks(cipherArr, originalData) cipherText := base64.StdEncoding.EncodeToString(cipherArr) return cipherText, nil } // 3DES解密base64处理后的加密字符串，返回明⽂字符串 func TripleDesDecrypt2Str(cipherText string, key []byte) (string, error) { cipherArr, _ := base64.StdEncoding.DecodeString(cipherText) block, err := des.NewTripleDESCipher(key) if err != nil { return "", err } blockMode := cipher.NewCBCDecrypter(block, key[:8]) originalArr := make([]byte, len(cipherArr)) blockMode.CryptBlocks(originalArr, cipherArr) originalArr = PKCS5UnPadding(originalArr) // origData = ZeroUnPadding(origData) return string(originalArr), nil } AES //AES加密字节数组，返回字节数组 func AesEncrypt(originalBytes, key []byte) ([]byte, error) { block, err := aes.NewCipher(key) if err != nil { return nil, err } blockSize := block.BlockSize() originalBytes = PKCS5Padding(originalBytes, blockSize) // originalBytes = ZeroPadding(originalBytes, block.BlockSize()) blockMode := cipher.NewCBCEncrypter(block, key[:blockSize]) cipherBytes := make([]byte, len(originalBytes)) // 根据CryptBlocks⽅法的说明，如下⽅式初始化crypted也可以 // crypted := originalBytes blockMode.CryptBlocks(cipherBytes, originalBytes) return cipherBytes, nil } //AES解密字节数组，返回字节数组 func AesDecrypt(cipherBytes, key []byte) ([]byte, error) { block, err := aes.NewCipher(key) if err != nil { return nil, err } blockSize := block.BlockSize() blockMode := cipher.NewCBCDecrypter(block, key[:blockSize]) originalBytes := make([]byte, len(cipherBytes)) // origData := cipherBytes blockMode.CryptBlocks(originalBytes, cipherBytes) originalBytes = PKCS5UnPadding(originalBytes) // origData = ZeroUnPadding(origData) return originalBytes, nil } //AES加密⽂本，返回对加密后字节数组进⾏base64处理后字符串 func AesEncryptString(originalText string, key []byte) (string, error) { cipherBytes, err := AesEncrypt([]byte(originalText), key) if err != nil { return "", err } base64str := base64.StdEncoding.EncodeToString(cipherBytes) return base64str, nil } //AES解密⽂本，对Base64处理后的加密⽂本进⾏AES解密，返回解密后明⽂ func AesDecryptString(cipherText string, key []byte) (string, error) { cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText) cipherBytes, err := AesDecrypt(cipherBytes, key) if err != nil { return "", err } return string(cipherBytes), nil } ⾮对称加密 RSA算法也是一个块加密算法（ block cipher algorithm），总是在一个固定长度的块上进行操作。但跟AES等不同的是，block length是跟key length有关的。 每次RSA加密的明文的长度是受RSA填充模式限制的，但是RSA每次加密的块长度就是key length。 填充⽅式 密文长度 PKCS1Padding 必须 比 RSA 秘钥模长(modulus) 短至少11个字节, 也就是RSA_SIZE(rsa) – 11 OAEPPadding RSA_SIZE(rsa) – 41 NOPadding 可以和RSA钥模长一样长，如果输入的明文过长，必须切割，　然后填充 在不同的padding模式下，使用相同长度的密钥可以加密的数据最大长度不同在不同密钥长度下，使用相同的padding模式可以加密的数据最大长度也不同 因此，脱离了密钥长度而讨论padding模式可以加密的最大长度是不严谨的。常用的密钥长度有1024bits，2048bits等，理论上1024bits的密钥可以加密的数据最大长度为1024bits（即1024/8 = 128bytes）。2048bits的密钥可以加密的数据最大长度为2048bits(2048/8 = 256bytes)，但是RSA在实际应用中不可能使用这种“教科书式的RSA”系统。实际应用中RSA经常与填充技术（padding）一起使用，可以增加RSA的安全性。 PKCS1 // 加密字节数组，返回字节数组 func RsaEncrypt(publicKey, origData []byte) ([]byte, error) { block, _ := pem.Decode(publicKey) if block == nil { return nil, errors.New("public key error") } pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes) if err != nil { return nil, err } pub := pubInterface.(*rsa.PublicKey) return rsa.EncryptPKCS1v15(rand.Reader, pub, origData) } // 解密字节数组，返回字节数组 func RsaDecrypt(privateKey, ciphertext []byte) ([]byte, error) { block, _ := pem.Decode(privateKey) if block == nil { return nil, errors.New("private key error!") } priv, err := x509.ParsePKCS1PrivateKey(block.Bytes) if err != nil { return nil, err } return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext) } // 加密字符串，返回base64处理的字符串 func RsaEncryptString(publicKey []byte, origData string) (string, error) { block, _ := pem.Decode(publicKey) if block == nil { return "", errors.New("public key error") } pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes) if err != nil { return "", err } pub := pubInterface.(*rsa.PublicKey) cipherArr, err := rsa.EncryptPKCS1v15(rand.Reader, pub, []byte(origData)) if err != nil { return "", err } else { return base64.StdEncoding.EncodeToString(cipherArr), nil } } // 解密经过base64处理的加密字符串，返回加密前的明⽂ func RsaDecryptString(privateKey []byte, cipherText string) (string, error) { block, _ := pem.Decode(privateKey) if block == nil { return "", errors.New("private key error!") } priv, err := x509.ParsePKCS1PrivateKey(block.Bytes) if err != nil { return "", err } cipherArr, _ := base64.StdEncoding.DecodeString(cipherText) originalArr, err := rsa.DecryptPKCS1v15(rand.Reader, priv, cipherArr) if err != nil { return "", err } else { return string(originalArr), nil } } OAEP // 加密 func EncryptOAEP(publicKey []byte, text string) (string, error) { block, _ := pem.Decode(publicKey) if block == nil { return "", errors.New("public key error") } pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes) if err != nil { return "", err } pub := pubInterface.(*rsa.PublicKey) secretMessage := []byte(text) rng := rand.Reader cipherdata, err := rsa.EncryptOAEP(sha1.New(), rng, pub, secretMessage, nil) if err != nil { return "", err } ciphertext := base64.StdEncoding.EncodeToString(cipherdata) return ciphertext, nil } // 解密 func DecryptOAEP(privateKey []byte, ciphertext string) (string, error) { block, _ := pem.Decode(privateKey) if block == nil { return "", errors.New("private key error!") } priv, err := x509.ParsePKCS1PrivateKey(block.Bytes) if err != nil { return "", err } cipherdata, _ := base64.StdEncoding.DecodeString(ciphertext) rng := rand.Reader plaintext, err := rsa.DecryptOAEP(sha1.New(), rng, priv, cipherdata, nil) if err != nil { return "", err } return string(plaintext), nil } 椭圆曲线加密算法ECC 椭圆曲线密码学（Elliptic curve cryptography，缩写为 ECC），是基于椭圆曲线数学理论实现的⼀种⾮对称加密算法。 ECC与RSA算法的优势对⽐ 椭圆曲线公钥系统是代替RSA的强有⼒的竞争者。 与经典的RSA、DSA等公钥密码体制相⽐，椭圆密码体制有以下优点： （1）安全性能更⾼（ECC可以使⽤更短的密钥）： 160位ECC加密算法的安全强度相当于1024位RSA加密； 210位ECC加密算法的安全强度相当于2048位RSA加密。 （2）处理速度快：计算量⼩，处理速度快 在私钥的处理速度上（解密和签名），ECC远 ⽐RSA、DSA快得多。 （3）存储空间占⽤⼩： ECC的密钥尺⼨和系统参数与RSA、DSA相⽐要⼩得多， 所以占⽤的存储空间⼩得多。 （4）带宽要求低使得ECC具有⼴泛的应⽤前景。ECC的这些特点使它必将取代RSA，成为通⽤的公钥加密算法。 //生成ECC椭圆曲线密钥对 func GenerateECCKey() (*ecdsa.PublicKey, *ecdsa.PrivateKey, error) { privateKey, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader) if err != nil { return nil, nil, err } publicKey := &privateKey.PublicKey return publicKey, privateKey, nil } //对消息的散列值生成数字签名 func SignECC(msg []byte) ([]byte, []byte) { //取得私钥 _, privateKey, err := GenerateECCKey() if err != nil { panic(err) } //计算哈希值 hash := sha256.New() //填入数据 hash.Write(msg) b := hash.Sum(nil) //对哈希值生成数字签名 r, s, err := ecdsa.Sign(rand.Reader, privateKey, b) if err != nil { panic(err) } rtext, _ := r.MarshalText() stext, _ := s.MarshalText() return rtext, stext } //验证数字签名 func VerifySignECC(msg []byte, rtext, stext []byte) bool { //取得公钥 publicKey, _, err := GenerateECCKey() if err != nil { panic(err) } //计算哈希值 hash := sha256.New() hash.Write(msg) b := hash.Sum(nil) //验证数字签名 var r, s big.Int if err := r.UnmarshalText(rtext); err != nil { panic(err) } if err := s.UnmarshalText(stext); err != nil { panic(err) } verify := ecdsa.Verify(publicKey, b, &r, &s) return verify } //测试 func Test(t *testing.T) { //模拟发送者 //要发送的消息 msg := []byte("hello world") //生成数字签名 rtext, stext := SignECC(msg) //模拟接受者 //接受到的消息 acceptmsg := []byte("hello world") //接收到的签名 acceptrtext := rtext acceptstext := stext //验证签名 verifySignECC := VerifySignECC(acceptmsg, acceptrtext, acceptstext) fmt.Println("验证结果：", verifySignECC) } 数字签名 数字签名的概念 1、签名不可伪造性； 2、签名不可抵赖的； 3、签名可信性，签名的识别和应⽤相对容易，任何⼈都可以验证签名的有效 性； 4、签名是不可复制的，签名与原⽂是不可分割的整体； 5、签名消息不可篡改，因为任意⽐特数据被篡改，其签名便被随之改变，那么 任何⼈可以验证⽽拒绝接受此签名。 椭圆曲线数字签名算法ECDSA //⽣成私钥和公钥，⽣成的私钥为结构体ecdsa.PrivateKey的指针 func NewKeyPair() (ecdsa.PrivateKey, []byte) { //⽣成secp256椭圆曲线 curve := elliptic.P256() //产⽣的是⼀个结构体指针，结构体类型为ecdsa.PrivateKey private, err := ecdsa.GenerateKey(curve, rand.Reader) if err != nil { log.Panic(err) } fmt.Printf("私钥：%x\n", private) fmt.Printf("私钥X：%x\n", private.X.Bytes()) fmt.Printf("私钥Y：%x\n", private.Y.Bytes()) fmt.Printf("私钥D：%x\n", private.D.Bytes()) //x坐标与y坐标拼接在⼀起，⽣成公钥 pubKey := append(private.X.Bytes(), private.Y.Bytes()...) //打印公钥，公钥⽤16进制打印出来⻓度为128，包含了x轴坐标与y轴坐标。 fmt.Printf("公钥：%x \n", pubKey) return *private, pubKey } //⽣成签名的DER格式 func MakeSignatureDerString(r, s string) string { // 获取R和S的⻓度 lenSigR := len(r) / 2 lenSigS := len(s) / 2 // 计算DER序列的总⻓度 lenSequence := lenSigR + lenSigS + 4 // 将10进制⻓度转16进制字符串 strLenSigR := DecimalToHex(int64(lenSigR)) strLenSigS := DecimalToHex(int64(lenSigS)) strLenSequence := DecimalToHex(int64(lenSequence)) // 拼凑DER编码 derString := "30" + strLenSequence derString = derString + "02" + strLenSigR + r derString = derString + "02" + strLenSigS + s derString = derString + "01" return derString } func DecimalToHex(n int64) string { if n < 0 { log.Println("Decimal to hexadecimal error: the argument must be greater than zero.") return "" } if n == 0 { return "0" } hex := map[int64]int64{10: 65, 11: 66, 12: 67, 13: 68, 14: 69, 15: 70} s := "" for q := n; q > 0; q = q / 16 { m := q % 16 if m > 9 && m < 16 { m = hex[m] s = fmt.Sprintf("%v%v", string(m), s) continue } s = fmt.Sprintf("%v%v", m, s) } return s } //验证签名1 func VerifySig(pubKey, message []byte, r, s *big.Int) bool { curve := elliptic.P256() //公钥的⻓度 keyLen := len(pubKey) //前⼀半为x轴坐标，后⼀半为y轴坐标 x := big.Int{} y := big.Int{} x.SetBytes(pubKey[:(keyLen / 2)]) y.SetBytes(pubKey[(keyLen / 2):]) rawPubKey := ecdsa.PublicKey{curve, &x, &y} //根据交易哈希、公钥、数字签名验证成功。ecdsa.Verify func Verify(pub *PublicKey, hash[] byte, r * big.Int, s * big.Int) bool res := ecdsa.Verify(&rawPubKey, message, r, s) return res } //验证签名2 func VerifySignature(pubKey, message []byte, r, s string) bool { curve := elliptic.P256() //公钥的⻓度 keyLen := len(pubKey) //前⼀半为x轴坐标，后⼀半为y轴坐标 x := big.Int{} y := big.Int{} x.SetBytes(pubKey[:(keyLen / 2)]) y.SetBytes(pubKey[(keyLen / 2):]) rawPubKey := ecdsa.PublicKey{curve, &x, &y} //根据交易哈希、公钥、数字签名验证成功。ecdsa.Verify func Verify(pub *PublicKey, hash[] byte, r * big.Int, s * big.Int) bool rint := big.Int{} sint := big.Int{} rByte, _ := hex.DecodeString(r) sByte, _ := hex.DecodeString(s) rint.SetBytes(rByte) sint.SetBytes(sByte) //fmt.Println("------", rint.SetBytes(rByte)) //fmt.Println("------", sint.SetBytes(sByte)) res := ecdsa.Verify(&rawPubKey, message, &rint, &sint) return res } //验证过程 func Test(t *testing.T) { //1、⽣成签名 fmt.Println("1、⽣成签名-------------------------------") //调⽤函数⽣成私钥与公钥 privKey, pubKey := NewKeyPair() //信息的哈希 msg := sha256.Sum256([]byte("hello world")) //根据私钥和信息的哈希进⾏数字签名，产⽣r和s r, s, _ := ecdsa.Sign(rand.Reader, &privKey, msg[:]) //⽣成r、s字符串 fmt.Println("-------------------------------") strSigR := fmt.Sprintf("%x", r) strSigS := fmt.Sprintf("%x", s) fmt.Println("r、s的10进制分别为：", r, s) fmt.Println("r、s的16进制分别为：", strSigR, strSigS) //r和s拼接在⼀起，形成数字签名的der格式 signatureDer := MakeSignatureDerString(strSigR, strSigS) //打印数字签名的16进制显示 fmt.Println("数字签名DER格式为：", signatureDer) fmt.Println() //2、签名验证过程 fmt.Println("2、签名验证过程-------------------------------") res := VerifySig(pubKey, msg[:], r, s) fmt.Println("签名验证结果：", res) res = VerifySignature(pubKey, msg[:], strSigR, strSigS) fmt.Println("签名验证结果：", res) } 字符编码/解码 Base64 Base64就是⼀种基于64个可打印字符来表示⼆进制数据的⽅法。Base64使⽤了26个⼩写字⺟、26个⼤写字⺟、10个数字以及两个符号（例如“+”和“/”），⽤于在电⼦邮件这样的基于⽂本的媒介中传输⼆进制数据。 Base64字符集： ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ Base64的步骤 将每个字符转成ASCII编码（10进制）将10进制编码转成2进制编码将2进制编码按照6位⼀组进⾏平分将6位⼀组的2进制数⾼位补零，然后转成10进制数将10进制数作为索引，从Base64编码表中查找字符每3个字符的⽂本将编码为4个字符⻓度（3 8=46） a. 若⽂本为3个字符，则正好编码为4个字符⻓度； b. 若⽂本为2个字符，则编码为3个字符，由于不⾜4个字符，则在尾部⽤⼀个“=”补⻬； c. 若⽂本为1个字符，则编码为2个字符，由于不⾜4个字符，则在尾部⽤两个“=”补⻬。 巨人的肩膀 从他人的工作中汲取经验来避免自己的错误重复，正如我们是站在巨人的肩膀上才能做出更好的成绩。 https://github.com/rubyhan1314/Golang-100-Days https://blog.csdn.net/luckydog612/article/details/80547758 https://www.cnblogs.com/yanzi-meng/p/9640578.html https://www.cnblogs.com/starwolf/p/3365834.html https://blog.csdn.net/u013073067/article/details/87086562 https://www.cnblogs.com/Terry-Wu/p/10314315.html http://blog.studygolang.com/2013/01/go%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86%E4%B9%8Bdes/ https://blog.csdn.net/kikajack/article/details/78329567 到此这篇关于Go中使用加密算法的方法的文章就介绍到这了,更多相关go 加密算法内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

本文主要针对Golang的内置库 net/http 做了简单的扩展，通过添加中间件的形式实现了管道(Pipeline)模式，这样的好处是各模块之间是低耦合的，符合单一职责原则，可以很灵活的通过中间件的形式添加一些功能到管道中，一次请求和响应在管道中的执行过程如下 首先, 我定义了三个测试的中间件 Middleware1,2,3 如下 func Middleware1(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Println("M1 in") next.ServeHTTP(w, r) fmt.Println("M1 out") }) } func Middleware2(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Println("M2 in") next.ServeHTTP(w, r) fmt.Println("M2 out") }) } func Middleware3(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Println("M3 in") next.ServeHTTP(w, r) fmt.Println("M3 out") }) } 这里中间件的入参和出参的类型都是 http.Handler, 然后在 next.ServeHTTP() 的前后分别输出了 In 和 Out. 接下来，定义一个 Pipeline 的方法，里面使用嵌套的形式, 使用了上面定义的三个测试的中间件. func Pipeline(next http.Handler) http.Handler { return Middleware1(Middleware2(Middleware3(next))) } 然后还需要业务代码，这里我定义了 LoginHandler 和 RegisterHandler 两个方法 func LoginHandler(w http.ResponseWriter, r *http.Request) { fmt.Println("Login...") w.Write([]byte("Login...")) } func RegisterHandler(w http.ResponseWriter, r *http.Request) { fmt.Println("Register...") w.Write([]byte("Register...")) } 最后修改程序的 main 函数, 在 Login 接口上使用上面添加过中间件的 Pipeline func main() { http.Handle("/Login", Pipeline(http.HandlerFunc(LoginHandler))) http.Handle("/Register", http.HandlerFunc(RegisterHandler)) http.ListenAndServe(":8080", nil) } 启动程序后，访问 http://localhost:8080/Login, 程序的输出如下，这和本文最上面的管道的流程图是一致的，然后访问 Register 接口, 控制台没有输出信息，当然也不会执行任何中间件。 现在已经实现了中间件的机制，但是，上面添加中间件是用嵌套的方法，这种方式不能说不太优雅，只能说非常的Low，接下来我们需要对管道进行优化 type Chain struct { middlewares []func(handler http.Handler) http.Handler } func Pipeline(next http.Handler) http.Handler { //return Middleware1(Middleware2(Middleware3(next))) return AddMiddlewares(Middleware1,Middleware2,Middleware3).Then(next) } func AddMiddlewares(m ...func(handlerFunc http.Handler) http.Handler) Chain { c := Chain{} c.middlewares = append(c.middlewares,m...) return c } func (c Chain) Then(next http.Handler) http.Handler { for i := range c.middlewares { prev := c.middlewares[len(c.middlewares)-1-i] next = prev(next) } return next } 首先定义了一个Chain 的struct，用来接收添加到管道中的中间件，在 AddMiddlewares() 函数中，接收了多个Handle, 然后组装到 Chain 对象并返回, 接下来调用 Then() 函数, 把管道中的中间件和业务的Handler 关联起来。在中间件的使用方式上， 这两种方法都是一样的，只需要调用 Pipeline() 方法就行了。 本文在go web中简单的实现了中间件的机制，这样带来的好处也是显而易见的，当然社区也有一些成熟的 middleware 组件，包括 Gin 一些Web框架中也包含了 middleware 相关的功能, 希望对您有用. 到此这篇关于Golang中实现简单的Http Middleware的文 本文主要针对Golang的内置库 net/http 做了简单的扩展，通过添加中间件的形式实现了管道(Pipeline)模式，这样的好处是各模块之间是低耦合的，符合单一职责原则，可以很灵活的通过中间件的形式添加一些功能到管道中，一次请求和响应在管道中的执行过程如下 首先, 我定义了三个测试的中间件 Middleware1,2,3 如下 func Middleware1(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Println("M1 in") next.ServeHTTP(w, r) fmt.Println("M1 out") }) } func Middleware2(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Println("M2 in") next.ServeHTTP(w, r) fmt.Println("M2 out") }) } func Middleware3(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Println("M3 in") next.ServeHTTP(w, r) fmt.Println("M3 out") }) } 这里中间件的入参和出参的类型都是 http.Handler, 然后在 next.ServeHTTP() 的前后分别输出了 In 和 Out. 接下来，定义一个 Pipeline 的方法，里面使用嵌套的形式, 使用了上面定义的三个测试的中间件. func Pipeline(next http.Handler) http.Handler { return Middleware1(Middleware2(Middleware3(next))) } 然后还需要业务代码，这里我定义了 LoginHandler 和 RegisterHandler 两个方法 func LoginHandler(w http.ResponseWriter, r *http.Request) { fmt.Println("Login...") w.Write([]byte("Login...")) } func RegisterHandler(w http.ResponseWriter, r *http.Request) { fmt.Println("Register...") w.Write([]byte("Register...")) } 最后修改程序的 main 函数, 在 Login 接口上使用上面添加过中间件的 Pipeline func main() { http.Handle("/Login", Pipeline(http.HandlerFunc(LoginHandler))) http.Handle("/Register", http.HandlerFunc(RegisterHandler)) http.ListenAndServe(":8080", nil) } 启动程序后，访问 http://localhost:8080/Login, 程序的输出如下，这和本文最上面的管道的流程图是一致的，然后访问 Register 接口, 控制台没有输出信息，当然也不会执行任何中间件。 现在已经实现了中间件的机制，但是，上面添加中间件是用嵌套的方法，这种方式不能说不太优雅，只能说非常的Low，接下来我们需要对管道进行优化 type Chain struct { middlewares []func(handler http.Handler) http.Handler } func Pipeline(next http.Handler) http.Handler { //return Middleware1(Middleware2(Middleware3(next))) return AddMiddlewares(Middleware1,Middleware2,Middleware3).Then(next) } func AddMiddlewares(m ...func(handlerFunc http.Handler) http.Handler) Chain { c := Chain{} c.middlewares = append(c.middlewares,m...) return c } func (c Chain) Then(next http.Handler) http.Handler { for i := range c.middlewares { prev := c.middlewares[len(c.middlewares)-1-i] next = prev(next) } return next } 首先定义了一个Chain 的struct，用来接收添加到管道中的中间件，在 AddMiddlewares() 函数中，接收了多个Handle, 然后组装到 Chain 对象并返回, 接下来调用 Then() 函数, 把管道中的中间件和业务的Handler 关联起来。在中间件的使用方式上， 这两种方法都是一样的，只需要调用 Pipeline() 方法就行了。 本文在go web中简单的实现了中间件的机制，这样带来的好处也是显而易见的，当然社区也有一些成熟的 middleware 组件，包括 Gin 一些Web框架中也包含了 middleware 相关的功能, 希望对您有用. 到此这篇关于Golang中实现简单的Http Middleware的文Go语言 ......查看全文

Go 协程超时控制 Select 阻塞方式 Context 方式 先说个场景： 假设业务中 A 服务需要调用 服务B，要求设置 5s 超时，那么如何优雅实现？ Select 超时控制 考虑是否可以用 select + time.After 方式进行实现 这里主要利用的是通道在携程之间通信的特点，当程序调用成功后，会向通道中发送信号。没调用成功前，通道会阻塞。 select { case res := <-c2: fmt.Println(res) case <-time.After(time.Second * 3): fmt.Println("timeout 2") } 当 c2 通道中有数据时，并且超时时间没有达到 3s，走 case res := <-c2 这个业务逻辑，当超时时间达到 3s , 走的 case <-time.After(time.Second * 3) 这个业务逻辑， 这样就可以实现超时 3s 的控制。 res:= <-c2 是因为channel 可以实现阻塞，那么 time.After 为啥可以阻塞呢？ 看 After 源码。sleep.go 可以看到其实也是 channel func After(d Duration) <-chan Time { return NewTimer(d).C } 完整代码示例： package timeout import ( "fmt" "testing" "time" ) func TestSelectTimeOut(t *testing.T) { // 在这个例子中， 假设我们执行了一个外部调用， 2秒之后将结果写入c1 c1 := make(chan string, 1) go func() { time.Sleep(time.Second * 2) c1 <- "result 1" }() // 这里使用select来实现超时， `res := <-c1`等待通道结果， // `<- Time.After`则在等待1秒后返回一个值， 因为select首先 // 执行那些不再阻塞的case， 所以这里会执行超时程序， 如果 // `res := <-c1`超过1秒没有执行的话 select { case res := <-c1: fmt.Println(res) case <-time.After(time.Second * 1): fmt.Println("timeout 1") } // 如果我们将超时时间设为3秒， 这个时候`res := <-c2`将在 // 超时case之前执行， 从而能够输出写入通道c2的值 c2 := make(chan string, 1) go func() { time.Sleep(time.Second * 2) c2 <- "result 2" }() select { case res := <-c2: fmt.Println(res) case <-time.After(time.Second * 3): fmt.Println("timeout 2") } } 运行结果： === RUN   TestSelectTimeOut timeout 1 result 2 --- PASS: TestSelectTimeOut (3.00s) PASS go timer 计时器 这个是 timer 类似的计时器实现，通用也是通过通道来发送数据。 package main import "time" import "fmt" func main() { // Ticker使用和Timer相似的机制， 同样是使用一个通道来发送数据。 // 这里我们使用range函数来遍历通道数据， 这些数据每隔500毫秒被 // 发送一次， 这样我们就可以接收到 ticker := time.NewTicker(time.Millisecond * 500) go func() { for t := range ticker.C { fmt.Println("Tick at", t) } }() // Ticker和Timer一样可以被停止。 一旦Ticker停止后， 通道将不再 // 接收数据， 这里我们将在1500毫秒之后停止 time.Sleep(time.Millisecond * 1500) ticker.Stop() fmt.Println("Ticker stopped") } go context context 监听是否有 IO 操作，开始从当前连接中读取网络请求，每当读取到一个请求则会将该cancelCtx传入，用以传递取消信号，可发送取消信号，取消所有进行中的网络请求。 go func(ctx context.Context, info *Info) { timeLimit := 120 timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeLimit)*time.Millisecond) defer func() { cancel() wg.Done() }() resp := DoHttp(timeoutCtx, info.req) }(ctx, info) 关键看业务代码: resp := DoHttp(timeoutCtx, info.req) 业务代码中包含 http 调用 NewRequestWithContext req, err := http.NewRequestWithContext(ctx, "POST", url, strings.NewReader(paramString)) 上面的代码，设置了过期时间，当DoHttp(timeoutCtx, info.req) 处理时间超过超时时间时，会自动截止，并且打印 context deadline exceeded。 看个代码： package main import ( "context" "fmt" "testing" "time" ) func TestTimerContext(t *testing.T) { now := time.Now() later, _ := time.ParseDuration("10s") ctx, cancel := context.WithDeadline(context.Background(), now.Add(later)) defer cancel() go Monitor(ctx) time.Sleep(20 * time.Second) } func Monitor(ctx context.Context) { select { case <-ctx.Done(): fmt.Println(ctx.Err()) case <-time.After(20 * time.Second): fmt.Println("stop monitor") } } 运行结果： === RUN   TestTimerContext context deadline exceeded --- PASS: TestTimerContext (20.00s) PASS Context 接口有如下： type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} } Deadline — 返回 context.Context 被取消的时间，也就是完成工作的截止日期； Done — 返回一个 Channel，这个 Channel 会在当前工作完成或者上下文被取消之后关闭，多次调用 Done 方法会返回同一个 Channel； Err — 返回 context.Context 结束的原因，它只会在 Done 返回的 Channel 被关闭时才会返回非空的值； 如果 context.Context 被取消，会返回 Canceled 错误； 如果 context.Context 超时，会返回 DeadlineExceeded 错误； Value — 从 context.Context 中获取键对应的值，对于同一个上下文来说，多次调用 Value 并传入相同的 Key 会返回相同的结果，该方法可以用来传递请求特定的数据； 到此这篇关于 Go 协程超时控制 Select 阻塞方式 Context 方式 先说个场景： 假设业务中 A 服务需要调用 服务B，要求设置 5s 超时，那么如何优雅实现？ Select 超时控制 考虑是否可以用 select + time.After 方式进行实现 这里主要利用的是通道在携程之间通信的特点，当程序调用成功后，会向通道中发送信号。没调用成功前，通道会阻塞。 select { case res := <-c2: fmt.Println(res) case <-time.After(time.Second * 3): fmt.Println("timeout 2") } 当 c2 通道中有数据时，并且超时时间没有达到 3s，走 case res := <-c2 这个业务逻辑，当超时时间达到 3s , 走的 case <-time.After(time.Second * 3) 这个业务逻辑， 这样就可以实现超时 3s 的控制。 res:= <-c2 是因为channel 可以实现阻塞，那么 time.After 为啥可以阻塞呢？ 看 After 源码。sleep.go 可以看到其实也是 channel func After(d Duration) <-chan Time { return NewTimer(d).C } 完整代码示例： package timeout import ( "fmt" "testing" "time" ) func TestSelectTimeOut(t *testing.T) { // 在这个例子中， 假设我们执行了一个外部调用， 2秒之后将结果写入c1 c1 := make(chan string, 1) go func() { time.Sleep(time.Second * 2) c1 <- "result 1" }() // 这里使用select来实现超时， `res := <-c1`等待通道结果， // `<- Time.After`则在等待1秒后返回一个值， 因为select首先 // 执行那些不再阻塞的case， 所以这里会执行超时程序， 如果 // `res := <-c1`超过1秒没有执行的话 select { case res := <-c1: fmt.Println(res) case <-time.After(time.Second * 1): fmt.Println("timeout 1") } // 如果我们将超时时间设为3秒， 这个时候`res := <-c2`将在 // 超时case之前执行， 从而能够输出写入通道c2的值 c2 := make(chan string, 1) go func() { time.Sleep(time.Second * 2) c2 <- "result 2" }() select { case res := <-c2: fmt.Println(res) case <-time.After(time.Second * 3): fmt.Println("timeout 2") } } 运行结果： === RUN   TestSelectTimeOut timeout 1 result 2 --- PASS: TestSelectTimeOut (3.00s) PASS go timer 计时器 这个是 timer 类似的计时器实现，通用也是通过通道来发送数据。 package main import "time" import "fmt" func main() { // Ticker使用和Timer相似的机制， 同样是使用一个通道来发送数据。 // 这里我们使用range函数来遍历通道数据， 这些数据每隔500毫秒被 // 发送一次， 这样我们就可以接收到 ticker := time.NewTicker(time.Millisecond * 500) go func() { for t := range ticker.C { fmt.Println("Tick at", t) } }() // Ticker和Timer一样可以被停止。 一旦Ticker停止后， 通道将不再 // 接收数据， 这里我们将在1500毫秒之后停止 time.Sleep(time.Millisecond * 1500) ticker.Stop() fmt.Println("Ticker stopped") } go context context 监听是否有 IO 操作，开始从当前连接中读取网络请求，每当读取到一个请求则会将该cancelCtx传入，用以传递取消信号，可发送取消信号，取消所有进行中的网络请求。 go func(ctx context.Context, info *Info) { timeLimit := 120 timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeLimit)*time.Millisecond) defer func() { cancel() wg.Done() }() resp := DoHttp(timeoutCtx, info.req) }(ctx, info) 关键看业务代码: resp := DoHttp(timeoutCtx, info.req) 业务代码中包含 http 调用 NewRequestWithContext req, err := http.NewRequestWithContext(ctx, "POST", url, strings.NewReader(paramString)) 上面的代码，设置了过期时间，当DoHttp(timeoutCtx, info.req) 处理时间超过超时时间时，会自动截止，并且打印 context deadline exceeded。 看个代码： package main import ( "context" "fmt" "testing" "time" ) func TestTimerContext(t *testing.T) { now := time.Now() later, _ := time.ParseDuration("10s") ctx, cancel := context.WithDeadline(context.Background(), now.Add(later)) defer cancel() go Monitor(ctx) time.Sleep(20 * time.Second) } func Monitor(ctx context.Context) { select { case <-ctx.Done(): fmt.Println(ctx.Err()) case <-time.After(20 * time.Second): fmt.Println("stop monitor") } } 运行结果： === RUN   TestTimerContext context deadline exceeded --- PASS: TestTimerContext (20.00s) PASS Context 接口有如下： type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} } Deadline — 返回 context.Context 被取消的时间，也就是完成工作的截止日期； Done — 返回一个 Channel，这个 Channel 会在当前工作完成或者上下文被取消之后关闭，多次调用 Done 方法会返回同一个 Channel； Err — 返回 context.Context 结束的原因，它只会在 Done 返回的 Channel 被关闭时才会返回非空的值； 如果 context.Context 被取消，会返回 Canceled 错误； 如果 context.Context 超时，会返回 DeadlineExceeded 错误； Value — 从 context.Context 中获取键对应的值，对于同一个上下文来说，多次调用 Value 并传入相同的 Key 会返回相同的结果，该方法可以用来传递请求特定的数据； 到此这篇关于Go语言 ......查看全文

算数运算符 算数运算符和C语言几乎一样 运算符 描述 实例+ 相加 A + B - 相减 A - B * 相乘 A * B / 相除 B / A % 求余 B % A ++ 自增 A++ – 自减 A– 注意点: 只有相同类型的数据才能进行运算 package main import "fmt" int main(){ var num1 int32 = 10 //var num2 int64 = num1 // 类型不同不能进行赋值运算 var num2 int64 = int64(num1) // 类型不同不能进行赋值运算 fmt.Println(num2) var num3 int32 = 10 var num4 int64 = 20 //var res int64 = num3 + num4 // 类型不同不能进行算数运算 var res1 int64 = int64(num3) + num4 // 类型不同不能进行算数运算 fmt.Println(res1) var num5 int32 = 10 var num6 int64 = 20 //var res2 bool = (num5 == num6) // 类型不同不能进行关系运算 var res2 bool = (num5 == int32(num6)) // 类型不同不能进行关系运算 fmt.Println(res2) // ... ... 其它以此类推 } Go语言中++、–运算符不支持前置 错误写法: ++i; --i; Go语言中++、–是语句,不是表达式,所以必须独占一行 错误写法: a = i++; return i++; package main import "fmt" func main() { num1 := 0 num1++ fmt.Println(num1) //++num1 // 编译报错, Go语言中++只能后置,不能前置 //fmt.Println(num1) //var num2 int = num1++ // 编译报错, num1++是语句不是表达式, 所以必须独占一行 //fmt.Println(num2) } Go语言中字符串支持利用+号进行拼接 package main import "fmt" func main() { str := "abc" + "def" //fmt.Println(str) } 关系算符 关系算符和C语言一样 运算符 描述 实例 == 检查两个值是否相等，如果相等返回 True 否则返回 False。 A == B != 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 A != B > 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 A > B < 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 A < B >= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 A >= B <= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 A <= B 注意点: 和C语言不通的是, Go语言中关系运算符只能返回true和false 逻辑运算符 逻辑运算符和C语言一样 运算符 描述 实例 && 如果两边的操作数都是 True，则条件 True，否则为 False。 A && B \|\| 如果两边的操作数有一个 True，则条件 True，否则为 False。 A || B ! 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 !A 注意点: 和C语言不通的是, Go语言中关系运算符只能返回true和false 逻辑非只能用于true和false 位运算符 位运算符和C语言几乎一样 运算符描述实例&参与运算的两数各对应的二进位相与, 对应位只要都是1结果就为1A & B\|参与运算的两数各对应的二进位相或,对应位只要其中一个是1结果就为1A | B^参与运算的两数各对应的二进位相异或,对应位只要不同结果就是1A ^ B<<左移运算符,左移n位就是乘以2的n次方A << 2>>右移运算符,右移n位就是除以2的n次方B >> 2&^逻辑清零运算符, B对应位是1,A对应位清零,B对应位是0, A对应位保留原样A &^ B 新增一个&^运算符 int main(){ /* 0110 a &^1011 b 如果b位位1,那么结果为0, 否则结果为a位对应的值 ---------- 0100 */ a1 := 6 b1 := 11 res1 := a1 &^ b1 fmt.Println("res1 = ", res1) // 4 /* 1011 a &^1101 b 如果b位位1,那么结果为0, 否则结果为a位对应的值 ---------- 0010 */ a2 := 11 b2 := 13 res2 := a2 &^ b2 fmt.Println("res2 = ", res2) // 2 } 赋值运算符 赋值运算符和C语言几乎一样 新增一个&^=运算符 运算符 描述 实例 = 将右边赋值给左边 C = A + B 将 A + B 表达式结果赋值给 C += 相加后再赋值 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 &^= 位逻辑清零赋值 C &^= 2 等于 C = C &^ 2 其它运算符 运算符 描述 实例 & 返回变量存储地址 &a; 将给出变量的实际地址 * 访问指针指向内存 *p; 访问指针p指向内存 package main import "fmt" int main(){ var num int = 666 var p *int = &num fmt.Println(num) fmt.Println(*p) num = 777 fmt.Println(num) *p = 999 fmt.Println(num) } 注意点 指针类型只支持相等运算, 不能做加减运算 #include <stdio.h> int main() { int ages[3] = {19, 23, 22}; int *arrayP = &ages[0]; printf("ages[0] = %i\n", *(arrayP + 0)); // *(arrayP + 0) == *arrayP printf("ages[1] = %i\n", *(arrayP + 1)); printf("ages[2] = %i\n", *(arrayP + 2)); return 0; } package main import "fmt" int main(){ var ages [3]int = [3]int{19, 23, 22} var p *int = &ages[0] //fmt.Println(&ages[0]) //fmt.Println(*p) // 19 fmt.Println(*(p + 0)) // 编译报错 } 运算符优先级 和C语言一样, 只需记住()优先级最高即可 到此这 算数运算符 算数运算符和C语言几乎一样 运算符 描述 实例 + 相加 A + B - 相减 A - B * 相乘 A * B / 相除 B / A % 求余 B % A ++ 自增 A++ – 自减 A– 注意点: 只有相同类型的数据才能进行运算 package main import "fmt" int main(){ var num1 int32 = 10 //var num2 int64 = num1 // 类型不同不能进行赋值运算 var num2 int64 = int64(num1) // 类型不同不能进行赋值运算 fmt.Println(num2) var num3 int32 = 10 var num4 int64 = 20 //var res int64 = num3 + num4 // 类型不同不能进行算数运算 var res1 int64 = int64(num3) + num4 // 类型不同不能进行算数运算 fmt.Println(res1) var num5 int32 = 10 var num6 int64 = 20 //var res2 bool = (num5 == num6) // 类型不同不能进行关系运算 var res2 bool = (num5 == int32(num6)) // 类型不同不能进行关系运算 fmt.Println(res2) // ... ... 其它以此类推 } Go语言中++、–运算符不支持前置 错误写法: ++i; --i; Go语言中++、–是语句,不是表达式,所以必须独占一行 错误写法: a = i++; return i++; package main import "fmt" func main() { num1 := 0 num1++ fmt.Println(num1) //++num1 // 编译报错, Go语言中++只能后置,不能前置 //fmt.Println(num1) //var num2 int = num1++ // 编译报错, num1++是语句不是表达式, 所以必须独占一行 //fmt.Println(num2) } Go语言中字符串支持利用+号进行拼接 package main import "fmt" func main() { str := "abc" + "def" //fmt.Println(str) } 关系算符 关系算符和C语言一样 运算符 描述 实例 == 检查两个值是否相等，如果相等返回 True 否则返回 False。 A == B != 检查两个值是否不相等，如果不相等返回 True 否则返回 False。 A != B > 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 A > B < 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 A < B >= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 A >= B <= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 A <= B 注意点: 和C语言不通的是, Go语言中关系运算符只能返回true和false 逻辑运算符 逻辑运算符和C语言一样 运算符 描述 实例 && 如果两边的操作数都是 True，则条件 True，否则为 False。 A && B \|\| 如果两边的操作数有一个 True，则条件 True，否则为 False。 A || B ! 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 !A 注意点: 和C语言不通的是, Go语言中关系运算符只能返回true和false 逻辑非只能用于true和false 位运算符 位运算符和C语言几乎一样 运算符描述实例&参与运算的两数各对应的二进位相与, 对应位只要都是1结果就为1A & B\|参与运算的两数各对应的二进位相或,对应位只要其中一个是1结果就为1A | B^参与运算的两数各对应的二进位相异或,对应位只要不同结果就是1A ^ B<<左移运算符,左移n位就是乘以2的n次方A << 2>>右移运算符,右移n位就是除以2的n次方B >> 2&^逻辑清零运算符, B对应位是1,A对应位清零,B对应位是0, A对应位保留原样A &^ B 新增一个&^运算符 int main(){ /* 0110 a &^1011 b 如果b位位1,那么结果为0, 否则结果为a位对应的值 ---------- 0100 */ a1 := 6 b1 := 11 res1 := a1 &^ b1 fmt.Println("res1 = ", res1) // 4 /* 1011 a &^1101 b 如果b位位1,那么结果为0, 否则结果为a位对应的值 ---------- 0010 */ a2 := 11 b2 := 13 res2 := a2 &^ b2 fmt.Println("res2 = ", res2) // 2 } 赋值运算符 赋值运算符和C语言几乎一样 新增一个&^=运算符 运算符 描述 实例 = 将右边赋值给左边 C = A + B 将 A + B 表达式结果赋值给 C += 相加后再赋值 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 &^= 位逻辑清零赋值 C &^= 2 等于 C = C &^ 2 其它运算符 运算符 描述 实例 & 返回变量存储地址 &a; 将给出变量的实际地址 * 访问指针指向内存 *p; 访问指针p指向内存 package main import "fmt" int main(){ var num int = 666 var p *int = &num fmt.Println(num) fmt.Println(*p) num = 777 fmt.Println(num) *p = 999 fmt.Println(num) } 注意点 指针类型只支持相等运算, 不能做加减运算 #include <stdio.h> int main() { int ages[3] = {19, 23, 22}; int *arrayP = &ages[0]; printf("ages[0] = %i\n", *(arrayP + 0)); // *(arrayP + 0) == *arrayP printf("ages[1] = %i\n", *(arrayP + 1)); printf("ages[2] = %i\n", *(arrayP + 2)); return 0; } package main import "fmt" int main(){ var ages [3]int = [3]int{19, 23, 22} var p *int = &ages[0] //fmt.Println(&ages[0]) //fmt.Println(*p) // 19 fmt.Println(*(p + 0)) // 编译报错 } 运算符优先级 和C语言一样, 只需记住()优先级最高即可 到此这Go语言 ......查看全文

普通指针 和C语言一样, 允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量 和C语言一样, Go语言中的指针无论是什么类型占用内存都一样(32位4个字节, 64位8个字节) package main import ( "fmt" "unsafe" ) func main() { var p1 *int; var p2 *float64; var p3 *bool; fmt.Println(unsafe.Sizeof(p1)) // 8 fmt.Println(unsafe.Sizeof(p2)) // 8 fmt.Println(unsafe.Sizeof(p3)) // 8 } 和C语言一样, 只要一个指针变量保存了另一个变量对应的内存地址, 那么就可以通过*来访问指针变量指向的存储空间 package main import ( "fmt" ) func main() { // 1.定义一个普通变量 var num int = 666 // 2.定义一个指针变量 var p *int = &num fmt.Printf("%p\n", &num) // 0xc042064080 fmt.Printf("%p\n", p) // 0xc042064080 fmt.Printf("%T\n", p) // *int // 3.通过指针变量操作指向的存储空间 *p = 888 // 4.指针变量操作的就是指向变量的存储空间 fmt.Println(num) // 888 fmt.Println(*p) // 888 } 指向数组指针 在C语言中, 数组名,&数组名,&数组首元素保存的都是同一个地址 #include <stdio.h> int main(){ int arr[3] = {1, 3, 5}; printf("%p\n", arr); // 0060FEA4 printf("%p\n", &arr); // 0060FEA4 printf("%p\n", &arr[0]); // 0060FEA4 } 在Go语言中通过数组名无法直接获取数组的内存地址 package main import "fmt" func main() { var arr [3]int = [3]int{1, 3, 5} fmt.Printf("%p\n", arr) // 乱七八糟东西 fmt.Printf("%p\n", &arr) // 0xc0420620a0 fmt.Printf("%p\n", &arr[0]) // 0xc0420620a0 } 在C语言中, 无论我们将数组名,&数组名,&数组首元素赋值给指针变量, 都代表指针变量指向了这个数组 #include <stdio.h> int main(){ int arr[3] = {1, 3, 5}; int *p1 = arr; p1[1] = 6; printf("%d\n", arr[1]); int *p2 = &arr; p2[1] = 7; printf("%d\n", arr[1]); int *p3 = &arr[0]; p3[1] = 8; printf("%d\n", arr[1]); } 在Go语言中, 因为只有数据类型一模一样才能赋值, 所以只能通过&数组名赋值给指针变量, 才代表指针变量指向了这个数组 package main import "fmt" func main() { // 1.错误, 在Go语言中必须类型一模一样才能赋值 // arr类型是[3]int, p1的类型是*[3]int var p1 *[3]int fmt.Printf("%T\n", arr) fmt.Printf("%T\n", p1) p1 = arr // 报错 p1[1] = 6 fmt.Println(arr[1]) // 2.正确, &arr的类型是*[3]int, p2的类型也是*[3]int var p2 *[3]int fmt.Printf("%T\n", &arr) fmt.Printf("%T\n", p2) p2 = &arr p2[1] = 6 fmt.Println(arr[1]) // 3.错误, &arr[0]的类型是*int, p3的类型也是*[3]int var p3 *[3]int fmt.Printf("%T\n", &arr[0]) fmt.Printf("%T\n", p3) p3 = &arr[0] // 报错 p3[1] = 6 fmt.Println(arr[1]) } 注意点: Go语言中的指针, 不支持C语言中的+1 -1和++ – 操作 package main import "fmt" func main() { var arr [3]int = [3]int{1, 3, 5} var p *[3]int p = &arr fmt.Printf("%p\n", &arr) // 0xc0420620a0 fmt.Printf("%p\n", p) // 0xc0420620a0 fmt.Println(&arr) // &[1 3 5] fmt.Println(p) // &[1 3 5] // 指针指向数组之后操作数组的几种方式 // 1.直接通过数组名操作 arr[1] = 6 fmt.Println(arr[1]) // 2.通过指针间接操作 (*p)[1] = 7 fmt.Println((*p)[1]) fmt.Println(arr[1]) // 3.通过指针间接操作 p[1] = 8 fmt.Println(p[1]) fmt.Println(arr[1]) // 注意点: Go语言中的指针, 不支持+1 -1和++ --操作 *(p + 1) = 9 // 报错 fmt.Println(*p++) // 报错 fmt.Println(arr[1]) } 指向切片的指针 值得注意点的是切片的本质就是一个指针指向数组, 所以指向切片的指针是一个二级指针 package main import "fmt" func main() { // 1.定义一个切片 var sce[]int = []int{1, 3, 5} // 2.打印切片的地址 // 切片变量中保存的地址, 也就是指向的那个数组的地址 sce = 0xc0420620a0 fmt.Printf("sce = %p\n",sce ) fmt.Println(sce) // [1 3 5] // 切片变量自己的地址, &sce = 0xc04205e3e0 fmt.Printf("&sce = %p\n",&sce ) fmt.Println(&sce) // &[1 3 5] // 3.定义一个指向切片的指针 var p *[]int // 因为必须类型一致才能赋值, 所以将切片变量自己的地址给了指针 p = &sce // 4.打印指针保存的地址 // 直接打印p打印出来的是保存的切片变量的地址 p = 0xc04205e3e0 fmt.Printf("p = %p\n", p) fmt.Println(p) // &[1 3 5] // 打印*p打印出来的是切片变量保存的地址, 也就是数组的地址 *p = 0xc0420620a0 fmt.Printf("*p = %p\n", *p) fmt.Println(*p) // [1 3 5] // 5.修改切片的值 // 通过*p找到切片变量指向的存储空间(数组), 然后修改数组中保存的数据 (*p)[1] = 666 fmt.Println(sce[1]) } 指向字典指针 与普通指针并无差异 package main import "fmt" func main() { var dict map[string]string = map[string]string{"name":"lnj", "age":"33"} var p *map[string]string = &dict (*p)["name"] = "zs" fmt.Println(dict) } 指向结构体指针 Go语言中指向结构体的指针和C语言一样 结构体和指针 创建结构体指针变量有两种方式 package main import "fmt" type Student struct { name string age int } func main() { // 创建时利用取地址符号获取结构体变量地址 var p1 = &Student{"lnj", 33} fmt.Println(p1) // &{lnj 33} // 通过new内置函数传入数据类型创建 // 内部会创建一个空的结构体变量, 然后返回这个结构体变量的地址 var p2 = new(Student) fmt.Println(p2) // &{ 0} } 利用结构体指针操作结构体属性 package main import "fmt" type Student struct { name string age int } func main() { var p = &Student{} // 方式一: 传统方式操作 // 修改结构体中某个属性对应的值 // 注意: 由于.运算符优先级比*高, 所以一定要加上() (*p).name = "lnj" // 获取结构体中某个属性对应的值 fmt.Println((*p).name) // lnj // 方式二: 通过Go语法糖操作 // Go语言作者为了程序员使用起来更加方便, 在操作指向结构体的指针时可以像操作接头体变量一样通过.来操作 // 编译时底层会自动转发为(*p).age方式 p.age = 33 fmt.Println(p.age) // 33 } 指针作为函数参数和返回值 如果指针类型作为函数参数, 修改形参会影响实参 不能将函数内的指向局部变量的指针作为返回值, 函数结束指向空间会被释放 可以将函数内的局部变量作为返回值, 本质是拷贝一份 到此这篇 普通指针 和C语言一样, 允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量 和C语言一样, Go语言中的指针无论是什么类型占用内存都一样(32位4个字节, 64位8个字节) package main import ( "fmt" "unsafe" ) func main() { var p1 *int; var p2 *float64; var p3 *bool; fmt.Println(unsafe.Sizeof(p1)) // 8 fmt.Println(unsafe.Sizeof(p2)) // 8 fmt.Println(unsafe.Sizeof(p3)) // 8 } 和C语言一样, 只要一个指针变量保存了另一个变量对应的内存地址, 那么就可以通过*来访问指针变量指向的存储空间 package main import ( "fmt" ) func main() { // 1.定义一个普通变量 var num int = 666 // 2.定义一个指针变量 var p *int = &num fmt.Printf("%p\n", &num) // 0xc042064080 fmt.Printf("%p\n", p) // 0xc042064080 fmt.Printf("%T\n", p) // *int // 3.通过指针变量操作指向的存储空间 *p = 888 // 4.指针变量操作的就是指向变量的存储空间 fmt.Println(num) // 888 fmt.Println(*p) // 888 } 指向数组指针 在C语言中, 数组名,&数组名,&数组首元素保存的都是同一个地址 #include <stdio.h> int main(){ int arr[3] = {1, 3, 5}; printf("%p\n", arr); // 0060FEA4 printf("%p\n", &arr); // 0060FEA4 printf("%p\n", &arr[0]); // 0060FEA4 } 在Go语言中通过数组名无法直接获取数组的内存地址 package main import "fmt" func main() { var arr [3]int = [3]int{1, 3, 5} fmt.Printf("%p\n", arr) // 乱七八糟东西 fmt.Printf("%p\n", &arr) // 0xc0420620a0 fmt.Printf("%p\n", &arr[0]) // 0xc0420620a0 } 在C语言中, 无论我们将数组名,&数组名,&数组首元素赋值给指针变量, 都代表指针变量指向了这个数组 #include <stdio.h> int main(){ int arr[3] = {1, 3, 5}; int *p1 = arr; p1[1] = 6; printf("%d\n", arr[1]); int *p2 = &arr; p2[1] = 7; printf("%d\n", arr[1]); int *p3 = &arr[0]; p3[1] = 8; printf("%d\n", arr[1]); } 在Go语言中, 因为只有数据类型一模一样才能赋值, 所以只能通过&数组名赋值给指针变量, 才代表指针变量指向了这个数组 package main import "fmt" func main() { // 1.错误, 在Go语言中必须类型一模一样才能赋值 // arr类型是[3]int, p1的类型是*[3]int var p1 *[3]int fmt.Printf("%T\n", arr) fmt.Printf("%T\n", p1) p1 = arr // 报错 p1[1] = 6 fmt.Println(arr[1]) // 2.正确, &arr的类型是*[3]int, p2的类型也是*[3]int var p2 *[3]int fmt.Printf("%T\n", &arr) fmt.Printf("%T\n", p2) p2 = &arr p2[1] = 6 fmt.Println(arr[1]) // 3.错误, &arr[0]的类型是*int, p3的类型也是*[3]int var p3 *[3]int fmt.Printf("%T\n", &arr[0]) fmt.Printf("%T\n", p3) p3 = &arr[0] // 报错 p3[1] = 6 fmt.Println(arr[1]) } 注意点: Go语言中的指针, 不支持C语言中的+1 -1和++ – 操作 package main import "fmt" func main() { var arr [3]int = [3]int{1, 3, 5} var p *[3]int p = &arr fmt.Printf("%p\n", &arr) // 0xc0420620a0 fmt.Printf("%p\n", p) // 0xc0420620a0 fmt.Println(&arr) // &[1 3 5] fmt.Println(p) // &[1 3 5] // 指针指向数组之后操作数组的几种方式 // 1.直接通过数组名操作 arr[1] = 6 fmt.Println(arr[1]) // 2.通过指针间接操作 (*p)[1] = 7 fmt.Println((*p)[1]) fmt.Println(arr[1]) // 3.通过指针间接操作 p[1] = 8 fmt.Println(p[1]) fmt.Println(arr[1]) // 注意点: Go语言中的指针, 不支持+1 -1和++ --操作 *(p + 1) = 9 // 报错 fmt.Println(*p++) // 报错 fmt.Println(arr[1]) } 指向切片的指针 值得注意点的是切片的本质就是一个指针指向数组, 所以指向切片的指针是一个二级指针 package main import "fmt" func main() { // 1.定义一个切片 var sce[]int = []int{1, 3, 5} // 2.打印切片的地址 // 切片变量中保存的地址, 也就是指向的那个数组的地址 sce = 0xc0420620a0 fmt.Printf("sce = %p\n",sce ) fmt.Println(sce) // [1 3 5] // 切片变量自己的地址, &sce = 0xc04205e3e0 fmt.Printf("&sce = %p\n",&sce ) fmt.Println(&sce) // &[1 3 5] // 3.定义一个指向切片的指针 var p *[]int // 因为必须类型一致才能赋值, 所以将切片变量自己的地址给了指针 p = &sce // 4.打印指针保存的地址 // 直接打印p打印出来的是保存的切片变量的地址 p = 0xc04205e3e0 fmt.Printf("p = %p\n", p) fmt.Println(p) // &[1 3 5] // 打印*p打印出来的是切片变量保存的地址, 也就是数组的地址 *p = 0xc0420620a0 fmt.Printf("*p = %p\n", *p) fmt.Println(*p) // [1 3 5] // 5.修改切片的值 // 通过*p找到切片变量指向的存储空间(数组), 然后修改数组中保存的数据 (*p)[1] = 666 fmt.Println(sce[1]) } 指向字典指针 与普通指针并无差异 package main import "fmt" func main() { var dict map[string]string = map[string]string{"name":"lnj", "age":"33"} var p *map[string]string = &dict (*p)["name"] = "zs" fmt.Println(dict) } 指向结构体指针 Go语言中指向结构体的指针和C语言一样 结构体和指针 创建结构体指针变量有两种方式 package main import "fmt" type Student struct { name string age int } func main() { // 创建时利用取地址符号获取结构体变量地址 var p1 = &Student{"lnj", 33} fmt.Println(p1) // &{lnj 33} // 通过new内置函数传入数据类型创建 // 内部会创建一个空的结构体变量, 然后返回这个结构体变量的地址 var p2 = new(Student) fmt.Println(p2) // &{ 0} } 利用结构体指针操作结构体属性 package main import "fmt" type Student struct { name string age int } func main() { var p = &Student{} // 方式一: 传统方式操作 // 修改结构体中某个属性对应的值 // 注意: 由于.运算符优先级比*高, 所以一定要加上() (*p).name = "lnj" // 获取结构体中某个属性对应的值 fmt.Println((*p).name) // lnj // 方式二: 通过Go语法糖操作 // Go语言作者为了程序员使用起来更加方便, 在操作指向结构体的指针时可以像操作接头体变量一样通过.来操作 // 编译时底层会自动转发为(*p).age方式 p.age = 33 fmt.Println(p.age) // 33 } 指针作为函数参数和返回值 如果指针类型作为函数参数, 修改形参会影响实参 不能将函数内的指向局部变量的指针作为返回值, 函数结束指向空间会被释放 可以将函数内的局部变量作为返回值, 本质是拷贝一份 到此这篇Go语言 ......查看全文