2018-07-20 08:22:37

goweb-037-golang-常用包

以示例的方式演示常用包的用法,更详细深入的信息请参考 https://golang.google.cn/pkg/标准库
alt

os

  • os包提供了操作系统函数的不依赖平台的接口。设计为Unix风格的,错误处理是go风格的;失败的调用会返回错误值而非错误码。
  • 通常错误值里包含更多信息。

os包的接口规定为在所有操作系统中都是一致的。

打开一个文件并从中读取一些数据。

file, err := os.Open("file.go")
if err != nil {
    log.Fatal(err)
}

如果打开失败,错误字符串是自解释的。
open file.go: no such file or directory

文件的信息可以读取进一个[]byte切片。ReadWrite方法从切片参数获取其内的字节数。

data := make([]byte, 100)
count, err := file.Read(data)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("read %d bytes: %q\n", count, data[:count])

标准的文件信息

type FileInfo interface {
    Name() string       // base name of the file
    Size() int64        // length in bytes for regular files; system-dependent for others
    Mode() FileMode     // file mode bits
    ModTime() time.Time // modification time
    IsDir() bool        // abbreviation for Mode().IsDir()
    Sys() interface{}   // underlying data source (can return nil)
}

常用方法

  • Stat
    func Stat(name string) (fi FileInfo, err error)
    Stat返回一个描述name指定的文件对象的FileInfo
    f, _ := os.Stat(`main.go`)
    fmt.Println(f.Name(), f.IsDir(), f.ModTime())
    
  • Mkdir
    func Mkdir(name string, perm FileMode) error
    Mkdir使用指定的权限和名称创建一个目录。
    os.Mkdir(`dir`, 0777)
    
    alt
  • MkdirAll
    func MkdirAll(path string, perm FileMode) error
    MkdirAll使用指定的权限和名称创建一个目录,包括任何必要的上级目录,并返回nil,否则返回错误。
    权限位perm会应用在每一个被本函数创建的目录上。
    如果path指定了一个已经存在的目录,MkdirAll不做任何操作并返回nil。

    os.MkdirAll(`a/b/c/d`, 0777)
    

    alt

  • Rename
    func Rename(oldpath, newpath string) error
    Rename修改一个文件的名字,移动一个文件。可能会有一些个操作系统特定的限制。

    os.Rename(`dir`, `dir1`)
    

    alt

  • Remove
    func Remove(name string) error
    Remove删除name指定的文件或目录。
    os.Remove(`dir1`)
    
    alt
  • RemoveAll
    func RemoveAll(path string) error
    RemoveAll删除path指定的文件,或目录及它包含的任何下级对象。它会尝试删除所有东西,除非遇到错误并返回。
    如果path指定的对象不存在,RemoveAll会返回nil而不返回错误。
    os.RemoveAll(`a`)
    
    alt
  • Create
    func Create(name string) (file *File, err error)
    Create采用模式0666✋创建一个名为name的文件,如果文件已存在会置为空文件。
    如果成功,返回的文件对象可用于I/O;对应的文件描述符具有O_RDWR模式。

  • Open
    func Open(name string) (file *File, err error) Open打开一个文件用于读取。如果操作成功,返回的文件对象的方法可用于读取数据;对应的文件描述符具有O_RDONLY模式。

    fout, _ := os.Create(`output.txt`)
    fin, _ := os.Open(`main.go`)
    io.Copy(fout, fin)//io包
    
  • OpenFile
    func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
    OpenFile是一个更一般性的文件打开函数,大多数调用者都应用OpenCreate代替本函数。
    它会使用指定的选项(如O_RDONLY等)、指定的模式(如0666等)打开指定名称的文件。
    如果操作成功,返回的文件对象可用于I/O
    fout, _ := os.Create(`output.txt`)
    fin, _ := os.OpenFile(`main.go`, os.O_RDWR, 0666)
    io.Copy(fout, fin)
    
  • Readdir func (f *File) Readdir(n int) (fi []FileInfo, err error)
    Readdir读取目录f的内容,返回一个有n个成员的[]FileInfo,采用目录顺序。 对本函数的下一次调用会返回上一次调用剩余未读取的内容的信息。
    如果n>0Readdir函数会返回一个最多n个成员的切片。
    如果n<=0Readdir函数返回目录中剩余所有文件对象的FileInfo构成的切片。
    dir, _ := os.Open(`util`)
    dirs, _ := dir.Readdir(-1)
    for idx := range dirs {
      fmt.Println(dirs[idx].Name())
    }
    
  • Read
    func (f *File) Read(b []byte) (n int, err error)
    Read方法从f中读取最多len(b)字节数据并写入b。它返回读取的字节数和可能遇到的任何错误。文件终止标志是读取0个字节且返回值errio.EOF
  • Write
    func (f *File) Write(b []byte) (n int, err error)
    Write向文件中写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b),本方法会返回一个非nil的错误。
  • Close
    func (f *File) Close() error
    Close关闭文件f,使文件不能用于读写。它返回可能出现的错误。
    fin, _ := os.Open(`main.go`)
    fout, _ := os.Create(`output.txt`)
    //准备容器
    buf := make([]byte, 128)
    for {
      n, err := fin.Read(buf)
      if n == 0 || err == io.EOF {
          break
      }
      fout.Write(buf[:n])
    }
    fin.Close()
    fout.Close()
    
  • WriteString
    func (f *File) WriteString(s string) (ret int, err error)
    WriteString 类似Write,但接受一个字符串参数。
