Golang学习+深入-函数

Posted 2023-04-09 杀神lwz

目录

一、概述

1、时间和日期相关函数

2、内置函数(builtin)

3、错误处理

自定义错误

---

一、概述

1、时间和日期相关函数

1、时间和日期相关函数，需要导入time包
2、time.Time类型，用于表示时间
	now := time.Now()
	fmt.Printf("type=%T val= %v",now,now)
3、获取到当前时间的方法
now := time.Now() //now的类型就是time.Time
4、如何获取到其他的日期信息
	now := time.Now()
	fmt.Printf("type=%T val= %v\\n",now,now)
	fmt.Printf("年=%v\\n",now.Year())
	fmt.Printf("月=%v\\n",now.Month())
	fmt.Printf("月=%v\\n",int(now.Month()))
	fmt.Printf("日=%v\\n",now.Day())
	fmt.Printf("时=%v\\n",now.Hour())
	fmt.Printf("分=%v\\n",now.Minute())
	fmt.Printf("秒=%v\\n",now.Second())
5、格式化日期时间
方式1:
now := time.Now()
fmt.Printf("当前年月日%02d-%02d-%02d:%02d:%02d:%02d\\n",now.Year(),now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
方式2:
        now := time.Now()
	fmt.Printf(now.Format("2006/01/02 15:04:05"))
	fmt.Println()
	fmt.Printf(now.Format("2006/01/02"))
	fmt.Println()
	fmt.Printf(now.Format("15:04:05"))
	fmt.Println()
//"2006/01/02 15:04:05"这个字符串的各个数字是固定的，必须这样写。/可以改成-等
//"2006/01/02 15:04:05"这个字符串各个数字可以自由的组合，这样可以按程序需求来返回时间和日期

6、时间的常量
const (
    Nanosecond  Duration = 1  //纳秒
    Microsecond          = 1000 * Nanosecond //微妙
    Millisecond          = 1000 * Microsecond //毫秒
    Second               = 1000 * Millisecond //秒
    Minute               = 60 * Second  //分
    Hour                 = 60 * Minute  //时
)
//常量的作用:在程序中可用于获取指定时间单位的时间，比如想得到100毫秒 100 * time.Millisecond
7、休眠
func Sleep(d Duration)
//例:
	fmt.Println("start ...")
	time.Sleep(1000 * time.Millisecond) //休眠1000毫秒
	fmt.Println("end ...")
8、获取当前Unix时间戳和UnixNano时间戳(作用是可以获取随机数字)
func (t Time) Unix() int64：Unix将t表示为Unix时间，即从时间点January 1, 1970 UTC到时间点t所经过的时间（单位秒）。
func (t Time) UnixNano() int64：UnixNano将t表示为Unix时间，即从时间点January 1, 1970 UTC到时间点t所经过的时间（单位纳秒）。如果纳秒为单位的unix时间超出了int64能表示的范围，结果是未定义的。注意这就意味着Time零值调用UnixNano方法的话，结果是未定义的。
	fmt.Printf("unix=%v\\n",now.Unix())
	fmt.Printf("unixNano=%v\\n",now.UnixNano())

2、内置函数(builtin)

Golang设计者为了编程方便，提供了一些函数，这些函数可以直接使用，我们称为Go的内置函数。在godoc文档的builtin下。内置函数也叫内建函数。

1、len:用来求长度，比如string、array、slice、map、channel
2、new:用来分配内存，主要用来分配值类型，比如int、float32,struct....返回的是指针
func new(Type) *Type：内建函数new分配内存。其第一个实参为类型，而非值。其返回值为指向该类型的新分配的零值的指针。
3、make:用来分配内存，主要用来分配引用类型，比如chan、map、slice。

package main
import (
	"fmt"
)
func main()
	n1 := 100
	fmt.Printf("n1的类型=%T,n1的值=%v,n1的地址=%v\\n",n1,n1,&n1)
	n2 := new(int)
	*n2 = 100
	fmt.Printf("n2的类型=%T,n2的值=%v,n2的地址=%v,n2指向的值=%v\\n",n2,n2,&n2,*n2)
        //n2的类型=*int,n2的值=0xc00000e0e0,n2的地址=0xc00000a030,n2指向的值=100//默认值是0

 

3、错误处理

package main
import (
	"fmt"
)
func test() 
        n1 := 10
	n2 := 0
	res := n1 / n2
	fmt.Println("res=",res)

func main()
	test()
	fmt.Println("main()...")

//panic: runtime error: integer divide by zero
//...exit status 2
//在默认情况下，当发生错误后，程序就会退出(崩溃)
//我们希望，发生错误后，可以捕获错误，并进行处理，保证程序可以继续执行

1. Go语言追求简洁优雅，所以，Go语言不支持传统的try...catch...finally这种处理。
2. Go中引入的处理方式为:defer,panic,recover
3. Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理
4. 错误处理的好处:进行错误处理后，程序不会轻易挂掉，如果加入预警代码，就可以让程序更加的健壮。

例:defer+recover来处理错误

package main
import (
	"fmt"
)
func test() 
	defer func()
		err := recover()//recover()内置函数，可以捕获到异常
		if err != nil 
			fmt.Println("err=",err)
		
	()
	n1 := 10
	n2 := 0
	res := n1 / n2
	fmt.Println("res=",res)

func main()
	test()
	fmt.Println("main()...")

自定义错误

Go程序中，也支持自定义错误，使用errors.New和panic内置函数。

1. errors.New("错误说明")，会返回一个error类型的值，表示一个错误
2. panic内置函数，接收一个interface类型的值(也就是任何值了)作为参数。可以接收error类型的变量，输出错误信息，并退出程序。

package main
import (
	"fmt"
	"errors"
)
func readConf(name string) (err error)
	if name == "config.ini" 
		return nil
	else
		return errors.New("读取文件错误...")
	

func test() 
	err := readConf("config1.ini")
	if err != nil 
		panic(err) //输出这个错误，并终止程序
	
	fmt.Println("test()继续执行..")



func main()
	test()
	fmt.Println("main()...")

//panic: 读取文件错误...
//...exit status 2

干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！

深入理解Golang之http server

前言

对于Golang来说，实现一个简单的http server非常容易，只需要短短几行代码。同时有了协程的加持，Go实现的http server能够取得非常优秀的性能。这篇文章将会对Go标准库net/http实现http服务的原理进行较为深入的探究，以此来学习了解网络编程的常见范式以及设计思路。

HTTP服务

基于HTTP构建的网络应用包括两个端，即客户端(Client)和服务端(Server)。两个端的交互行为包括从客户端发出request、服务端接受request进行处理并返回response以及客户端处理response。所以http服务器的工作就在于如何接受来自客户端的request，并向客户端返回response。

典型的http服务端的处理流程可以用下图表示：

服务器在接收到请求时，首先会进入路由(router)，这是一个Multiplexer，路由的工作在于为这个request找到对应的处理器(handler)，处理器对request进行处理，并构建response。Golang实现的http server同样遵循这样的处理流程。

我们先看看Golang如何实现一个简单的http server：

package main

import (
    "fmt"
    "net/http"
)

func indexHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "hello world")
}

