After_Reading：Build Web Application With Golang

最新推荐文章于 2024-08-10 07:07:43 发布
最新推荐文章于 2024-08-10 07:07:43 发布
阅读量258 收藏
点赞数
文章标签： Go语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang_chengfeng/article/details/81231271
版权

正式工作一个月，空闲时间不断思考自己的发展方向，与其迷茫，不如先动起来。。。

Go语言的几大优势

这里写图片描述

赞 - 作者语：写这本书不表示我能力很强，而是我愿意分享

目录

这里写图片描述

一 Go环境配置

1、Go安装

  • 源码

  • 安装包

  • 第三方工具：如Ubuntu的apt-get、Mac的homebrew、GVM(支持同一系统安装多个版本的Go)

以上罗列了3种安装方式，个人借助第三方工具homebrew：brew install go

2、GOPATH与工作空间

go 命令依赖一个重要的环境变量:$GOPATH

（1）配置GOPATH：

① go env

GOPATH设置

② vim .bash_profile

③ 参数配置

export GOPATH=/usr/local/Cellar/go/1.10.3
export GOBIN=$GOPATH/bin
export PATH=$PATH:$GOBIN

④ source .bash_profile

3、Go 命令

（1）命令查询

GO命令查询

（2）chm手册

4、GoLand

工欲善其事，必先利其器

1、vscode 有款不错的插件 ---- vscode-go

2、下面使用GoLand进行代码编辑，其破解方法见于此’

2 基本语法

1、Hello, Go!

示例代码 2-1：新建helloworld.go，打印Hello, Go!

package main

import "fmt"

func main() {
	fmt.Print("Hello, Go!")
}

1、导入包文件

①

import (
	"fmt"
)

②

import "./model"

③

import "shorturl/model"

特殊的import方式：
①点操作

package main

import (
	. "fmt"
)

func main() {
	println("Hello, Go") // 可省略前缀包名
}

②别名操作

package main

import (
	f "fmt"
)

func main() {
	f.Println("Hello world")
}

③_操作

import (
    _ "github.com/go-sql-driver/mysql"
)

2、变量

（1）公有变量&私有变量

  • 大写字母开头的为：公有变量，可导出(其他包可读取)
  • 小写字母开头：私有变量(不可导出)

（2）变量声明

import (
	"fmt"
	"reflect"
)

var a int
var b int = 123
var( // 分组声明
	c string = "chengfeng_Yang"
	d int = 2019
)

func main()  {
	fmt.Println("hello_world!")
	fmt.Println(c)
	fmt.Println(d)
	var e, f, g int  = 1, 2, 3
	fmt.Println(e)
	fmt.Println(f)
	fmt.Println(g)

	h := 4 // 声明&赋值
	fmt.Println(reflect.TypeOf(h))
}

（3）iota使用

iota在const关键字出现时将被重置为0 ；const中每新增一行常量声明将使iota计数一次
Iota常见使用法：

  • 1)跳值使用法
  • 2)插队使用法
  • 3)表达式隐式使用法
  • 4)单行使用法
package main

import (
	"fmt"
)

const a  = iota
const (
	b = iota
    c = iota
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 0
	fmt.Println(c) // 1
}

① 跳值使用法

package main

import (
	"fmt"
)


const (
	a = iota
	b = iota
	_
	_
    c = iota
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 1
	fmt.Println(c) // 4
}

② 插队使用法

package main

import (
	"fmt"
)


const (
	a = iota
	b = 3.14
    c = iota
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 3.14
	fmt.Println(c) // 2
}

③ 表达式隐式使用法

package main

import (
	"fmt"
)


const (
	a = iota * 2
	b = iota
    c = iota
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 1
	fmt.Println(c) // 2
}

package main

import (
	"fmt"
)


const (
	a = iota * 2
	b
    c
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 2
	fmt.Println(c) // 4
}

package main

import (
"fmt"
)


const (
	a = iota * 2
	b = iota * 3
	c
	d
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 3
	fmt.Println(c) // 6
	fmt.Println(d) // 9
}

④ 单行使用法

package main

