go·标准库

[wxb]

标准库学习

[wxb]

os/exec

Package exec runs external commands. It wraps os.StartProcess to make it easier to remap stdin and stdout, connect I/O with pipes, and do other adjustments.

go os/exec 简明教程

鸟窝

Go 1.19变化

从Go 1.19开始，exec包定义了变量：

var ErrDot = errors.New("cannot run executable found relative to current directory")

无法运行相对于当前目录找到的可执行文件

LookPath 函数和Cmd结构体相关方法会在执行命令是相对路径时抛出ErrDot

注意ErrDot判断，不能使用err == ErrDot，应该使用errors.Is(err, ErrDot)

假定你坚持要使用相对地址命令 😂

• 以./开头重写相对地址命令："./prog" instead of "prog".

  Code that always wants to run a program from the current directory can be rewritten to say "./prog" instead of "prog".

• 重置忽略ErrDot错误

  Code that insists on including results from relative path entries can instead override the error using an errors.Is check:

  • LookPath

  path, err := exec.LookPath("prog")
  if errors.Is(err, exec.ErrDot) {
      err = nil
  }
  if err != nil {
      log.Fatal(err)
  }
  use(path)

  • Command

  cmd := exec.Command("prog")
  if errors.Is(cmd.Err, exec.ErrDot) {
      cmd.Err = nil
  }
  if err := cmd.Run(); err != nil {
      log.Fatal(err)
  }

命令搜索逻辑

源码

Command结构体的相关操作，在源码层面是依赖于LookPath方法的：
https://sourcegraph.com/github.com/golang/go/-/blob/src/os/exec/exec.go?L271:6&popover=pinned

func Command(name string, arg ...string) *Cmd {
	cmd := &Cmd{
		Path: name,
		Args: append([]string{name}, arg...),
	}
	if filepath.Base(name) == name {
		lp, err := LookPath(name)
		if lp != "" {
			// Update cmd.Path even if err is non-nil.
			// If err is ErrDot (especially on Windows), lp may include a resolved
			// extension (like .exe or .bat) that should be preserved.
			cmd.Path = lp
		}
		if err != nil {
			cmd.Err = err
		}
	}
	return cmd
}

所以，我们要搞清楚命令搜索逻辑主要是搞清楚LookPath方法的内容：
https://sourcegraph.com/github.com/golang/go/-/blob/src/os/exec/lp_unix.go?L40:6&popover=pinned

func LookPath(file string) (string, error) {
	// NOTE(rsc): I wish we could use the Plan 9 behavior here
	// (only bypass the path if file begins with / or ./ or ../)
	// but that would not match all the Unix shells.

	if strings.Contains(file, "/") {
		err := findExecutable(file)
		if err == nil {
			return file, nil
		}
		return "", &Error{file, err}
	}
	path := os.Getenv("PATH")
	for _, dir := range filepath.SplitList(path) {
		if dir == "" {
			// Unix shell semantics: path element "" means "."
			dir = "."
		}
		path := filepath.Join(dir, file)
		if err := findExecutable(path); err == nil {
			if !filepath.IsAbs(path) && godebug.Get("execerrdot") != "0" {
				return path, &Error{file, ErrDot}
			}
			return path, nil
		}
	}
	return "", &Error{file, ErrNotFound}
}

逻辑图

Cmd不能重用

Cmd的数据结构，代表了一个执行的外部命令，主要调用它的Run、Output、CombinedOutput方法后这个对象就不能重用了

A Cmd cannot be reused after calling its Run, Output or CombinedOutput methods.

[wxb]

encoding/json

Package json implements encoding and decoding of JSON as defined in RFC 7159. The mapping between JSON and Go values is described in the documentation for the Marshal and Unmarshal functions.

omitempty

The "omitempty" option specifies that the field should be omitted from the encoding if the field has an empty value, defined as false, 0, a nil pointer, a nil interface value, and any empty array, slice, map, or string.

"omitempty"选项指定如果字段有一个空值，该字段应该从编码中被忽略，这个空值被定义为false、0、nil指针、nil接口值和任何空数组、切片、映射或字符串。

// Field appears in JSON as key "myName".
Field int `json:"myName"`

// Field appears in JSON as key "myName" and
// the field is omitted from the object if its value is empty,
// as defined above.
Field int `json:"myName,omitempty"`

// Field appears in JSON as key "Field" (the default), but
// the field is skipped if empty.
// Note the leading comma.
Field int `json:",omitempty"`

-

As a special case, if the field tag is "-", the field is always omitted. Note that a field with name "-" can still be generated using the tag "-,".

作为特殊情况，如果字段标记为“-”，该字段总是被省略。请注意，使用标记"-,"仍然可以生成名称为"-"的字段。

// Field is ignored by this package.
Field int `json:"-"`

// Field appears in JSON as key "-".
Field int `json:"-,"`

[wxb]

io包

[wxb]

一图掌握 Go 中 IO 包的关系

• io：基础的IO库，提供了Reader和Writer接口。其中的os包、net包、string包、bytes包以及bufio包都实现了io中的Reader或Writer接口。
• os：提供了访问底层操作系统资源的能力，如文件读写、进程控制等。
• net：提供了网络相关的IO功能，如TCP、UDP通信、HTTP请求等。
• string.Reader：提供了string的读取。因为string不能写，所以只有Reader。
• bytes.Buffer和Reader：提供了对字节内容的读写。
• bufio：提供带缓存的I/O操作，解决频繁、少量读取场景下的性能问题。这里利用了计算机的局部性原理。
• ioutil：提供了一些方便的文件读写函数，如ReadFile和WriteFile。

[wxb]

net/http

常量

变量

方法