func main() {
    http.HandleFunc("/", indexHandler)
    http.ListenAndServe(":8000", nil)
}

运行代码之后，在浏览器中打开localhost:8000就可以看到hello world。这段代码先利用http.HandleFunc在根路由/上注册了一个indexHandler, 然后利用http.ListenAndServe开启监听。当有请求过来时，则根据路由执行对应的handler函数。

我们再来看一下另外一种常见的http server实现方式：

package main

import (
    "fmt"
    "net/http"
)

type indexHandler struct {
    content string
}

func (ih *indexHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, ih.content)
}

func main() {
    http.Handle("/", &indexHandler{content: "hello world!"})
    http.ListenAndServe(":8001", nil)
}

Go实现的http服务步骤非常简单，首先注册路由，然后创建服务并开启监听即可。下文我们将从注册路由、开启服务、处理请求这几个步骤了解Golang如何实现http服务。

注册路由

http.HandleFunc和http.Handle都是用于注册路由，可以发现两者的区别在于第二个参数，前者是一个具有func(w http.ResponseWriter, r *http.Requests)签名的函数，而后者是一个结构体，该结构体实现了func(w http.ResponseWriter, r *http.Requests)签名的方法。
http.HandleFunc和http.Handle的源码如下：

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

// HandleFunc registers the handler function for the given pattern.
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    mux.Handle(pattern, HandlerFunc(handler))
}

