Go语言文件读取

幸运草
幸运草
幸运草
896
文章
3
评论
2020年4月18日22:56:50 评论 112

Go语言文件读取

文件读取

读取文件内容如下:

cat ./file.txt 
最近很火的一首小诗:

纽约时间比加州时间早三个小时,

New York is 3 hours ahead of California,

但加州时间并没有变慢。

but it does not make California slow.

有人22岁就毕业了,

Someone graduated at the age of 22,

但等了五年才找到好的工作!

but waited 5 years before securing a good job!

有人25岁就当上CEO,

Someone became a CEO at 25,

却在50岁去世。

and died at 50.

也有人迟到50岁才当上CEO,

While another became a CEO at 50,

然后活到90岁。

and lived to 90 years.

有人依然单身,

Someone is still single,

同时也有人已婚。

while someone else got married.

奥巴马55岁就退休,

Obama retires at 55,

川普70岁才开始当总统。

but Trump starts at 70.

世上每个人本来就有自己的发展时区。

Absolutely everyone in this world works based on their Time Zone.

身边有些人看似走在你前面,

People around you might seem to go ahead of you,

也有人看似走在你后面。

some might seem to be behind you.

但其实每个人在自己的时区有自己的步程。

But everyone is running their own RACE, in their own TIME.

不用嫉妒或嘲笑他们。

Don’t envy them or mock them.

他们都在自己的时区里,你也是!

They are in their TIME ZONE, and you are in yours!

生命就是等待正确的行动时机。

Life is about waiting for the right moment to act.

所以,放轻松。

So, RELAX.

你没有落后。

You’re not LATE.

你没有领先。

You’re not EARLY.

在命运为你安排的属于自己的时区里,一切都准时。

You are very much ON TIME, and in your TIME ZONE Destiny set up for you.

使用 os包按byte读取文件常用方法:

func (f *File) Read(b []byte) (n int, err error)

Read方法从f中读取最多len(b)字节数据并写入b。它返回读取的字节数和可能遇到的任何错误。文件终止标志是读取0个字节且返回值err为io.EOF。

func (f *File) ReadAt(b []byte, off int64) (n int, err error)

ReadAt从指定的位置(相对于文件开始位置)读取len(b)字节数据并写入b。它返回读取的字节数和可能遇到的任何错误。当n<len(b)时,本方法总是会返回错误;如果是因为到达文件结尾,返回值err会是io.EOF。

代码实现:

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("./file.txt")
    if err != nil {
        fmt.Printf("open ./file.txt err : %vn", err)
    }
    if file != nil {
        defer func(file *os.File) { file.Close() }(file)
    }

    var b1 = make([]byte, 102)
    space1, err := file.Read(b1)
    if err != nil {
        fmt.Printf("file read err : %vn", err)
    }
    fmt.Printf("file read success , 读取 %d 字节。n", space1)
    fmt.Printf("读取内容:n%sn", string(b1))

    b2 := make([]byte, 205)
    space2, err := file.ReadAt(b2, int64(space1))
    if err != nil {
        fmt.Printf("file readat err : %vn", err)
    }
    fmt.Printf("file readat success , 读取 %d 字节。n", space2)
    fmt.Printf("读取内容:n%sn", string(b2))
}

缓冲读取

bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象,创建另一个也实现了该接口,且同时还提供了缓冲和一些文本I/O的帮助函数的对象。

缓冲读取常用函数和方法:

func NewReader(rd io.Reader) *Reader

NewReader创建一个具有默认大小缓冲、从r读取的*Reader。

func (b *Reader) Read(p []byte) (n int, err error)

Read读取数据写入p。本方法返回写入p的字节数。本方法一次调用最多会调用下层Reader接口一次Read方法,因此返回值n可能小于len(p)。读取到达结尾时,返回值n将为0而err将为io.EOF。

func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)

ReadLine是一个低水平的行数据读取原语。大多数调用者应使用ReadBytes('n')或ReadString('n')代替,或者使用Scanner。

ReadLine尝试返回一行数据,不包括行尾标志的字节。如果行太长超过了缓冲,返回值isPrefix会被设为true,并返回行的前面一部分。该行剩下的部分将在之后的调用中返回。返回值isPrefix会在返回该行最后一个片段时才设为false。返回切片是缓冲的子切片,只在下一次读取操作之前有效。ReadLine要么返回一个非nil的line,要么返回一个非nil的err,两个返回值至少一个非nil。