import (
"fmt"
)


const (
	a, b = iota, iota + 3
	c, d
	f = iota
)

func main()  {
	fmt.Println(a) // 0
	fmt.Println(b) // 3
	fmt.Println(c) // 1
	fmt.Println(d) // 4
	fmt.Println(f) // 2
}

3、struct类型

（1）三种声明：

①

package main

import "fmt"

type person struct {
	name string
	age int
}

func main() {
	var P person
	P.name = "Astaxie"
	P.age = 25
	fmt.Printf("This Person's name is %s, it's age is %d", P.name, P.age)
}

②

package main

import "fmt"

type person struct {
	name string
	age int
}

func main() {
	P := person{"Tom", 25} // P必须是未声明的，否则编译出错：no new variables on left side of :=
	fmt.Printf("This Person's name is %s, it's age is %d", P.name, P.age)
}

③

package main

import "fmt"

type person struct {
	name string
	age int
}

func main() {
	P := person{age: 12, name:"Alice"} // 相较②这是无序的
	fmt.Printf("This Person's name is %s, it's age is %d", P.name, P.age)
}

仅是引入该包，当导入一个包时，它所有的init()函数就会被执行，但有时并非真的需要使用这些包，仅仅是希望它的init()函数被执行而已（此时可使用_操作引用该包了。即使用_操作引用包是无法通过包名来调用包中的导出函数，而是只是为了简单的调用其init函数()）

package main

import "fmt"

type person struct {
   name string
   age int
}

func Older(p1, p2 person) (person, int) {
   if p1.age > p2.age {
   	return p1, p1.age - p2.age
   }
   return p2, p2.age - p1.age
}

func main() {
   var tom person
   tom.name, tom.age = "Tom", 33
   bob := person{"Bob", 25}
   paul := person{"Paul", 43}

   tb_Older, tb_diff := Older(tom, bob)
   tp_Older, tp_diff := Older(tom, paul)
   bp_Older, bp_diff := Older(bob, paul)

   fmt.Printf("Of %s and %s, %s is older by %d years\n", tom.name, bob.name, tb_Older.name, tb_diff)
   fmt.Printf("Of %s and %s, %s is older by %d years\n", tom.name, paul.name, tp_Older.name, tp_diff)
   fmt.Printf("Of %s and %s, %s is older by %d years\n", bob.name, paul.name, bp_Older.name, bp_diff)
}

（2）匿名字段

package main

import "fmt"

type Human struct {
   name string
   age int
   weight int
}

type Student struct {
   Human
   speciality string
}

func main() {
   mark := Student{Human{"Mark", 25, 120}, "ComputerScience"}

   mark.speciality = "AI"
   mark.name = "QQ"
   mark.age = 55
   mark.weight += 10

   fmt.Printf("The information of this student name:%s, age:%d, weight:%d, speciality:%s", mark.name, mark.age, mark.weight, mark.speciality)
}

假如：Student里面有phone，Human里面也有phone，那如何处理呢？
最外层优先访问 -> Student

4、面向对象

method

package main

import (
	"math"
	"fmt"
)

type Rectangle struct {
	 width, height float64
}

type Circle struct {
	 radius float64
}

func (r Rectangle) area() float64 {
	return  r.width * r.height
}

func (c Circle) area() float64 {
	return c.radius * c.radius *math.Pi
}

func main() {
	r1 := Rectangle{12, 2}
	r2 := Rectangle{9, 4}
	c1 := Circle{10}
	c2 := Circle{25}
	fmt.Println("Area of r1 is:", r1.area())
	fmt.Println("Area of r2 is:", r2.area())
	fmt.Println("Area of c1 is:", c1.area())
	fmt.Println("Area of c2 is:", c2.area())
}

1、指针receiver和非指针receiver

package main

import "fmt"

type Person struct {
	Name string
	Age int
}

func (p *Person) SayHi1() {
	p.Name = "leon1"
}

func (p Person) sayHi2() {
	p.Name = "leon2"
}