func Handle(pattern string, handler Handler) { 
    DefaultServeMux.Handle(pattern, handler)
}

可以看到这两个函数最终都由DefaultServeMux调用Handle方法来完成路由的注册。
这里我们遇到两种类型的对象：ServeMux和Handler，我们先说Handler。

Handler

Handler是一个接口：

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Handler接口中声明了名为ServeHTTP的函数签名，也就是说任何结构只要实现了这个ServeHTTP方法，那么这个结构体就是一个Handler对象。其实go的http服务都是基于Handler进行处理，而Handler对象的ServeHTTP方法也正是用以处理request并构建response的核心逻辑所在。

回到上面的HandleFunc函数，注意一下这行代码：

mux.Handle(pattern, HandlerFunc(handler))

可能有人认为HandlerFunc是一个函数，包装了传入的handler函数，返回了一个Handler对象。然而这里HandlerFunc实际上是将handler函数做了一个类型转换，看一下HandlerFunc的定义：

type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

HandlerFunc是一个类型，只不过表示的是一个具有func(ResponseWriter, *Request)签名的函数类型，并且这种类型实现了ServeHTTP方法（在ServeHTTP方法中又调用了自身），也就是说这个类型的函数其实就是一个Handler类型的对象。利用这种类型转换，我们可以将一个handler函数转换为一个
Handler对象，而不需要定义一个结构体，再让这个结构实现ServeHTTP方法。读者可以体会一下这种技巧。

ServeMux

Golang中的路由（即Multiplexer）基于ServeMux结构，先看一下ServeMux的定义：

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    es    []muxEntry // slice of entries sorted from longest to shortest.
    hosts bool       // whether any patterns contain hostnames
}

type muxEntry struct {
    h       Handler
    pattern string
}

这里重点关注ServeMux中的字段m，这是一个map，key是路由表达式，value是一个muxEntry结构，muxEntry结构体存储了对应的路由表达式和handler。

值得注意的是，ServeMux也实现了ServeHTTP方法：

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    if r.RequestURI == "*" {
        if r.ProtoAtLeast(1, 1) {
            w.Header().Set("Connection", "close")
        }
        w.WriteHeader(StatusBadRequest)
        return
    }
    h, _ := mux.Handler(r)
    h.ServeHTTP(w, r)
}

也就是说ServeMux结构体也是Handler对象，只不过ServeMux的ServeHTTP方法不是用来处理具体的request和构建response，而是用来确定路由注册的handler。

注册路由

搞明白Handler和ServeMux之后，我们再回到之前的代码：

DefaultServeMux.Handle(pattern, handler)

这里的DefaultServeMux表示一个默认的Multiplexer，当我们没有创建自定义的Multiplexer，则会自动使用一个默认的Multiplexer。

然后再看一下ServeMux的Handle方法具体做了什么：

func (mux *ServeMux) Handle(pattern string, handler Handler) {
    mux.mu.Lock()
    defer mux.mu.Unlock()

    if pattern == "" {
        panic("http: invalid pattern")
    }
    if handler == nil {
        panic("http: nil handler")
    }
    if _, exist := mux.m[pattern]; exist {
        panic("http: multiple registrations for " + pattern)
    }

    if mux.m == nil {
        mux.m = make(map[string]muxEntry)
    }
    // 利用当前的路由和handler创建muxEntry对象
    e := muxEntry{h: handler, pattern: pattern}
    // 向ServeMux的map[string]muxEntry增加新的路由匹配规则
    mux.m[pattern] = e
    // 如果路由表达式以'/'结尾，则将对应的muxEntry对象加入到[]muxEntry中，按照路由表达式长度排序
    if pattern[len(pattern)-1] == '/' {
        mux.es = appendSorted(mux.es, e)
    }

    if pattern[0] != '/' {
        mux.hosts = true
    }
}

Handle方法主要做了两件事情：一个就是向ServeMux的map[string]muxEntry增加给定的路由匹配规则；然后如果路由表达式以'/'结尾，则将对应的muxEntry对象加入到[]muxEntry中，按照路由表达式长度排序。前者很好理解，但后者可能不太容易看出来有什么作用，这个问题后面再作分析。