返回的文本不包含行尾的标志字节("rn"或"n")。如果输入流结束时没有行尾标志字节,方法不会出错,也不会指出这一情况。在调用ReadLine之后调用UnreadByte会总是吐出最后一个读取的字节(很可能是该行的行尾标志字节),即使该字节不是ReadLine返回值的一部分。

func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

ReadSlice读取直到第一次遇到delim字节,返回缓冲里的包含已读取的数据和delim字节的切片。该返回值只在下一次读取操作之前合法。如果ReadSlice放在在读取到delim之前遇到了错误,它会返回在错误之前读取的数据在缓冲中的切片以及该错误(一般是io.EOF)。如果在读取到delim之前缓冲就被写满了,ReadSlice失败并返回ErrBufferFull。因为ReadSlice的返回值会被下一次I/O操作重写,调用者应尽量使用ReadBytes或ReadString替代本法功法。当且仅当ReadBytes方法返回的切片不以delim结尾时,会返回一个非nil的错误。

func (b *Reader) ReadBytes(delim byte) (line []byte, err error)

ReadBytes读取直到第一次遇到delim字节,返回一个包含已读取的数据和delim字节的切片。如果ReadBytes方法在读取到delim之前遇到了错误,它会返回在错误之前读取的数据以及该错误(一般是io.EOF)。当且仅当ReadBytes方法返回的切片不以delim结尾时,会返回一个非nil的错误。

func (b *Reader) ReadString(delim byte) (line string, err error)

ReadString读取直到第一次遇到delim字节,返回一个包含已读取的数据和delim字节的字符串。如果ReadString方法在读取到delim之前遇到了错误,它会返回在错误之前读取的数据以及该错误(一般是io.EOF)。当且仅当ReadString方法返回的切片不以delim结尾时,会返回一个非nil的错误。

代码实现:

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open("./file.txt")
    if err != nil {
        fmt.Printf("os open ./file.txt err : %vn", err)
    }
    if file != nil {
        defer func(file *os.File) { file.Close() }(file)
    }

    read1 := bufio.NewReader(file)

    var b1 = make([]byte, 102)
    readByte1, err := read1.Read(b1)
    if err != nil {
        fmt.Printf("read err : %vn", err)
    }
    fmt.Printf("read success , 读取 %d 字节n读取的内容:n%sn", readByte1, string(b1))

    var line []byte
    for {
        data, prefix, err := read1.ReadLine()
        if err == io.EOF {
            // fmt.Println(err)
            break
        }

        line = append(line, data...)
        if !prefix {
            // fmt.Printf("data:%sn", string(line))
        }
    }
    fmt.Println(string(line))
}

读取整个文件

使用 io/ioutil 包实现了读取整个文件功能

读取整个文件常用函数:

func ReadAll(r io.Reader) ([]byte, error)

ReadAll从r读取数据直到EOF或遇到error,返回读取的数据和遇到的错误。成功的调用返回的err为nil而非EOF。因为本函数定义为读取r直到EOF,它不会将读取返回的EOF视为应报告的错误。

func ReadFile(filename string) ([]byte, error)

ReadFile 从filename指定的文件中读取数据并返回文件的内容。成功的调用返回的err为nil而非EOF。因为本函数定义为读取整个文件,它不会将读取返回的EOF视为应报告的错误。

代码实现:

package main

import (
    "fmt"
    "io/ioutil"
    "os"
)

func main() {
    file, err := os.Open("./file.txt")
    if err != nil {
        fmt.Printf("open ./file.txt err : %vn", err)
    }
    if file != nil {
        defer func(file *os.File) { file.Close() }(file)
    }

    data1, err := ioutil.ReadAll(file)
    if err != nil {
        fmt.Printf("ioutil read all err : %vn", err)
    }
    fmt.Printf("ioutil read all success.n内容:n%sn", string(data1))

    data2, err := ioutil.ReadFile("./file.txt")
    if err != nil {
        fmt.Printf("ioutil read file err : %vn", err)
    }
    fmt.Printf("ioutil read file success.n内容:n%sn", string(data2))
}

特别声明:以上文章内容仅代表作者本人观点,不代表变化吧观点或立场。如有关于作品内容、版权或其它问题请于作品发表后的30日内与变化吧联系。

转载请注明:{{title}}-变化吧
  • 赞助本站
  • 微信扫一扫
  • weinxin
  • 赞助本站
  • 支付宝扫一扫
  • weinxin
幸运草
Go语言接口规则 前端框架

Go语言接口规则