fout, _ := os.Create(`output.txt`)
defer fout.Close()
fout.WriteString(`WriteString`)

io && ioutil

  • eof var EOF = errors.New("EOF")
    EOF当无法得到更多输入时,Read方法返回EOF☂️。当函数一切正常的到达输入的结束时,就应返回EOF

  • Copy func Copy(dst Writer, src Reader) (written int64, err error)

  • src的数据拷贝到dst,直到在src上到达EOF或发生错误。返回拷贝的字节数和遇到的第一个错误。
  • 对成功的调用,返回值err为nil而非EOF,因为Copy定义为从src读取直到EOF,它会将读取到EOF视为应报告的错误。
    fout, _ := os.Create(`output.txt`)
    fin, _ := os.OpenFile(`main.go`, os.O_RDWR, 0666)
    io.Copy(fout, fin)
    

    ioutil

  • ReadAll
    func ReadAll(r io.Reader) ([]byte, error)
    ReadAllr读取数据直到EOF或遇到error,返回读取的数据和遇到的错误。
    成功的调用返回的errnil而非EOF。因为本函数定义为读取r直到EOF,它不会将读取返回的EOF视为应报告的错误。
package main
import (
    "fmt"
    "io/ioutil"
    "log"
    "strings"
)
func main() {
    r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
    b, err := ioutil.ReadAll(r)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s", b)
}
  • ReadFile
    func ReadFile(filename string) ([]byte, error)
    ReadFilefilename指定的文件中读取数据并返回文件的内容。成功的调用返回的errnil而非EOF。因为本函数定义为读取整个文件,它不会将读取返回的EOF视为应报告的错误。
package main
import (
    "fmt"
    "io/ioutil"
    "log"
)
func main() {
    content, err := ioutil.ReadFile("testdata/hello")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("File contents: %s", content)
}
  • WriteFile
    func WriteFile(filename string, data []byte, perm os.FileMode) error
    函数向filename指定的文件中写入数据。如果文件不存在将按给出的权限创建文件,否则在写入数据之前清空文件。
package main
import "io/ioutil"
func main() {
    ioutil.WriteFile("1.txt", []byte(`string`), 0777)
}
  • ReadDir func ReadDir(dirname string) ([]os.FileInfo, error)
    返回dirname指定的目录的目录信息的有序列表。
package main
import (
    "fmt"
    "io/ioutil"
    "log"
)
func main() {
    files, err := ioutil.ReadDir(".")
    if err != nil {
        log.Fatal(err)
    }
    for _, file := range files {
        fmt.Println(file.Name())
    }
}