自定义ServeMux

我们也可以创建自定义的ServeMux取代默认的DefaultServeMux：

package main

import (
    "fmt"
    "net/http"
)

func indexHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "hello world")
}

func htmlHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    html := `<!doctype html>
    <META http-equiv="Content-Type" content="text/html" charset="utf-8">
    <html lang="zh-CN">
            <head>
                    <title>Golang</title>
                    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0;" />
            </head>
            <body>
                <div id="app">Welcome!</div>
            </body>
    </html>`
    fmt.Fprintf(w, html)
}

func main() {
    mux := http.NewServeMux()
    mux.Handle("/", http.HandlerFunc(indexHandler))
    mux.HandleFunc("/welcome", htmlHandler)
    http.ListenAndServe(":8001", mux)
}

NewServeMux()可以创建一个ServeMux实例，之前提到ServeMux也实现了ServeHTTP方法，因此mux也是一个Handler对象。对于ListenAndServe()方法，如果传入的handler参数是自定义ServeMux实例mux，那么Server实例接收到的路由对象将不再是DefaultServeMux而是mux。

开启服务

首先从http.ListenAndServe这个方法开始：

func ListenAndServe(addr string, handler Handler) error {
    server := &Server{Addr: addr, Handler: handler}
    return server.ListenAndServe()
}

func (srv *Server) ListenAndServe() error {
    if srv.shuttingDown() {
        return ErrServerClosed
    }
    addr := srv.Addr
    if addr == "" {
        addr = ":http"
    }
    ln, err := net.Listen("tcp", addr)
    if err != nil {
        return err
    }
    return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

看一下Server这个结构体，Server结构体中字段比较多，可以先大致了解一下：

type Server struct {
    Addr    string  // TCP address to listen on, ":http" if empty
    Handler Handler // handler to invoke, http.DefaultServeMux if nil
    TLSConfig *tls.Config
    ReadTimeout time.Duration
    ReadHeaderTimeout time.Duration
    WriteTimeout time.Duration
    IdleTimeout time.Duration
    MaxHeaderBytes int
    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
    ConnState func(net.Conn, ConnState)
    ErrorLog *log.Logger

    disableKeepAlives int32     // accessed atomically.
    inShutdown        int32     // accessed atomically (non-zero means we're in Shutdown)
    nextProtoOnce     sync.Once // guards setupHTTP2_* init
    nextProtoErr      error     // result of http2.ConfigureServer if used

    mu         sync.Mutex
    listeners  map[*net.Listener]struct{}
    activeConn map[*conn]struct{}
    doneChan   chan struct{}
    onShutdown []func()
}

func (srv *Server) Serve(l net.Listener) error {
    ...

    baseCtx := context.Background() // base is always background, per Issue 16220
    ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    for {
        rw, e := l.Accept() // 等待新的连接建立

        ...

        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew) // before Serve can return
        go c.serve(ctx) // 创建新的协程处理请求
    }
}

这里隐去了一些细节，以便了解Serve方法的主要逻辑。首先创建一个上下文对象，然后调用Listener的Accept()等待新的连接建立；一旦有新的连接建立，则调用Server的newConn()创建新的连接对象，并将连接的状态标志为StateNew，然后开启一个新的goroutine处理连接请求。

处理连接

我们继续探索conn的serve()方法，这个方法同样很长，我们同样只看关键逻辑。坚持一下，马上就要看见大海了。

func (c *conn) serve(ctx context.Context) {

    ...

    for {
        w, err := c.readRequest(ctx)
        if c.r.remain != c.server.initialReadLimitSize() {
            // If we read any bytes off the wire, we're active.
            c.setState(c.rwc, StateActive)
        }

        ...

        // HTTP cannot have multiple simultaneous active requests.[*]
        // Until the server replies to this request, it can't read another,
        // so we might as well run the handler in this goroutine.
        // [*] Not strictly true: HTTP pipelining. We could let them all process
        // in parallel even if their responses need to be serialized.
        // But we're not going to implement HTTP pipelining because it
        // was never deployed in the wild and the answer is HTTP/2.
        serverHandler{c.server}.ServeHTTP(w, w.req)
        w.cancelCtx()
        if c.hijacked() {
            return
        }
        w.finishRequest()
        if !w.shouldReuseConnection() {
            if w.requestBodyLimitHit || w.closedRequestBodyEarly() {
                c.closeWriteAndWait()
            }
            return
        }
        c.setState(c.rwc, StateIdle)
        c.curReq.Store((*response)(nil))

        ...
    }
}

