golang 读写操作

package main

import (
   "bufio"
   "fmt"
   "io"
   "os"
   "strconv"
   "unsafe"
)

func echo() {
   reader := bufio.NewReader(os.Stdin)
   writer := bufio.NewWriter(os.Stdout)
   for {
      fmt.Println("请输入你的消息")
      line, prefix, err := reader.ReadLine()
      if err != nil {
         fmt.Println("读写异常", err, prefix)
      }
      fmt.Print("你输入的消息为:")
      writer.WriteString(string(line) + "\r\n")
      writer.Flush() //不加上不会有输出
      //fmt.Println(string(line), prefix)
      if string(line) == "bye" {
         break
      }
   }
}
func WriteFile() {
   var fn string = "./1.txt"
   /**
   第二个参数
   // 只读模式
       O_RDONLY int = syscall.O_RDONLY // open the file read-only.
       // 只写模式
       O_WRONLY int = syscall.O_WRONLY // open the file write-only.
       // 可读可写
       O_RDWR   int = syscall.O_RDWR   // open the file read-write.
       // The remaining values may be or'ed in to control behavior.
       // 追加内容
       O_APPEND int = syscall.O_APPEND // append data to the file when writing.
       // 创建文件，如果文件不存在
       O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
       // 与创建文件一同使用，文件必须存在
       O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
       // 打开一个同步的文件流
       O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
       // 如果可能，打开时缩短文件
       O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
   */
   /**
   第三个参数
    // 文件夹模式
       ModeDir        FileMode = 1 << (32 - 1 - iota) // d: is a directory
       // 追加模式
       ModeAppend                                     // a: append-only
       // 单独使用
       ModeExclusive                                  // l: exclusive use
       // 临时文件
       ModeTemporary                                  // T: temporary file; Plan 9 only
       // 象征性的关联
       ModeSymlink                                    // L: symbolic link
       // 设备文件
       ModeDevice                                     // D: device file
       // 命名管道
       ModeNamedPipe                                  // p: named pipe (FIFO)
       // Unix 主机 socket
       ModeSocket                                     // S: Unix domain socket
       // 设置uid
       ModeSetuid                                     // u: setuid
       // 设置gid
       ModeSetgid                                     // g: setgid
       // UNIX 字符串设备，当设备模式是设置unix
       ModeCharDevice                                 // c: Unix character device, when ModeDevice is set
       // 粘性的
       ModeSticky                                     // t: sticky
       // 非常规文件；对该文件一无所知
       ModeIrregular                                  // ?: non-regular file; nothing else is known about this file

       // bit位遮盖，不变的文件设置为none
       // Mask for the type bits. For regular files, none will be set.
       ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice | ModeCharDevice | ModeIrregular
       // 权限位
       ModePerm FileMode = 0777 // Unix permission bits
   */

/**
golang os.OpenFile几种常用模式

os.O_WRONLY | os.O_CREATE | O_EXCL 如果已经存在，则失败
os.O_WRONLY | os.O_CREATE 如果已经存在，会覆盖写，不会清空原来的文件，而是从头直接覆盖写
os.O_WRONLY | os.O_CREATE | os.O_APPEND 如果已经存在，则在尾部添加写
*/

   f, err := os.OpenFile(fn, os.O_WRONLY|os.O_CREATE|os.O_APPEND, os.ModeAppend|os.ModePerm)
   if err != nil {
      fmt.Println("打开文件异常", err)
   }
   defer f.Close()

   writer := bufio.NewWriter(f)

   for i := 0; i < 10; i++ {
      writer.WriteString("item" + strconv.Itoa(i) + "\r\n")
   }
   writer.Flush()

}
func ReadFile() {
   var fn string = "./1.txt"
   f, err := os.OpenFile(fn, os.O_RDONLY, os.ModeAppend)
   if err != nil {
      fmt.Println("打开文件失败", err)
   }
   defer f.Close()
   reader := bufio.NewReader(f)

   for {
      line, _, err := reader.ReadLine()
      if err != nil {
         break
      }
      if line == nil {
         break
      }
      fmt.Println(string(line))
   }
}

func copyFile() {
   var src string = "./1.txt"
   var dst string = "./2.txt"
   r, err := os.OpenFile(src, os.O_RDONLY, os.ModeAppend)
   if err != nil {
      fmt.Println("打开读文件异常", err)
   }
   defer r.Close()
   w, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_APPEND, os.ModeAppend|os.ModePerm)
   if err != nil {
      fmt.Println("打开写文件异常", err)
   }
   defer w.Close()
   //var bufs [1024]byte
   reader := bufio.NewReader(r)
   writer := bufio.NewWriter(w)

   io.Copy(writer, reader)
   //writer.Flush()

}
func echo2() {
   var b []byte = []byte("hello")
   fmt.Println(string(b))
}

type bytes []byte

// 非线程安全地
func ToString(b []byte) string {
   return *(*string)(unsafe.Pointer(&b))
}

// func (b []byte) ToString() string {
//    return *(*string)(unsafe.Pointer(&b))
// }
func ToBytes(s string) []byte {

   b := *(*[]byte)(unsafe.Pointer(&s))
   fmt.Println(b)
   return b
}
func transfer() {
   b := ToBytes("hello")
   fmt.Println(b)
   s := ToString(b)
   fmt.Println(s)
}
func main() {
   //WriteFile()
   //ReadFile()
   copyFile()
}