Go语言系列(七)- 读写操作
终端读写
1. 终端读写
操作终端相关文件句柄常量
- os.Stdin:标准输入
- os.Stdout:标准输出
- os.Stderr:标准错误输出
2. 终端读写示例
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.Scanf("%s %s", &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)
}
package main import "fmt" type student struct {
Name string
Age int
Score float32
} func main() {
var str = "stu01 18 89.92"
var stu student
fmt.Sscanf(str, "%s %d %f", &stu.Name, &stu.Age, &stu.Score)
fmt.Println(stu)
}
终端读写示例
3. 带缓冲区的读写
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)
}
}
package main import (
"bufio"
"fmt"
"os"
) func main() {
reader := bufio.NewReader(os.Stdin)
str, err := reader.ReadString('\n')
if err != nil {
fmt.Println("read string failed, err:", err)
return
} fmt.Printf("read str success, ret: %s\n", str)
} // go run go_dev/day7/example/example3/main
带缓冲区的读写
文件读写
1. os.File封装所有文件相关操作,之前讲的 os.Stdin,os.Stdout, os.Stderr都是*os.File
- 打开一个文件进行读操作: os.Open(name string) (*File, error)
- 关闭一个文件:File.Close()
2. 文件操作示例
package main import (
"bufio"
"fmt"
"os"
) func file_write() {
// 文件读写
file, err := os.OpenFile("test.log", os.O_CREATE|os.O_WRONLY, 0664)
if err != nil {
fmt.Println("open file err,:", err)
return
}
fmt.Fprintf(file, "do balance error\n")
file.Close()
} func main() {
// file_write()
file, err := os.Open("test.log")
if err != nil {
fmt.Println("read file failed, 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 success, ret: %s\n", str)
}
3. 读取整个文件示例
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())
}
}
4. 读取压缩文件示例
package main import (
"bufio"
"compress/gzip"
"fmt"
"os"
)
func main() {
fName := "MyFile.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)
}
}
5. 文件写入
os.OpenFile(“output.dat”, os.O_WRONLY|os.O_CREATE, 0666)
第二个参数:文件打开模式
- 1. os.O_WRONLY:只写
- 2. os.O_CREATE:创建文件
- 3. os.O_RDONLY:只读
- 4. os.O_RDWR:读写
- 5. os.O_TRUNC :清空
第三个参数:权限控制:
- r --> 004w --> 002x --> 001
6.文件写入示例
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()
}
7. 拷贝文件
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 {
return
}
defer src.Close()
dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
return
}
defer dst.Close()
return io.Copy(dst, src)
}
8 读取文件,统计英文、数字、空格以及其他字符的数量。
package main import (
"bufio"
"fmt"
"io"
"os"
) type CharCount struct {
ChCount int
NumCount int
SpaceCount int
OtherCount int
} func main() {
file, err := os.Open("test.log")
if err != nil {
fmt.Println("read file failed, 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%s", err)
break
}
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)
}
9. 带缓冲区的文件读写
package main import (
"bufio"
"flag"
"fmt"
"io"
"os"
) func cat(r *bufio.Reader) {
for {
buf, err := r.ReadBytes('\n')
if err == io.EOF {
break
}
fmt.Fprintf(os.Stdout, "%s", buf) return
}
} func main() {
flag.Parse()
if flag.NArg() == 0 {
cat(bufio.NewReader(os.Stdin))
}
for i := 0; i < flag.NArg(); i++ {
f, err := os.Open(flag.Arg(i))
if err != nil {
fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n",
os.Args[0], flag.Arg(i), err.Error())
}
continue
}
cat(bufio.NewReader(f))
}
10. 带缓冲区的终端读写
package main import (
"bufio"
"fmt"
"os"
) func main() {
fmt.Fprintf(os.Stdout, "%s\n", "hello world! - unbuffered")
buf := bufio.NewWriter(os.Stdout)
fmt.Fprintf(buf, "%s\n", "hello world! - buffered")
buf.Flush()
}
命令行参数
os.Args是一个string的切片,用来存储所有的命令行参数
1. flag包的使用,用来解析命令行参数:
- flag.BoolVar(&test, "b", false, "print on newline")
- flag.StringVar(&str, "s", "", "print on newline")
- flag.IntVar(&count, "c", 1001, "print on newline")
2. 命令行参数解析
package main import (
"flag" // command line option parser
"fmt"
) func main() { var test bool
var str string
var count int
flag.BoolVar(&test, "b", false, "print on newline")
flag.StringVar(&str, "s", "", "print on newline")
flag.IntVar(&count, "c", 1001, "print on newline")
flag.Parse() fmt.Println(test)
fmt.Println(str)
fmt.Println(count)
}
3. 示例
package main import (
"fmt"
"os"
) func main() {
fmt.Printf("len of args:%d\n", len(os.Args))
for i, v := range os.Args {
fmt.Printf("args[%d]: %s\n", i, v)
}
}
示例一
package main import (
"flag"
"fmt"
) func main() {
var confPath string
var logLevel int
flag.StringVar(&confPath, "c", "", "please input conf Path")
flag.IntVar(&logLevel, "d", 10, "please input log level") flag.Parse() fmt.Println("path:", confPath)
fmt.Println("log level:", logLevel)
} // go run go_dev/day7/example/example7/main -c d:/python -d 1
示例二
Json数据协议
- 1. 导入包:Import “encoding/json”
- 2. 序列化: json.Marshal(data interface{})
- 3. 反序列化: json.UnMarshal(data []byte, v interface{})
json序列化结构体,map,slice和int
package main import (
"encoding/json"
"fmt"
) type User struct {
UserName string `json:"username"`
Nickname string `json:"nickname"`
Age int
Birthday string
Sex string
Email string
Phone string
} func testStruct() {
user1 := &User{
UserName: "user1",
Nickname: "超级英雄",
Age: 18,
Birthday: "2008/8/8",
Sex: "男",
Email: "mayun@qq.com",
Phone: "110",
}
data, err := json.Marshal(user1)
if err != nil {
fmt.Println("json.marsha1 failed, err:", err)
return
}
fmt.Printf("%s\n", string(data))
} func testInt() {
var age = 100
data, err := json.Marshal(age)
if err != nil {
fmt.Println("json.marsha1 failed, err:", err)
return
}
fmt.Printf("%s\n", string(data))
} func testMap() {
var m map[string]interface{}
m = make(map[string]interface{})
m["username"] = "user1"
m["age"] = 18
m["sex"] = "女"
data, err := json.Marshal(m)
if err != nil {
fmt.Println("json.marsha1 failed, err:", err)
return
}
fmt.Printf("%s\n", string(data))
}
func testSlice() {
var m map[string]interface{}
var s []map[string]interface{}
m = make(map[string]interface{})
m["username"] = "user1"
m["age"] = 18
m["sex"] = "女" s = append(s, m) data, err := json.Marshal(s)
if err != nil {
fmt.Println("json.marsha1 failed, err:", err)
return
}
fmt.Printf("%s\n", string(data))
}
func main() {
testStruct()
testInt()
testMap()
testSlice()
}
json序列化示例
package main import (
"encoding/json"
"fmt"
) type User struct {
UserName string `json:"username"`
Nickname string `json:"nickname"`
Age int
Birthday string
Sex string
Email string
Phone string
} func testStruct() (ret string, err error) {
user1 := &User{
UserName: "user1",
Nickname: "超级英雄",
Age: 18,
Birthday: "2008/8/8",
Sex: "男",
Email: "mayun@qq.com",
Phone: "",
}
data, err := json.Marshal(user1)
if err != nil {
fmt.Println("json.marsha1 failed, err:", err)
return
}
ret = string(data)
return
}
func testMap() (ret string, err error) {
var m map[string]interface{}
m = make(map[string]interface{})
m["username"] = "user1"
m["age"] = 18
m["sex"] = "女"
data, err := json.Marshal(m)
if err != nil {
fmt.Println("json.marsha1 failed, err:", err)
return
}
ret = string(data)
return
}
func test() {
data, err := testStruct()
if err != nil {
fmt.Println("test struct failed, err:", err)
return
}
var user1 User
err = json.Unmarshal([]byte(data), &user1)
if err != nil {
fmt.Println("unmarshal failed", err)
return
}
fmt.Println(user1)
} func test2() {
data, err := testMap()
if err != nil {
fmt.Println("test map failed, err:", err)
return
}
var m map[string]interface{}
err = json.Unmarshal([]byte(data), &m)
if err != nil {
fmt.Println("unmarshal failed", err)
return
}
fmt.Println(m)
}
func main() {
test()
test2()
}
json序列化示例
定义错误
package main import (
"errors"
"fmt"
) var errNotFound error = errors.New("Not found error") func main() {
fmt.Printf("error: %v", errNotFound)
}
自定义错误
type error interface {
Error() string
}
package main
import (
// "fmt"
)
type PathError struct {
Op string
Path string
err string
}
func (e *PathError) Error() string {
return e.Op + " " + e.Path + ": " + e.Err.Error()
}
func test() error {
return &PathError{
Op: "op",
Path: "path",
}
}
func main() {
test()
}
判断自定义错误
switch err := err.(type) {
case ParseError:
PrintParseError(err)
case PathError:
PrintPathError(err)
... default:
}
示例
package main import (
"fmt"
"os"
"time"
) type PathError struct {
path string
op string
createTime string
message string
} func (p *PathError) Error() string {
return fmt.Sprintf("path=%s op=%s createTime=%s message=%s", p.path, p.op, p.createTime, p.message)
} func Open(filename string) error {
file, err := os.Open(filename)
if err != nil {
return &PathError{
path: filename,
op: "read",
message: err.Error(),
createTime: fmt.Sprintf("%v", time.Now()),
}
}
defer file.Close()
return nil
} func main() {
err := Open("c:/sasassas.txt")
switch v := err.(type) {
case *PathError:
fmt.Println("get path error,", v)
default: }
}
自定义错误
Panic&Recove
panic的作用就是抛出一条错误信息,从它的参数类型可以看到它可以抛出任意类型的错误信息。在函数执行过程中的某处调用了panic,则立即抛出一个错误信息,同时函数的正常执行流程终止,但是该函数中panic之前定义的defer语句将被依次执行。之后该goroutine立即停止执行。
recover()用于将panic的信息捕捉。recover必须定义在panic之前的defer语句中。在这种情况下,当panic被触发时,该goroutine不会简单的终止,而是会执行在它之前定义的defer语句。
package main import (
"fmt"
) func badCall() {
panic("bad end")
} func test() {
defer func() {
if e := recover(); e != nil {
fmt.Printf("Panicking %s\r\n", e)
}
}()
badCall()
fmt.Printf("After bad call\r\n")
} func main() {
fmt.Printf("Calling test\r\n")
test()
fmt.Printf("Test completed\r\n")
}
Go语言系列(七)- 读写操作的更多相关文章
- C语言基础文件读写操作
整理了一份C语言的文件读写件操作代码,测试时打开相应的注释即可. #include <stdio.h> #include <stdlib.h> #include <uni ...
- Java基础复习笔记系列 七 IO操作
Java基础复习笔记系列之 IO操作 我们说的出入,都是站在程序的角度来说的.FileInputStream是读入数据.?????? 1.流是什么东西? 这章的理解的关键是:形象思维.一个管道插入了一 ...
- C语言的文件读写操作函数小结
一.文件打开 使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件,这个调用会初始化类型 FILE 的一个对象,类型 FILE包含了所有用来控制流的必要的信息.函数原型为: FILE ...
- Python语言系列-03-文件操作和函数
## 深浅拷贝 #!/usr/bin/env python3 # author:Alnk(李成果) # 赋值运算 # 可变的数据类型:由于数据类型可变,修改数据会在原来的数据的基础上进行修改, # 可 ...
- C语言 文件的读写操作
//凯鲁嘎吉 - 博客园 http://www.cnblogs.com/kailugaji/ #include<stdio.h> #include<stdlib.h> void ...
- Linux学习系列八:操作网口
一些相对高性能的单片机会带以太网接口,网口在MCU里算是比较复杂的外设了,因为它涉及到网络协议栈,通常情况下网络协议栈会运行在一个RTOS中,所以对普通单片机开发者来说网口使用起来相对难度较大一些.在 ...
- c语言文件读写操作总结
C语言文件读写操作总结 C语言文件操作 一.标准文件的读写 1.文件的打开 fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程 ...
- C语言高速入口系列(七)
C语言高速入口系列(七) C语言指针进阶 本章引言: 在前面第5节中我们对C语言的指针进行了初步的学习理解;作为C语言的灵魂, C指针肯定没那么简单,在这一节中,我们将会对指针进行进一步的学习,比方二 ...
- C语言文件读写操作
C语言实现文件读写,注意区分几个方法: 写入: fwrite() //个人认为这个最好,可是实现写入任何数据类型,任何长度 fputs() //写入一个字符串,字符串长度不能太长,具体的长度未知,但估 ...
随机推荐
- Apollo的Oracle适配改动
这几天工作需要使用Apollo配置中心.Apollo唯一的依赖是MySQL数据库,然而公司只有Oracle数据库资源.这里有一个Oracle适配改动的分支,但是它是基于0.8.0版本的Apollo.看 ...
- 转:sql server锁知识及锁应用
sql server锁(lock)知识及锁应用 提示:这里所摘抄的关于锁的知识有的是不同sql server版本的,对应于特定版本时会有问题. 一 关于锁的基础知识 (一). 为什么要引入锁 当多个用 ...
- python正则表达式模块re
正则表达式的特殊元素 匹配符号 描述 '.'(点dot) 在默认模式下,它匹配除换行符之外的任何字符.如果指定了DOTALL标志,则匹配包括换行符在内的任何字符 '^'(Caret) 匹配以字符串开头 ...
- Think_in_java_4th(并发学习二)
使用Executor java.util.concurrent CachedThreadPool package concurrency.ExecutorService; //: concurrenc ...
- 【PAT】A1002 A+B for Polynomials
仅有两个要注意的点: 如果系数为0,则不输出,所以输入结束以后要先遍历确定系数不为零的项的个数 题目最后一句,精确到小数点后一位,如果这里忽略了,会导致样例1,3,4,5都不能通过
- elasticsearch系列一:elasticsearch(ES简介、安装&配置、集成Ikanalyzer)
一.ES简介 1. ES是什么? Elasticsearch 是一个开源的搜索引擎,建立在全文搜索引擎库 Apache Lucene 基础之上 用 Java 编写的,它的内部使用 Lucene 做索引 ...
- Python基础之协程
阅读目录 一 引子 二 协程介绍 三 Greenlet模块 四 Gevent模块 引子 之前我们学习了线程.进程的概念,了解了在操作系统中 进程是资源分配的最小单位,线程是CPU调度的最小单位. 按道 ...
- org.apache.ibatis.builder.IncompleteElementException: Could not find result map com.hp.entity.Emp
错误提示代码: org.apache.ibatis.builder.IncompleteElementException: Could not find result map com.hp.entit ...
- offsetLeft、offsetX等
https://blog.csdn.net/w390058785/article/details/80461845
- Django学习笔记之表单验证
表单概述 HTML中的表单 单纯从前端的html来说,表单是用来提交数据给服务器的,不管后台的服务器用的是Django还是PHP语言还是其他语言.只要把input标签放在form标签中,然后再添加一个 ...