发布于 2016-01-26 22:07:08 | 188 次阅读 | 评论: 0 | 来源: 网友投递
Go语言
Go是一种新的语言，一种并发的、带垃圾回收的、快速编译的语言。Go是谷歌2009年发布的第二款编程语言。2009年7月份，谷歌曾发布了Simple语言，它是用来开发Android应用的一种BASIC语言。
type PipeWriter
type PipeWriter struct {
// contains filtered or unexported fields
}
import (
"fmt"
"io"
)func main() {
r, w := io.Pipe()
go w.Write([]byte("hello word"))
data := make([]byte, 10)
n, err := r.Read(data)
w.Close()
if err == io.EOF {
fmt.Println("executing read return EOF")
fmt.Println("executing read reads number", n)
}
n, _ = r.Read(data)
fmt.Println(string(data)) //hello word
fmt.Println("next read number", n) //next read number 0
}
import (
"errors"
"fmt"
"io"
)
func main() {
r, w := io.Pipe()
go w.Write([]byte("hello widuu"))
newerr := errors.New("your daye 突然关闭了")
w.CloseWithError(newerr)
data := make([]byte, 10)
_, err := r.Read(data)
if err != nil {
fmt.Println(err) //your daye 突然关闭了
}
}
import (
"fmt"
"io"
)
func main() {
r, w := io.Pipe()
go w.Write([]byte("hello widuu")) //写入的是[]byte,注意官方文档写的是，写入管道阻塞，一直到所有数据的读取结束
data := make([]byte, 11)
n, _ := r.Read(data)
fmt.Println(string(data)) //hello widuu
fmt.Println("read number", n) //read number 10
}
type Reader
type Reader interface {
Read(p []byte) (n int, err error)
}
import (
"fmt"
"io"
"os"
"reflect"
)func main() {
f, _ := os.Open("test.txt")
defer f.Close()
reader := io.LimitReader(f, 5)
p := make([]byte, 5)
fmt.Println(reflect.TypeOf(reader)) //*io.LimitedReader
var total int
for {
n, err := reader.Read(p)
if err == io.EOF {
fmt.Println("read value", string(p[:total])) //read value hello
fmt.Println(total) //5
break
}
total = total + n
}
}
import (
"fmt"
"io"
"os"
"reflect"
)
func main() {
f1, _ := os.Open("test1.txt")
f2, _ := os.Open("test.txt")
defer f1.Close()
defer f2.Close()
reader := io.MultiReader(f1, f2) //*io.multiReader
fmt.Println(reflect.TypeOf(reader))
p := make([]byte, 10)
var total int
var data string
for {
n, err := reader.Read(p)
if err == io.EOF {
fmt.Println("read end", total) //read end 17
break
}
total = total + n
data = data + string(p[:n])
}
fmt.Println("read value", data) //read value widuu2hello widuu
fmt.Println("read count", total) // read count 17
}
import (
"fmt"
"io"
"io/ioutil"
"os"
)
func main() {
f1, _ := os.Create("1.txt")
f2, _ := os.Create("2.txt")
writer := io.MultiWriter(f1, f2)
writer.Write([]byte("widuu"))
//千万别这么逻辑来 ，我这是测试用的哈
r1, _ := ioutil.ReadFile("1.txt")
r2, _ := ioutil.ReadFile("2.txt")
fmt.Println(string(r1)) //widuu
fmt.Println(string(r2)) //widuu
}
import (
"fmt"
"io"
"os"
"reflect"
)
func main() {
r, _ := os.Open("test.txt")
w, _ := os.Create("test2.txt")
reader := io.TeeReader(r, w)
fmt.Println(reflect.TypeOf(reader)) //*io.teeReader
p := make([]byte, 10)
n, _ := reader.Read(p)
fmt.Println(string(p[:n])) //hello widu
}
type SectionReader{}
type SectionReader struct {
// contains filtered or unexported fields
}
(1)func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader，你一看就知道了，其实就是通过这个方法获取到io.SectionReader,第一个参数读取器，第二个参数偏移量，第三个参数是读取多少
import (
"fmt"
"io"
"os"
"reflect"
)func main() {
f, _ := os.Open("test.txt")
sr := io.NewSectionReader(f, 2, 5)
fmt.Println(reflect.TypeOf(sr)) //*io.SectionReader
}
import (
"fmt"
"io"
"os"
)
func main() {
f, _ := os.Open("test.txt")
defer f.Close()
sr := io.NewSectionReader(f, 2, 5)
p := make([]byte, 10)
n, err := sr.Read(p)
if err != nil {
fmt.Println(err)
}
fmt.Println(string(p[:n])) //llo w
}
import (
"fmt"
"io"
"os"
)
func main() {
f, _ := os.Open("test.txt")
defer f.Close()
sr := io.NewSectionReader(f, 2, 5)
p := make([]byte, 10)
n, err := sr.ReadAt(p, 1)
if err == io.EOF {
fmt.Println(string(p[:n])) // lo w
}
}
import (
"fmt"
"io"
"os"
)
func main() {
f, _ := os.Open("test.txt")
defer f.Close()
sr := io.NewSectionReader(f, 2, 5)
p := make([]byte, 10)
sr.Seek(1, 0) //相当于起始的地址偏移1
n, err := sr.Read(p)
if err != nil {
fmt.Println(err)
}
fmt.Println(string(p[:n])) //lo w 是不是达到了前边的ReadAt()
}
import (
"fmt"
"io"
"os"
)
func main() {
f, _ := os.Open("test.txt")
defer f.Close()
sr := io.NewSectionReader(f, 2, 5)
fmt.Println(sr.Size()) //5
p := make([]byte, 10)
sr.Seek(1, 0) //相当于起始的地址偏移1
n, err := sr.Read(p)
if err != nil {
fmt.Println(err)
}
fmt.Println(string(p[:n])) //lo w
fmt.Println(sr.Size()) //5
}