• func DetectContentType
  DetectContentType 方法实现了 https://mimesniff.spec.whatwg.org/ 中描述的算法，以确定给定数据的Content-Type。它最多考虑数据的前512字节。DetectContentType 总是返回一个有效的MIME类型:如果它不能确定一个更具体的MIME类型，它返回 "application/octet-stream"

[wxb]

Go 标准库中隐藏了一个文件类型识别的宝贝

• 文件类型识别的常用方法有两种：

  • 一种是根据文件的扩展名来判断，比如 .jpg 表示 JPEG 图像，.mp3 表示 MP3 音频等；
  • 另一种是根据文件内容的特征来判断，比如 JPEG 图像的前几个字节是 FF D8 FF，MP3 音频的前几个字节是 ID3 等。

• 两种方法各有优缺点:

  • 扩展名方法简单快速，但是容易被伪造或者缺失；
  • 内容特征方法准确可靠，但是需要读取文件内容并进行分析。

• DetectContentType()

  • 该方法读取文件内容的前 512 个字节内容，返回一个 MIME 类型字符串（如 image/jpeg）。它根据一组预定义的规则来匹配文件内容的特征和对应的 MIME 类型（ mimesniff 算法）。
  • 这个方法既不依赖于文件扩展名，也不需要完整地读取文件内容，因此既快速又准确。

• 示例

  func main() {
   // 打开一个 MP3 文件
   file, err := os.Open("example.mp3")
   if err != nil {
    fmt.Println(err)
    return
   }
   defer file.Close()
  
   // 读取文件的前 512 个字节
   buffer := make([]byte, 512)
   n, err := file.Read(buffer)
   if err != nil {
    fmt.Println(err)
    return
   }
  
   // 调用 http.DetectContentType 方法判断文件类型
    // 实际上，如果字节数超过 512，该函数也只会使用前 512 个字节
   contentType := http.DetectContentType(buffer[:n])
   fmt.Println(contentType) // 输出 audio/mpeg
  
  
    // contentType 可以通过以下方式返回具体的扩展名：
    // 上面 mp3 文件返回的会是 .mp3，注意包含 .
    ext := mime.ExtensionsByType(contentType)
  }

[wxb]

文件类型识别 开源库

• go·开源库 #134 (comment)
• go·开源库 #134 (comment)

[wxb]

net/url

[wxb]

Go中url.ParseRequestURI和url.Parse函数的踩坑记

• url.Parse和url.ParseRequestURI

  • url.Parse

    // Parse parses a raw url into a URL structure.
    //
    // The url may be relative (a path, without a host) or absolute
    // (starting with a scheme). Trying to parse a hostname and path
    // without a scheme is invalid but may not necessarily return an
    // error, due to parsing ambiguities.
    func Parse(rawURL string) (*URL, error) {
        // Cut off #frag
        u, frag, _ := strings.Cut(rawURL, "#")
        url, err := parse(u, false)
        if err != nil {
    	    return nil, &Error{"parse", u, err}
        }
        if frag == "" {
    	    return url, nil
        }
        if err = url.setFragment(frag); err != nil {
    	    return nil, &Error{"parse", rawURL, err}
        }
        return url, nil
    }

  • url.ParseRequestURI

    // ParseRequestURI parses a raw url into a URL structure. It assumes that
    // url was received in an HTTP request, so the url is interpreted
    // only as an absolute URI or an absolute path.
    // The string url is assumed not to have a #fragment suffix.
    // (Web browsers strip #fragment before sending the URL to a web server.)
    func ParseRequestURI(rawURL string) (*URL, error) {
        url, err := parse(rawURL, true)
        if err != nil {
    	    return nil, &Error{"parse", rawURL, err}
        }
        return url, nil
    }

• url.Parse和url.ParseRequestURI的区别
  
  url.Parse显示以 将 # 符号前后做了截断处理。而ParseRequestURI函数则没有。其他的两个函数基本是一样的。

• URL中的 # 号是什么
  "#"号代表网页中的一个位置。其右面的字符，就是该位置的标识符。浏览器会自动滚动至网页标识符位置：

  • 锚点
  • id属性

• 浏览器HTTP请求不包括 “#”
  #是用来指导浏览器动作的，对服务器端完全无用。所以，HTTP请求中不包括#。比如，访问下面的网址

  http://www.example.com/index.html#print
  

  浏览器实际发出的请求是这样的：

   GET /index.html HTTP/1.1
  
   Host: www.example.com
  

• #后的字符
  只有将#转码为%23，浏览器才会将其作为实义字符处理

  http://example.com/?color=%23fff
  

总结
#号是给浏览器用来定位网页位置用的。在url中包含#号时，浏览器不会将其后面的字符串发送到服务端。但如果是服务端通过程序发送url时，则不受这个限制。所以，在使用url.Parse解析url地址时，需要注意其会以#号为基准，将url地址截取为两部分。但url.ParseRequestURI则不会。在实际使用中根据自己的使用场景要正确选择。

[wxb]

golang.org/x/mod

This repository holds packages for writing tools that work directly with Go module mechanics. That is, it is for direct manipulation of Go modules themselves.

这个库包含直接使用Go模块机制的编写工具的包。也就是说，它用于直接操作Go模块本身

[wxb]

golang.org/x/mod/modfile

Package modfile implements a parser and formatter for go.mod files.

modfile 包是实现go.mod文件的解析器和格式化器

自研工具包

• github.com/wxb/got/modparser go.mod 文件解析

[wxb]

go

[wxb]

go/ast

Package ast declares the types used to represent syntax trees for Go packages.

ast包定义了用于表示Go包的语法树的类型

[wxb]

go/parser

Package parser implements a parser for Go source files.

parser包实现了一个go源码文件解析器