Go语言接口规则 接口是一个或多个方法签名的集合。任何类型的方法集中只要拥有该接口对应的全部方法签名。就表示它 "实现" 了该接口,无须在该类型上显式声明实现了哪个接口。对应方法,是指有相同名称、参数列表 (不包括参数名) 以及返回值,该类型也可以有其他方法。 接口赋值 对象赋值给接口时,会发生拷贝,而接口内部存储的是指向这个复制品的指针,既无法修改复制品的状态,也无法获取指针。 package main import "fmt" type User struct {     id   int     name string } func main() {     u := User{18, "oldboy"}     var i interface{} = u     u.id = 20     u.name = "Golang"     fmt.Printf("u : %vn", u)     fmt.Printf("i.(User) : %vn", i.(User)) } 运行结果: u : {20 Golang} i.(User) : {18 oldboy} 接口转型返回临时对象,只有使用指针才能修改其状态。 package main import "fmt" type User struct {     id   int     name string } func main() {     u := User{18, "oldboy"}     var vi, pi interface{} = u, &u     // vi.(User).name = "Golang"     pi.(*User).name = "Golang"     fmt.Printf("vi.(User) : %vn", vi.(User))     fmt.Printf("pi.(*User) : %vn", pi.(*User)) } 空接口 只有当接口存储的类型和对象都为nil时,接口才等于nil。 package main import (     "fmt" ) func main() {     var i interface{}     fmt.Printf("i => %vn", i)     fmt.Printf("(i == nil) => %vn", i == nil)     var p *int = nil     // i 指向 p,指向的对象是个nil,但是存在类型不是nil,是个指针     i = p     fmt.Printf("i => %vn", i)     fmt.Printf("(i == nil) => %vn", i == nil) } 运行结果: i => <nil> (i == nil) => true i => <nil> (i == nil) => false 接口实现 接口只有方法声明,没有数据字段,没有实现,也不需要显示的实现。只要一个变量,含有接口类型中的所有方法,那么这个变量就实现这个接口。 package main import (     "fmt" ) type Info interface {     GetAge() int     GetName() string } type User struct {     name string     age  int } func (u User) GetAge() int {     return u.age } func (u User) GetName() string {     return u.name } func main() {     var user Info = User{"oldboy", 18}     age := user.GetAge()     name := user.GetName()     fmt.Println(age, name) } 如果一个变量含有了多个interface类型的方法,那么这个变量就实现了多个接口。 package main import (     "fmt" ) type Age interface {     GetAge() int } type Name interface {     GetName() int } type User struct {     name string...
Go语言中处理 HTTP 服务器 前端框架

Go语言中处理 HTTP 服务器

1 概述 包 net/http 提供了HTTP服务器端和客户端的实现。本文说明关于服务器端的部分。 快速开始: package main import (   "log"   "net/http" ) func main() {   // 设置 路由   http.HandleFunc("/", IndexAction)   // 开启监听   log.Fatal(http.ListenAndServe(":8888", nil)) } func IndexAction(w http.ResponseWriter, r *http.Request) {  w.Write(byte(`<h1 align="center">来自变化吧的问候</h1>`)) } 运行程序,在浏览器上请求: localhost:8888,你会看到我们的结果 Go语言构建HTTP服务器还是很容易的。深入说明。 2 http.Server 类型 HTTP 服务器在 Go 语言中是由 http.Server 结构体对象实现的。参考 http.ListenAndServe() 的实现: // 文件:src/net/http/server.go // ListenAndServe always returns a non-nil error. func ListenAndServe(addr string, handler Handler) error {   server := &Server{Addr: addr, Handler: handler}   return server.ListenAndServe() } 可见过程是先实例化 Server 对象,再完成 ListenAndServe 。其中 Serve 对象就是表示 HTTP 服务器的对象。其结构如下 : // 文件:src/net/http/server.go type Server struct {   Addr    string  // TCP 监听地址, 留空为:":http"   Handler Handler // 调用的 handler(路由处理器), 设为 nil 表示 http.DefaultServeMux   TLSConfig *tls.Config // TLS 配置对象   ReadTimeout time.Duration // 请求超时时长   ReadHeaderTimeout time.Duration // 请求头超时时长   WriteTimeout time.Duration // 响应超时时长   IdleTimeout time.Duration // 请求空闲时长(keep-alive下两个请求间)   MaxHeaderBytes int // 请求头的最大长度   TLSNextProto mapfunc(*Server, *tls.Conn, Handler) // NPN 型协议升级出现时接管TLS连接的处理器函数映射表   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  mapstruct{}   activeConn mapstruct{}   doneChan   chan struct{}   onShutdown func() } 可见 Server 定义了服务器需要的信息。 实例化了 Server 对象后,调用其 (srv *Server) ListenAndServe() error 方法。该方法会监听 srv.Addr 指定的 TCP 地址,并通过 (srv *Server) Serve(l net.Listener) error 方法接收浏览器端连接请求。Serve 方法会接收监听器 l 收到的每一个连接,并为每一个连接创建一个新的服务进程。 该 go...
go语言动态库的编译和使用 前端框架

go语言动态库的编译和使用

本文主要介绍go语言动态库的编译和使用方法,以linux平台为例,windows平台步骤一样,具体环境如下: $ echo $GOPATH /media/sf_share/git/go_practice $ echo $GOROOT /usr/lib/golang/ $ tree $GOPATH/src /media/sf_share/git/go_practice/src |-- demo |   `-- demo.go `-- main.go 1 directory, 2 files 在$GOPATH/src目录,有demo包和使用demo包的应用程序main.go,main.go代码如下: package main import "demo" func main() {    demo.Demo() } demo包中的demo.go代码如下: package demo import "fmt" func Demo() {    fmt.Println("call demo ...") } 由于demo.go是$GOPATH/src目录下的一个包,main.go在import该包后,可以直接使用,运行main.go: $ go run main.go call demo ... 现在,需要将demo.go编译成动态库libdemo.so,让main.go以动态库方式编译,详细步骤如下: 1 将go语言标准库编译成动态库 $ go install -buildmode=shared -linkshared  std 在命令行运行go install -buildmode=shared -linkshared  std命令,-buildmode指定编译模式为共享模式,-linkshared表示链接动态库,成功编译后会在$GOROOT目录下生标准库的动态库文件libstd.so,一般位于$GOROOT/pkg/linux_amd64_dynlink目录: $ cd $GOROOT/pkg/linux_amd64_dynlink $ ls libstd.so libstd.so 2 将demo.go编译成动态库 $ go install  -buildmode=shared -linkshared demo $ cd $GOPATH/pkg $ ls linux_amd64_dynlink/ demo.a  demo.shlibname  libdemo.so 成功编译后会在$GOPATH/pkg目录生成相应的动态库libdemo.so。 3 以动态库方式编译main.go $ go...
go语言 - Scheduler原理以及查看Goroutine执行 前端框架

go语言 - Scheduler原理以及查看Goroutine执行

最近看了看go scheduler的基本原理,本文介绍go语言scheduler的基本原理以及如何查看go代码中的go routine的执行情况。 0)Scheduler(调度器) 熟悉go语言的小伙伴应该都使用过goroutine。goroutine就是Go语言提供的一种用户态线程。Scheduler是调度goroutine的调度器。 Go的调度器内部有三个重要概念:M,P,G。 M (machine): 代表真正的内核操作系统里面的线程,和POSIX里的thread差不多,也是真正执行goroutine逻辑的部分。 G (Goroutine): 代表一个goroutine。 P (Processor): 代表调度的上下文,可以理解成一个局部调度器。 Go语言实现了多个Goroutine到多个Processor的映射(调度)。注意的是,针对X个Processor,Scheduler可能创建多于X个M(有些M可能会暂时被block)。还需要理解额外两个概念:GRQ(Global Running Queue)以及 LRQ(Local Running Queue)。未指定Processor的Goroutine会存放在GRQ上,在调度到合适的Processor后,会将一个Goroutine从GRQ移动到LRQ。 Go程序中发生了四类事件,允许调程序做出调度决策。 a. 使用关键字go b. 垃圾收集 c. 系统调用 d. 同步 1)Processor的个数 Processor的个数可以通过GOMAXPROCS环境变量设置。GOMAXPROCS默认值是CPU的核数。Processor的个数可以通过如下的go代码进行查询: package main import ( "fmt" "runtime" ) func main() { // NumCPU returns the number of logical // CPUs usable by the current process. fmt.Println(runtime.NumCPU()) } 也就是通过runtime.NumCPU函数可以获得Processor的个数。查看go语言的源代码(runtime/os_linux.c),NumCPU函数的实现函数如下:  func getproccount() int32 { const maxCPUs = 64 * 1024 var buf byte r := sched_getaffinity(0, unsafe.Sizeof(buf), &buf) if r < 0 { return 1 } n := int32(0) for _, v := range buf { for v != 0 { n += int32(v...