Golang丰富的I/O----用N种Hello World展示

Golang丰富的I/O----用N种Hello World展示

Golang是我目前用过的最好的语言，一接触便深深地喜爱，不断实践，喜爱之情日久弥深。原因之一便是简单、强大、易用。编程操作涉及频率最高的莫过于I/O，标准io包提供的两个接口（io.Reader和io.Writer）对I/O进行了伟大的统一抽象，将简单、强大、易用的特点体现地淋漓尽致。两个接口的定义如下：

typeReaderinterface {

    Read(p []byte) (n int, err error)

}

typeWriterinterface {

    Write(p []byte) (n int, err error)

}

　　

标准库中的多个包实现了这两个接口，从而提供了丰富而强大的I/O功能。下面用N种输出“Hello，world!”来感受下。

package main

import (

    "bufio"

    "bytes"

    "fmt"

    "io"

    "log"

    "mime/quotedprintable"

    "os"

    "strings"

    "text/tabwriter"

)

func main() {

    //1

    fmt.Println("hello, world!")

    //2

    io.WriteString(os.Stdout, "Hello, World!\r\n")

    os.Stdout.WriteString("Hello, World!\r\n")

    //3

    w := bufio.NewWriter(os.Stdout)

    fmt.Fprint(w, "Hello, ")

    fmt.Fprint(w, "world!\r\n")

    w.Flush() // Don't forget to flush!

    fmt.Fprint(os.Stdout, "hello, world!\r\n")

    //4

    r := strings.NewReader("hello, world!\r\n")

    if _, err := io.Copy(os.Stdout, r); err != nil {

        log.Fatal(err)

    }

    r1 := strings.NewReader("hello, world!\r\n")

    buf := make([]byte, 8)

    // buf is used here...

    if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {

        log.Fatal(err)

    }

    r2 := strings.NewReader("hello, world!\r\n")

    //buf := make([]byte, 8)

    if _, err := io.CopyN(os.Stdout, r2, int64(r2.Len())); err != nil {

        log.Fatal(err)

    }

    //5

    var b bytes.Buffer // A Buffer needs no initialization.

    b.Write([]byte("Hello, "))

    fmt.Fprintf(&b, "world!\r\n")

    b.WriteTo(os.Stdout)

    // Output: Hello world!

    //6

    wTab := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', tabwriter.AlignRight)

    defer wTab.Flush()

    wTab.Write([]byte("Hello, world!\r\n"))

    //7

    wQuote := quotedprintable.NewWriter(os.Stdout)

    wQuote.Write([]byte("Hello, world!\r\n"))

    wQuote.Write([]byte("These symbols will be escaped: = \t"))

    wQuote.Close()

    wQuote.Write([]byte("\r\n"))

    //8

    log := log.New(os.Stdout, "", 0)

    log.Println("Hello, world!")

}

　　

以上代码均来自go源码，编译运行输出如下：

hello, world!

Hello, World!

Hello, World!

Hello, world!

hello, world!

hello, world!

hello, world!

hello, world!

Hello, world!

Hello, world!

Hello, world!

These symbols will be escaped: =3D =09

Hello, world!

　　

第一种很常见，

fmt.Println("hello, world!")

　　

各种go语言书籍中均展示了该种形式的Hello World。

第二种是io包和os包提供的WriteString函数或方法，对io.Writer进行了封装。

第三种是fmt包提供的Fprint函数，与第一种类似。从go源码可以看出Print和Println分别是对Fprint和Fprintln函数的封装。

func Print(a ...interface{}) (n int, err error) {

    return Fprint(os.Stdout, a...)

}

func Println(a ...interface{}) (n int, err error) {

    return Fprintln(os.Stdout, a...)

}

　　

第四种是io包提供的三个copy函数：io.Copy、io.CopyBuffer和io.CopyN。这三个函数是对copyBuffer函数的封装，

// copyBuffer is the actual implementation of Copy and CopyBuffer.

// if buf is nil, one is allocated.

func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)

　　

copyBuffer函数借助buf缓冲从Reader读取数据然后写入到Writer中。

第五种是bytes包提供的方法，对Writer方法进行了封装。

// WriteTo writes data to w until the buffer is drained or an error occurs.

// The return value n is the number of bytes written; it always fits into an

// int, but it is int64 to match the io.WriterTo interface. Any error

// encountered during the write is also returned.

func (b *Buffer) WriteTo(w io.Writer) (n int64, err error)

　　

第六种是text包实现的io.Writer接口，text/tabwriter包可以实现文本列对齐输出。

// Write writes buf to the writer b.

// The only errors returned are ones encountered

// while writing to the underlying output stream.

//

func (b *Writer) Write(buf []byte) (n int, err error) {

　　

第七种是"mime/quotedprintable"包实现的io.Writer接口。

// Write encodes p using quoted-printable encoding and writes it to the

// underlying io.Writer. It limits line length to 76 characters. The encoded

// bytes are not necessarily flushed until the Writer is closed.

func (w *Writer) Write(p []byte) (n int, err error) {

　　

第八种也是比较常用的，由log包提供的。

这么多种Hello
World的写法可能不是全面的，但这是我见过的写法最多的一种语言。