~~~
package main
import (
"os"
"fmt"
"io"
"bufio"
"io/ioutil"
"time"
)
func ReadFile1(filename string) {
// os.Create() 和 os.Open() 也是調用了os.OpenFile()
/*
*第二個參數: 文件打開模式
syscall.O_RDONLY // 只讀模式打開文件
syscall.O_WRONLY // 只寫模式打開文件
syscall.O_RDWR // 讀寫模式打開文件
syscall.O_APPEND // 寫操作時將數據附加到文件尾部
syscall.O_CREAT // 如果不存在將創建一個新文件
syscall.O_EXCL // 和O_CREATE配合使用，文件必須不存在
syscall.O_SYNC // 打開文件用于同步I/O
syscall.O_TRUNC // 如果可能，打開時清空文件
*/
/*第三個參數: 權限控制
-rw-r--r--
- | rw- | r-- | r--
1 | 2 | 3 | 4
1 文件類型
2 擁有者權限
3 群組用戶權限
4 其它用戶權限
r 可讀 4
w 可寫 2
x 可執行 1
- 無權限 0
*/
//os.O_WRONLY 只寫 O_RDWR 讀寫 (認錯單詞, 被坑了)
file, err := os.OpenFile(filename, os.O_RDONLY, 0777)
if err != nil {
fmt.Println(err)
}
defer file.Close()
//var b[]byte 長度為0
var b [64]byte
var content []byte
/*
fmt.Println(reflect.TypeOf(b))
fmt.Println(reflect.TypeOf(b[:]))
*/
for {
n, err := file.Read(b[:])
//讀到沒有內容時,報錯
if err == io.EOF {
break
}
if err != nil {
fmt.Println(err)
}
//content = append(content, b[:]...) //最后可能讀不夠64字節
content = append(content, b[:n]...)
}
fmt.Println(string(content))
}
func ReadFile2(filename string) {
//帶緩沖讀取文件
file, err := os.OpenFile(filename, os.O_RDONLY, 0777)
if err != nil {
fmt.Println(err)
}
//*file 實現了 Reader接口
reader := bufio.NewReader(file)
var b [64]byte
var content []byte
for {
//Read有很多讀取數據的方法
//reader.ReadString('\n') 讀取一行數據
n, err := reader.Read(b[:])
if err == io.EOF {
break
}
if err != nil {
fmt.Println(err)
}
content = append(content, b[:n]...)
}
fmt.Println(string(content))
}
func ReadFile3(filename string) {
//一次性讀取整個文件
content, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Println(err)
}
fmt.Println(string(content))
}
func WriteFile1(filename string) {
file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0777)
if err != nil {
fmt.Println(err)
}
var b []byte
b = []byte("\nHello World\nHello World2")
_, err = file.Write(b)
if err != nil {
fmt.Println(err)
}
}
func WriteFile2(filename string) {
file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0777)
if err != nil {
fmt.Println(err)
}
var b []byte
b = []byte("\nHello World\nHello World23")
write := bufio.NewWriter(file)
n, err := write.Write(b)
//Flush方法將緩沖中的數據寫入下層的io.Writer接口
write.Flush()
fmt.Println(n)
if err != nil {
fmt.Println(err)
}
}
func WriteFile3(filename string) {
var b []byte
b = []byte("Hello World\nHello World2")
//寫一個全新的文件
//os.O_WRONLY|os.O_CREATE|os.O_TRUNC
err := ioutil.WriteFile(filename, b, 0777)
if err != nil {
fmt.Println(err)
}
}
/*
類型*File
標準輸入 Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
標準輸出 Stdout = NemwFile(uintptr(syscall.Stdout), "/dev/stdout")
標準錯誤 Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
*/
func ReadAndWrite(filename string) {
//_, err := io.WriteString(os.Stdout, "Hello World")
//if err != nil {
// fmt.Println(err)
//}
/*
Pipe創建一個同步的內存中的管道。它可以用于連接期望io.Reader的代碼和期望io.Writer的代碼。一端的讀取對應另一端的寫入，直接在兩端拷貝數據，沒有內部緩沖。可以安全的并行調用Read和Write或者Read/Write與Close方法。Close方法會在最后一次阻塞中的I/O操作結束后完成。并行調用Read或并行調用Write也是安全的：每一個獨立的調用會依次進行。
*/
r, w := io.Pipe()
go func() {
i := 0
for {
w.Write([]byte(fmt.Sprint("Number", i)))
i++
}
}()
go func() {
var d [8]byte
for {
n, err := r.Read(d[:])
if err != nil {
fmt.Println(err)
}
fmt.Println(string(d[:n]))
}
}()
time.Sleep(time.Second * 10)
}
func main() {
var filename = "D:/uploads/file.txt"
ReadAndWrite(filename)
//TODO : ReadFile
//ReadFile1(filename)
//ReadFile2(filename) //帶緩沖讀取文件
//ReadFile3(filename) //一次性讀取整個文件
//TODO : WriteFile
//WriteFile1(filename)
//WriteFile2(filename)
//WriteFile3(filename)
}
~~~
> ### 例子2
~~~
package demo13
import (
"flag"
"fmt"
)
var name string
var age int
func init() {
//flag包獲取命令行參數
flag.StringVar(&name, "n", "Go", "A Name")
flag.IntVar(&age, "a", 18, "Age Number")
}
func Demo13() {
/*
類型*File
標準輸入 Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
標準輸出 Stdout = NemwFile(uintptr(syscall.Stdout), "/dev/stdout")
標準錯誤 Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
*/
/* -----
number := 1
fmt.Printf("1--fmt.Printf:%d\n\r", number)
data1 := fmt.Sprintf("2--fmt.Sprintf:%d", number)
fmt.Println(data1)
//var data2 interface{} interface類型在初始化，是沒有分配內存空間給data2變量，相當于nil也就是指一個空指針
var data2 string
fmt.Scan(&data2)
fmt.Println("3--Scan:", data2)
fmt.Scanf("%s", &data2)
fmt.Println("4--Scanf:", data2)
*/
//終端其實是一個文件
//以文件方式操作終端
//不同的運行環境中 console 的 stdin 實現特性不同導致的
/*
var b [16]byte
os.Stdin.Read(b[:])
fmt.Println(string(b[:]))
*/
//從字符串里獲取數據 fmt.scanf
//從文件里獲取數據 fmt.Fscanf
/*
var a int
var b string
fmt.Fscanf(os.Stdin, "%d%s", &a, &b)
fmt.Println(a, b)
*/
//文件本身讀寫差
//bufio 帶緩沖區文件讀寫 (大文件)
/*
inputReader := bufio.NewReader(os.Stdin)
input, err := inputReader.ReadString('\n')
if err == nil{
fmt.Println(input)
}
*/
//獲取命令行參數
//GoStudy.exe a b c d
/*
for _, v := range os.Args {
fmt.Println(v)
}
*/
//flag包獲取命令行參數
fmt.Println(name)
fmt.Println(age)
//github.com/urfave/cli
}
~~~
> ### 1
~~~
package demo14
import (
"os"
"fmt"
"gitee.com/winnie_gss/GoStudy/demo1"
"io"
"bufio"
"io/ioutil"
"compress/gzip"
)
func Exam1() {
file, err := os.Open("D:/demo13.go")
defer file.Close()
demo1.SimplePanic(err)
var b [32]byte
var content []byte
for {
n, err := file.Read(b[:])
//讀到沒有內容時,報錯
if err == io.EOF {
break
}
demo1.SimplePanic(err)
//content = append(content, b[:]...) //最后可能出現沒讀夠
content = append(content, b[:n]...)
}
fmt.Println(string(content))
}
func Exam2() {
file, err := os.Open("D:/demo13.go")
demo1.SimplePanic(err)
reader := bufio.NewReader(file)
for {
line, err := reader.ReadString('\n')
if err == io.EOF {
break
}
demo1.SimplePanic(err)
fmt.Println(line)
}
}
func Exam3() {
content, err := ioutil.ReadFile("D:/demo13.go")
demo1.SimplePanic(err)
fmt.Println(string(content))
}
func Exam4() {
file, err := os.Open("D:/demo13.zip")
demo1.SimplePanic(err)
defer file.Close()
reader, err := gzip.NewReader(file)
demo1.SimplePanic(err)
fmt.Println(reader)
//var b [32]byte
//var content []byte
//
//for {
// n, err := reader.Read(b[:])
// if err == io.EOF {
// break
// }
// demo1.SimplePanic(err)
// content = append(content, b[:n]...)
//}
//fmt.Println(string(content))
}
func Exam5() {
//第二個參數: 文件打開模式
/*
syscall.O_RDONLY // 只讀模式打開文件
syscall.O_WRONLY // 只寫模式打開文件
syscall.O_RDWR // 讀寫模式打開文件
syscall.O_APPEND // 寫操作時將數據附加到文件尾部
syscall.O_CREAT // 如果不存在將創建一個新文件
syscall.O_EXCL // 和O_CREATE配合使用，文件必須不存在
syscall.O_SYNC // 打開文件用于同步I/O
syscall.O_TRUNC // 如果可能，打開時清空文件
*/
//第三個參數: 權限控制
/*
-rw-r--r--
- | rw- | r-- | r--
1 | 2 | 3 | 4
1 文件類型
2 擁有者權限
3 群組用戶權限
4 其它用戶權限
r 可讀 4
w 可寫 2
x 可執行 1
- 無權限 0
*/
file, err := os.OpenFile("D:/demo14.go", os.O_TRUNC|os.O_WRONLY, 0666)
demo1.SimplePanic(err)
str := "Hello World"
file.Write([]byte(str))
}
/*
return x -> 返回值=x , ret指令
*/
func Exam6() (y int) {
x := 5
return x
}
func Exam7() {
file1, err := os.Open("D:/123.txt")
demo1.SimplePanic(err)
file2, err := os.OpenFile("D:/321.txt", os.O_CREATE|os.O_WRONLY, 0666)
demo1.SimplePanic(err)
}
func Demo14() {
//文件讀寫
//Exam1()
//bufio讀取一行數據
//Exam2()
//ioutil讀取整個文件
//Exam3()
//讀取壓縮文件 ????
//Exam4()
//文件寫入
//Exam5()
//fmt.Println(Exam6())
//TODO : io.copy 文件拷貝
Exam7()
}
~~~
- 第一序 入門教程(一)
- 1.1環境配置
- 1.1 環境配置(補充:Linux下安裝)
- 1.1 環境配置(補充:線上部署)
- 1.2 開發工具GoLand
- 1.3 準備工作
- 1.4 第一個應用程序 Hello World
- 1.4 補充 go get github 超時
- 第二序 入門教程(二)
- 2.1 語法結構
- 2.2 常量, 變量
- 2.2.1 命名規則
- 2.2.2 變量
- 2.2.2 變量(補充:類型推斷的好處)
- 2.2.2 變量(補充:泛型)
- 2.2.3 常量
- 2.2.4 iota
- 2.2.5 Unicode字符編碼
- 2.2.6 GBK 轉 UTF8
- 2.3 條件語句
- 2.3.1 判斷語句 if
- 2.3.2 選擇語句 switch
- 2.3.3 循環語句 for
- 2.3.4 遍歷 range
- 2.3.5 跳轉語句 goto, break, continue
- 2.3.6 for 和 for range區別
- 2.4 數組, 切片, 集合, 通道
- 2.4.1 make, len, cap, new, nil
- 2.4.1 make, len, cap, new, nil (補充:nil)
- 2.4.2 數組 array
- 2.4.3.1 切片 slice - 1
- 2.4.3.2 切片 slice - 2
- 2.4.3.3 slice list ring
- 2.4.4 集合 map
- 2.4.5 goroutine
- 2.4.6 channel
- 2.5 函數, 結構, 方法, 接口
- 2.5.1 函數 function
- 2.5.2 結構 struct
- 2.5.3 方法 method
- 2.5.4 接口 interface
- 2.5.5 Go是面向對象的語言嗎？
- 2.5.6 json序列化和反序列化
- 2.5.7 T和指針T
- 2.6 defer, panic, recover
- 2.6.1 defer
- 2.6.2 painc, recover
- 2.7 指針
- 2.7 指針(補充: 可尋址和不可尋址)
- 2.8 反射
- 第三序 相關閱讀
- 3.1 相關閱讀1
- 3.2 相關閱讀2
- 3.3 相關閱讀3
- 第四序 性能分析和調試工具
- 4.1 pprof工具介紹
- 4.2 CPU信息采集
- 4.3 Heap信息采集
- 4.4 Http信息采集
- 4.5 單元測試(功能測試)
- 4.6 基準測試(壓力測試/性能測試)
- 4.7 示例測試(example)
- 4.8 gdb調試
- 第五序 網絡編程
- 5.1 http請求和響應
- 5.2 socket
- 5.2.1 概念
- 5.2.2 服務端
- 5.2.3 客戶端
- 5.3 WebSocket
- 5.3.1 第一版
- 5.3.1.1 服務端
- 5.3.1.2 客戶端
- 5.3.1.3 相關閱讀
- 5.3.2 服務端
- 5.3.3 客戶端
- 5.3.4 nginx配置
- 5.3.5 修改版
- 5.3.5.1 草稿 - 1
- 5.3.5.2 草稿 - 2
- 5.3.5.3 草稿 - 3
- 5.3.5.4 服務端
- 5.3.5.5 客戶端
- 5.4 打印客戶端頭部信息
- 第六序 算法
- 6.1 查找
- 6.1.1 二分查找
- 6.2 排序
- 6.2.1 交換排序 - 冒泡排序
- 6.2.2 插入排序 - 直接插入排序
- 6.2.3 插入排序 - 希爾排序
- 6.2.4 交換排序 - 快速排序
- 6.3 算法求解應用
- 第七序 微服務
- 7.1 相關閱讀
- 7.2 gRPC
- 7.2.1 準備工作
- 7.2.2 編譯.proto文件
- 7.2.3 gRPC服務端
- 7.2.4 gRPC客戶端
- 7.3 micro/micro
- 7.3.1 服務發現
- 7.3.2 安裝consul
- 7.3.3 準備工作
- 7.3.4 服務端
- 7.3.5 客戶端
- 7.3.6 默認的服務發現
- 7.3.7 文檔閱讀
- 7.4 protobuf序列化
- 第八序 Web
- 8.1 視圖模板
- 8.1.1 main.go
- 8.1.2 login.html
- 8.2 原生留言板
- 8.2.1 原生sql
- 8.2.1.1 main.go
- 8.2.1.2 view
- 8.2.1.2.1 index.html
- 8.2.1.2.2 create.html
- 8.2.2 sqlx
- 8.3 Gin框架
- 第九序 數據庫
- 9.0 資料收集
- 9.1 Redis數據庫 (gomodule/redigo)
- 9.1.1 介紹
- 9.1.2 消息隊列
- 9.2 Redis數據庫(go-redis/redis)
- 第十序 日記
- 10.1 SimplePanic
- 10.2 第一版日記庫
- 10.2.1 winnielog
- 10.2.2 使用
- 第十一序 中間鍵
- 11.0 資料收集
- 11.1 NSQ
- 11.2 zookeeper
- 11.3 kafka
- 第十二序 加密
- 12.1 Token
- 12.2 SHA1
- 2.3 RSA + AES
- 第十三序 分布式鎖
- 第十四序 標準庫練習
- container/list
- 鏈表
- container/ring
- 環形鏈表
- context
- flag (獲取命令行參數)
- io
- strconv
- sync
- 為什么需要鎖?
- 互斥鎖
- 讀寫鎖
- 條件變量
- 計數器
- 并發安全字典
- 自制并發安全字典
- 官方并發安全字典
- 連接池
- sync/atomic
- 原子操作
- 第十五序 其它內容
- 文件讀寫
- 工作池
- 第十六序 相關閱讀