大佬教程收集整理的这篇文章主要介绍了golang基础-终端读(Scanln\bufio)、bufio文件读、、ioutil读读压缩、缓冲区读写、文件写入、文件拷贝，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。
package main
import (
"fmt"
)
var (
firstName,lastName,s String
i int
f float32
input = "56.12 / 5212 / Go"
format = "%f / %d / %s"
)
func main() {
fmt.Println("Please enter your full name: ")
fmt.Scanln(&firstName,&lastName)
fmt.Printf("Hi %s %s!\n",firstName,lastName) // Hi Chris Naegels
fmt.Sscanf(input,format,&f,&i,&s)
fmt.Println("From the String we read: ",f,i,s)
}
输出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
Please enter your full name:
Hello go lagn
Hi Hello go!
From the String we read: 56.12 5212 Go
PS E:\golang\go_pro\src\safly>
func Sscanf
func Sscanf(str String,format String,a …interface{}) (n int,err error)
Scanf 扫描实参 String，并将连续由空格分隔的值存储为连续的实参， 其格式由 format 决定。它返回成功解析的条目数。
func Scanln
func Scanln(a …interface{}) (n int,err error)
Scanln 类似于 Scan，但它在换行符处停止扫描，且最后的条目之后必须为换行符或 EOF。
ReadString读取换行
func (*Reader) ReadString
func (b *Reader) ReadString(delim bytE) (line String,err error)
ReadString读取输入到第一次终止符发生的时候，返回的String包含从当前到终止符的内容（包括终止符）。 如果ReadString在遇到终止符之前就捕获到一个错误，它就会返回遇到错误之前已经读取的数据，和这个捕获 到的错误（经常是 io.EOF）。当返回的数据没有以终止符结束的时候，ReadString返回err != nil。 对于简单的使用，或许 ScAnner 更方便。
package main
import (
"bufio"
"fmt"
"os"
)
var inputReader *bufio.Reader
var input String
var err error
func main() {
inputReader = bufio.NewReader(os.Stdin)
fmt.Println("Please enter some input: ")
input,err = inputReader.ReadString('\n')
if err == nil {
fmt.Printf("The input was: %s\n",input)
}
}
输出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
Please enter some input:
wyf
The input was: wyf
PS E:\golang\go_pro\src\safly>
1、os.Open
2、bufio.NewReader
3、reader.ReadString
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
file,err := os.Open("output.dat")
if err != nil {
fmt.Println("read file err:",err)
return
}
defer file.Close()
reader := bufio.NewReader(filE)
str,err := reader.ReadString('\n')
if err != nil {
fmt.Println("read String Failed,err:",err)
return
}
fmt.Printf("read str succ,ret:%s\n",str)
}
输出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
read file err: open test: The system cAnnot find the file specified.
PS E:\golang\go_pro\src\safly>
运行结果有问题，但是找不出问题所在
练习，从终端读取一行字符串，统计英文、数字、空格以及其他字符的数量。
package main
import (
"bufio"
"fmt"
"io"
"os"
)
type CharCount struct {
ChCount int
NumCount int
SpaceCount int
OtherCount int
}
func main() {
file,err := os.Open("output.dat")
if err != nil {
fmt.Println("read file err:",err)
return
}
defer file.Close()
var count CharCount
reader := bufio.NewReader(filE)
for {
str,err := reader.ReadString('\n')
//读取完毕
if err == io.EOF {
break
}
//读取失败
if err != nil {
fmt.Printf("read file Failed,err:%v",err)
break
}
/* 一个字符串可以可以用一个rune（又名int32）数组来表示， 每个rune都表示一个单一的字符。如： */
runeArr := []rune(str)
for _,v := range runeArr {
switch {
case v >= 'a' && v <= 'z':
fallthrough
case v >= 'A' && v <= 'Z':
count.ChCount++
case v == ' ' || v == '\t':
count.SpaceCount++
case v >= '0' && v <= '9':
count.NumCount++
default:
count.otherCount++
}
}
}
fmt.Printf("char count:%d\n",count.ChCount)
fmt.Printf("num count:%d\n",count.NumCount)
fmt.Printf("space count:%d\n",count.SpaceCount)
fmt.Printf("other count:%d\n",count.otherCount)
}
package main
import (
"fmt"
"io/IoUtil"
"os"
)
func main() {
inputFile := "products.txt"
outputFile := "products_copy.txt"
buf,err := IoUtil.ReadFile(inputFilE)
if err != nil {
fmt.Fprintf(os.Stderr,"File Error: %s\n",err)
return
}
fmt.Printf("%s\n",String(buf))
err = IoUtil.WriteFile(outputFile,buf,0x644)
if err != nil {
panic(err.Error())
}
}
在项目下创建2个文件
输出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
sfds
PS E:\golang\go_pro\src\safly>
1、os.Open压缩文件
2、gzip.NewReader(fi)
3、bufio.NewReader(fz)
4、bufio.ReadString
package main
import (
"bufio"
"compress/gzip"
"fmt"
"os"
)
func main() {
fName := "output.dat.gz"
var r *bufio.Reader
fi,err := os.open(fName)
if err != nil {
fmt.Fprintf(os.Stderr,"%v,can’t open %s: error: %s\n",os.Args[0],fName,err)
os.Exit(1)
}
fz,err := gzip.NewReader(fi)
if err != nil {
fmt.Fprintf(os.Stderr,"open gzip Failed,err: %v\n",err)
return
}
r = bufio.NewReader(fz)
for {
line,err := r.ReadString('\n')
if err != nil {
fmt.Println("Done reading file")
os.Exit(0)
}
fmt.Println(linE)
}
}
输出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Done reading file
PS E:\golang\go_pro\src\safly>
文件写入
1、OpenFile打开文件(没有文件就创建)
1、创建bufio.NewWriter对象
2、WriteString写入操作
3、刷新Flush
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
outputFile,outputError := os.openFile("output.dat",os.o_WRONLY|os.o_CREATE,0666)
if outputError != nil {
fmt.Printf("An error occurred with file creation\n")
return
}
defer outputFile.Close()
outputWriter := bufio.NewWriter(outputFilE)
outputString := "Hello World!\n"
for i := 0; i < 10; i++ {
outputWriter.WriteString(outputString)
}
outputWriter.Flush()
}
简单的三步骤
1、 os.Open(srcName)
2、os.OpenFile
3、io.Copy(dst,srC)
package main
import (
"fmt"
"io"
"os"
)
func main() {
CopyFile("target.txt","source.txt")
fmt.Println("Copy done!")
}
func CopyFile(dstName,srcName String) (written int64,err error) {
src,err := os.open(srcName)
if err != nil {
fmt.Println("src open err")
return
}
defer src.Close()
dst,err := os.openFile(dstName,0644)
if err != nil {
fmt.Println("dst open err")
return
}
defer dst.Close()
return io.Copy(dst,srC)
}以上是大佬教程为你收集整理的golang基础-终端读(Scanln\bufio)、bufio文件读、、ioutil读读压缩、缓冲区读写、文件写入、文件拷贝全部内容，希望文章能够帮你解决golang基础-终端读(Scanln\bufio)、bufio文件读、、ioutil读读压缩、缓冲区读写、文件写入、文件拷贝所遇到的程序开发问题。
如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。