当一个连接建立之后，该连接中所有的请求都将在这个协程中进行处理，直到连接被关闭。在serve()方法中会循环调用readRequest()方法读取下一个请求进行处理，其中最关键的逻辑就是一行代码：

serverHandler{c.server}.ServeHTTP(w, w.req)

进一步解释serverHandler：

type serverHandler struct {
    srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
    handler := sh.srv.Handler
    if handler == nil {
        handler = DefaultServeMux
    }
    if req.RequestURI == "*" && req.Method == "OPTIONS" {
        handler = globalOptionsHandler{}
    }
    handler.ServeHTTP(rw, req)
}

在serverHandler的ServeHTTP()方法里的sh.srv.Handler其实就是我们最初在http.ListenAndServe()中传入的Handler对象，也就是我们自定义的ServeMux对象。如果该Handler对象为nil，则会使用默认的DefaultServeMux。最后调用ServeMux的ServeHTTP()方法匹配当前路由对应的handler方法。

后面的逻辑就相对简单清晰了，主要在于调用ServeMux的match方法匹配到对应的已注册的路由表达式和handler。

// ServeHTTP dispatches the request to the handler whose
// pattern most closely matches the request URL.
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
    if r.RequestURI == "*" {
        if r.ProtoAtLeast(1, 1) {
            w.Header().Set("Connection", "close")
        }
        w.WriteHeader(StatusBadRequest)
        return
    }
    h, _ := mux.Handler(r)
    h.ServeHTTP(w, r)
}

func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
    mux.mu.RLock()
    defer mux.mu.RUnlock()

    // Host-specific pattern takes precedence over generic ones
    if mux.hosts {
        h, pattern = mux.match(host + path)
    }
    if h == nil {
        h, pattern = mux.match(path)
    }
    if h == nil {
        h, pattern = NotFoundHandler(), ""
    }
    return
}

// Find a handler on a handler map given a path string.
// Most-specific (longest) pattern wins.
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
    // Check for exact match first.
    v, ok := mux.m[path]
    if ok {
        return v.h, v.pattern
    }

    // Check for longest valid match.  mux.es contains all patterns
    // that end in / sorted from longest to shortest.
    for _, e := range mux.es {
        if strings.HasPrefix(path, e.pattern) {
            return e.h, e.pattern
        }
    }
    return nil, ""
}

在match方法里我们看到之前提到的mux的m字段(类型为map[string]muxEntry)和es(类型为[]muxEntry)。这个方法里首先会利用进行精确匹配，在map[string]muxEntry中查找是否有对应的路由规则存在；如果没有匹配的路由规则，则会利用es进行近似匹配。

之前提到在注册路由时会把以'/'结尾的路由（可称为节点路由）加入到es字段的[]muxEntry中。对于类似/path1/path2/path3这样的路由，如果不能找到精确匹配的路由规则，那么则会去匹配和当前路由最接近的已注册的父节点路由，所以如果路由/path1/path2/已注册，那么该路由会被匹配，否则继续匹配下一个父节点路由，直到根路由/。

由于[]muxEntry中的muxEntry按照路由表达式从长到短排序，所以进行近似匹配时匹配到的节点路由一定是已注册父节点路由中最相近的。

至此，Go实现的http server的大致原理介绍完毕！

总结

Golang通过ServeMux定义了一个多路器来管理路由，并通过Handler接口定义了路由处理函数的统一规范，即Handler都须实现ServeHTTP方法；同时Handler接口提供了强大的扩展性，方便开发者通过Handler接口实现各种中间件。相信大家阅读下来也能感受到Handler对象在server服务的实现中真的无处不在。理解了server实现的基本原理，大家就可以在此基础上阅读一些第三方的http server框架，以及编写特定功能的中间件。

以上。

参考资料

【Golang标准库文档--net/http】https://studygolang.com/pkgdoc

长按二维码↑