func main() {
	p1 := &Person{Name: "test", Age: 10}
	fmt.Println("name1:" + p1.Name)
	p1.SayHi1()
	fmt.Println("name2:" + p1.Name)

	p2 := Person{Name: "test1", Age: 11}
	fmt.Println("name3:" + p2.Name)
	p2.sayHi2()
	fmt.Println("name4:" + p2.Name)
}

name1:test
name2:leon1
name3:test1
name4:test1

2、method继承

package main

import "fmt"

type Human struct {
	name string
	age int
	phone string
}

type Student struct {
	Human
	school string
}

type Employee struct {
	Human
	company string
}

func (h *Human) Sayhi() {
	fmt.Println("Hi, I am %s you can call me on %s", h.name, h.phone)
}

func main() {
	mark := Student{Human{"Matk", 25, "222-222-YYYY"}, "MIT"}
	sam := Employee{Human{"Sam", 35, "222-322-YYYY"}, "Inc"}

	mark.Sayhi()
	sam.Sayhi()
}

3、method重写

package main

import "fmt"

type Human struct {
	name string
	age int
	phone string
}

type Student struct {
	Human
	school string
}

type Employee struct {
	Human
	company string
}

func (h *Human) Sayhi() {
	fmt.Println("Hi, I am %s you can call me on %s", h.name, h.phone)
}

func (e *Employee) Sayhi() { 
	fmt.Println("Hi, I am %s , I work at %s, you can call me on %s", e.name, e.company, e.phone)
}

func main() {
	mark := Student{Human{"Matk", 25, "222-222-YYYY"}, "MIT"}
	sam := Employee{Human{"Sam", 35, "222-322-YYYY"}, "Inc"}

	mark.Sayhi()
	sam.Sayhi()
}

注：没有任何的私有、 公有关键字，通过大小写来实现(大写开头的为共有，小写开头的为私有)，方法也同样适用这个原则。

interface

以 Student实现了三个方法:Sayhi、Sing、BorrowMoney;而Employee实现了Sayhi、Sing、SpendSalary为例子：

反射reflect

4、并发

goroutine

比线程更小，十几个goroutine可能体现在 底层就是五六个线程，Go语言内部帮你实现了这些goroutine之间的内存共享。执行goroutine只需极少的栈内存(大 概是4~5KB)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更 易用、更高效、更轻便。
goroutine是通过Go的runtime管理的一个线程管理器。goroutine通过go关键字实现了，其实就是一个普通的函数。

package main

import (
	"runtime"
	"fmt"
)

func say(s string) {
	for i := 0; i<5; i++ {
		runtime.Gosched()
		fmt.Println(s)
	}
}

func main() {
	go say("world")
	say("hello")
}

// 运行结果
hello
hello
hello
hello
hello

多个goroutine运行在同一个进程里面，共享内存数据， 不过设计上我们要遵循:不要通过共享来通信，而要通过通信来共享。
runtime.Gosched()表示让CPU把时间片让给别人,下次某个时候继续恢复执行该goroutine。
默认情况下，调度器仅使用单线程，也就是说只实现了并发。想要发挥多核处理器的并行，需要在我们的程序中显 示的调用 runtime.GOMAXPROCS(n) 告诉调度器同时使用多个线程。GOMAXPROCS 设置了同时运行逻辑代码的系统线 程的最大数量，并返回之前的设置。如果n < 1，不会改变当前设置。以后Go的新版本中调度得到改进后，这将被移除。

了解runtime包中其他几个处理goroutine的函数

  • Goexit：退出当前执行的goroutine，但是defer函数还会继续调用
  • Gosched：让出当前goroutine的执行权限，调度器安排其他等待的任务运行，并在下次某个时候从该位置恢复执行。
  • NumCPU：返回 CPU 核数量
  • NumGoroutine：返回正在执 行和排队的任务总数
  • GOMAXPROCS：用来设置可以运行的CPU核数

channels

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得Goroutines同步变的更加的 简单，而不需要显式的lock。所谓阻塞，也就是如果读取(value := <-ch)它将会被阻塞，直到有数据接收。其 次，任何发送(ch<-5)将会被阻塞，直到数据被读出。无缓冲channel是在多个goroutine之间同步很棒的工具。