strings

  • Compare
    func Compare(a, b string) int
    Compare returns an integer comparing two strings lexicographically. The result will be 0 if a==b, -1 if a < b, and +1 if a > b.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.Compare("a", "b"))
      fmt.Println(strings.Compare("a", "a"))
      fmt.Println(strings.Compare("b", "a"))
    }
    
  • Contains
    func Contains(s, substr string) bool
    Contains reports whether substr is within s.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.Contains("seafood", "foo"))
      fmt.Println(strings.Contains("seafood", "bar"))
      fmt.Println(strings.Contains("seafood", ""))
      fmt.Println(strings.Contains("", ""))
    }
    
  • Count
    func Count(s, substr string) int
    Count counts the number of non-overlapping instances of substr in s. If substr is an empty string, Count returns 1 + the number of Unicode code points in s.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.Count("cheese", "e"))
      fmt.Println(strings.Count("five", "")) // before & after each rune
    }
    
  • HasPrefix
    func HasPrefix(s, prefix string) bool
    HasPrefix tests whether the string s begins with prefix
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.HasPrefix("Gopher", "Go"))
      fmt.Println(strings.HasPrefix("Gopher", "C"))
      fmt.Println(strings.HasPrefix("Gopher", ""))
    }
    
  • HasSuffix func HasSuffix(s, suffix string) bool
    HasSuffix tests whether the string s ends with suffix.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.HasSuffix("Amigo", "go"))
      fmt.Println(strings.HasSuffix("Amigo", "O"))
      fmt.Println(strings.HasSuffix("Amigo", "Ami"))
      fmt.Println(strings.HasSuffix("Amigo", ""))
    }
    
  • Index
    func Index(s, substr string) int
    Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.Index("chicken", "ken"))
      fmt.Println(strings.Index("chicken", "dmr"))
    }
    
  • Join
    func Join(a []string, sep string) string
    Join concatenates the elements of a to create a single string. The separator string sep is placed between elements in the resulting string.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      s := []string{"foo", "bar", "baz"}
      fmt.Println(strings.Join(s, ", "))
    }
    
  • Replace func Replace(s, old, new string, n int) string
    Replace returns a copy of the string s with the first n non-overlapping instances of old replaced by new. If old is empty, it matches at the beginning of the string and after each UTF-8 sequence, yielding up to k+1 replacements for a k-rune string. If n < 0, there is no limit on the number of replacements.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
      fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
    }
    
  • Split func Split(s, sep string) []string Split slices s into all substrings separated by sep and returns a slice of the substrings between those separators.
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Printf("%q\n", strings.Split("a,b,c", ","))
      fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
      fmt.Printf("%q\n", strings.Split(" xyz ", ""))
      fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
    }
    
  • ToLower
    func ToLower(s string) string
    ToLower returns a copy of the string s with all Unicode letters mapped to their lower case.

    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.ToLower("Gopher"))
    }
    
  • ToUpper
    func ToUpper(s string) string
    ToUpper returns a copy of the string s with all Unicode letters mapped to their upper case.

    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      fmt.Println(strings.ToUpper("Gopher"))
    }
    
  • Builder
    ⚡️ A Builder is used to efficiently build a string using Write methods. It minimizes memory copying. The zero value is ready to use. Do not copy a non-zero Builder.

    type Builder struct {
          // contains filtered or unexported fields
    }
    
    package main
    import (
      "fmt"
      "strings"
    )
    func main() {
      var b strings.Builder
      for i := 3; i >= 1; i-- {
          fmt.Fprintf(&b, "%d...", i)
      }
      b.WriteString("ignition")
      fmt.Println(b.String())
    }
    

bytes

  • bytes 包使用方式同strings包
  • bytes 包操作对象为[]byte
  • strings包操作对象为string

直接操作不舒服 正则走一波

本文链接:https://www.paishouba.com/post/goweb-03-7.html

-- EOF --

Comments