package main

import "fmt"

func sum(a []int, c chan int) {
	sum := 0
	for _, v := range a {
		sum += v
	}
	c <- sum
}

func main() {
	a := []int{7, 2, 8, -9, 4, 0}
	c := make(chan int)
	
	go sum(a[:len(a)/2], c)
	go sum(a[len(a)/2:], c)
	
	x, y := <-c, <-c
	fmt.Println(x, y, x+y)
}

// 运行结果
-5 17 12
Buffered Channels

Range和Close

package main

import "fmt"

func fibonacci(n int, c chan int)  {
	x, y := 1, 1
	for i:=0; i<n; i++{
		c <- x;
		x, y = y, x + y
	}
	close(c)
}

func main() {

	c := make(chan int, 10)
	go fibonacci(cap(c), c)

	for  i := range c  {
		fmt.Println(i)
	}
}

// 运行结果
1
1
2
3
5
8
13
21
34
55

Select

通过select可以监听channel上的数据流动，select默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。

package main

import (
	"fmt"
)

func fibonacci(c, quit chan int)  {
	x, y := 1, 1
	for {
		select {
		case c <- x:
			x, y = y, x + y
		case <- quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {

	c := make(chan int)
	quit := make(chan int)

	go func() {
		for  i := 0; i<10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	} ()
	fibonacci(c, quit)
}

// 运行结果
1
1
2
3
5
8
13
21
34
55
quit

超时

package main

import (
	"time"
	 
)

func main() {
	c := make(chan int)
	o := make(chan bool)

	go func() {
		for {
			select { // 通过select来设置超时
				case v := <- c:
					println(v)
				case <- time.After(5 * time.Second):
					println("timeout")
					o <- true
					break
			}
		}
	} ()
	<- o
}

// 运行结果
timeout

附录

1、本文可见于个人GitHub

Go语言推荐书籍

yang_chengfeng
关注
bud_build:golang 构建系统使用 golang
06-10
芽golang 构建系统使用 golang安装go get github.com/tbud/bud 示例build.bud 此文件只是一个快速示例，可让您了解 bud 的作用。 # ! / usr / bin / env bud# config asset pluginTaskConfig ( "bud.asset" , Config...
build-web-application-with-golang学习笔记
weixin_30709061的博客
04-16 473
build-web-application-with-golang 学习教程 这几周学习以上教程，仅记录一些重点难点部分。 Go语言 Go语言基础 Go是一门类似C的编译型语言，但是它的编译速度非常快。这门语言的关键字总共也就二十五个： break default func interface select case defer go m...
学习build-web-application-with-golang第四章内容
weixin_33816821的博客
09-07 161
GITHUB网址： https://github.com/astaxie/build-web-application-with-golang 内容 4.表单 4.1 处理表单的输入 4.2 验证表单的输入 4.3 预防跨站脚本 4.4 防止多次递交表单 4.5 处理文件上传 4.6 小结 login.gtpl &lt;html&gt; &lt;head&...
构建Go Web应用指南
最新发布
gitblog_00707的博客
08-10 232
构建Go Web应用指南 build-web-application-with-golangastaxie/build-web-application-with-golang: 是一个用于学习使用 Golang 构建 Web 应用程序的教程，从基础知识到实际项目，涵盖了 Golang Web 开发的各个方面。项目地址:https://gitcode.com/gh_mirrors/bu/build...
Go语言入门书籍推荐(10本)
记录 IT 领域经验与见解的博客
06-27 3476
Go 入门指南》由中文社区 Go 中文网编写，内容涵盖了 Go 语言基础、控制流程、数组和切片、函数和指针、结构体和方法等方面的内容。《Go 语言编程》是由图灵教育编写的一本入门教程，全书共分为 18 章，包括 Go 语言基础、流程控制、函数、数组切片、指针、结构体和面向对象编程等内容。《Go 语言核心编程》是由 Go 语言爱好者张开涛编写出版的书籍，全书分为 14 章，涵盖了 Go 语言的以下方面：基础语法、函数、数组和切片、类型和接口、并发编程和Web开发等。1. 《Go 语言编程》
build web application with golang
weixin_30522183的博客
04-17 103
最近在学习go语言，go语言作为一个比较新出现的语言不仅在语法设计理念和编译、执行速度上都自己的独到之处，而且对并发性有着更好的支持，并且更容易实现一个网络软件的开发。所以我就跟着《build web application with golang》这本在github上更新的电子书学习了使用go语言来开发web软件的技术。 之前我学习过一些网络相关的开发，包括在lamp的基础上搭建一个...
2024年推荐 10 本 Go 经典书籍，从入门到进阶(1)，2024年最新这些知识你必须拿下
2401_84911322的博客
05-11 620
作者许式伟为原金山 WPS 首席架构师、曾是盛大创新院研究员，目前是国内 Go 语言实践圈子公认的 Go 语言专家。参与本书写作的几位作者都是实际用 Go 语言开发的项目的开发人员，有较强的实战经验。
:ping_pong:Reddit golang聊天-Golang开发
05-26
Golang聊天服务器:ping_pong:============================试试吧！ 将mongodb Clone存储库安装到$ GOPATH / src / github.com / octohedron / goddit安装依赖项$ go获取构建二进制文件$ go bu Golang聊天服务器:...
Build Web Application with Golang
11-20
Welcome to Building Web Apps with Go! If you are reading this then you have just started your journey from noob to pro. No seriously, web programming in Go is so fun and easy that you won't even ...
go_jobs：带你了解一下Golang的市场行情
02-03
了解一下Golang的市场行情 项目地址： : 如果对你有所帮助，欢迎Star，图床使用的是国外的，如果看不到图片的话你可能需要翻墙。 目标 在工作中Golang已是一个子，想让大家了解一下Golang的市场行情，也想让更多的...
Go语言Web编程-build-web-application-with-golang
04-03
谢大大编写了build-web-application-with-golang ，托管在github上，只有md版的，我个人把它编译成了chm版，共享给大家，又名《Go语言Web编程》，希望各位喜欢
build-web-application-with-golang 高清kindle版
06-30
介绍如何用Go语言进行Web应用的开发，将Go语言的特性与Web开发实战组合到一起，帮读者成功地构建跨平台的应用程序
想系统学习GO语言(Golang)，能推荐几本靠谱的书吗?
01-08
学习任何一门语言，都要学习好基础，把基础打牢，那些框架对你来说都是工具，你自己的基础好，懂得了他们的原理，自己就可以创造更优秀的框架。 基础推荐官方文档，没有什么比这个更清晰了。官方文档可以看这个中文的，比较快一些 https://go-zh.org/doc/ 其次参考这个Go指南，练习一遍 https://tour.go-zh.org/welcome/1 现在对Go语言应该有了一个全面的认识，然后你再结合Go语言圣经这本书，深入理解Go的基础。 Go语言圣经中文版 https://www.gitbook.com/book/yar999/gopl-zh/details 然后通过《Go语言实战》
go语言参考书籍
06-17
[Go语言·云动力（云计算时代的新型编程语言）].樊虹剑.扫描版 Go语言圣经-中文版
Go语言进阶推荐这样三本书
人邮异步社区
05-06 1687
编译一个大型的C或者C++项目所花费的时间甚至比去喝杯咖啡的时间还长。图1-1是XKCD中的一幅漫画，描述了在办公室里开小差的经典借口。 图1-1　努力工作？（来自XKCD） Go语言使用了更加智能的编译器，并简化了解决依赖的算法，最终提供了更快的编译速度。编译Go程序时，编译器只会关注那些直接被引用的库，而不是像Java、C和C++那样，要遍历依赖链中所有依赖的库。因此，很多Go程序可以在1秒内编译完。在现代硬件上，编译整个Go语言的源码树只需要20秒。 因为没有从编译代码到执行代码的中间过
【始动篇】Go语言经典书籍总结及其推荐
技术宅拯救世界
09-21 1183
以下是我自己了解到的Go语言的书籍，以电子版为主，因为我不会购买实体书。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值