Go 文件操作


package main

import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    // 打开文件 返回文件指针
    file, error := os.Open("/tmp/1.txt")
    if error != nil {
        fmt.Println(error)
    }
    fmt.Println(file)
    file.Close()

    // 以读写方式打开文件 返回文件指针 如果不存在则创建
    file2, error := os.OpenFile("/tmp/2.txt", os.O_RDWR|os.O_CREATE, 0644)
    if error != nil {
        fmt.Println(error)
    }
    fmt.Println(file2)
    file2.Close()

    // 创建文件 Create 函数也是调用的 OpenFile
    file3, error := os.Create("/tmp/3.txt")
    if error != nil {
        fmt.Println(error)
    }
    fmt.Println(file3)
    file3.Close()

    // 读取文件内容
    file4, error := os.Open("/tmp/1.txt")
    if error != nil {
        fmt.Println(error)
    }
    // 创建 byte 的 slice 用于接收文件读取数据
    buf := make([]byte, 1024)
    // 循环读取
    for {
        // Read 函数会改变文件当前偏移量
        len, _ := file4.Read(buf)
        // 读取字节数为 0 时跳出循环
        if len == 0 {
            break
        }
        fmt.Println(string(buf))
    }
    file4.Close()

    // 读取文件内容
    file5, error := os.Open("/tmp/1.txt")
    if error != nil {
        fmt.Println(error)
    }
    buf2 := make([]byte, 1024)
    ix := 0
    for {
        // ReadAt 从指定的偏移量开始读取,不会改变文件偏移量
        len, _ := file5.ReadAt(buf2, int64(ix))
        ix = ix + len
        if len == 0 {
        break
        }
        fmt.Println(string(buf2))
    }
    file5.Close()

    // 写入文件
    file6, error := os.Create("/tmp/4.txt")
    if error != nil {
        fmt.Println(error)
    }
    data := "This is data\r\n"
    for i := 0; i < 10; i++ {
        // 写入 byte 的 slice 数据
        file6.Write([]byte(data))
        // 写入字符串
        file6.WriteString(data)
    }
    file6.Close()

    // 写入文件
    file7, error := os.Create("/tmp/5.txt")
    if error != nil {
        fmt.Println(error)
    }
    for i := 0; i < 10; i++ {
        // 按指定偏移量写入数据
        ix := i * 64
        file7.WriteAt([]byte("This is data"+strconv.Itoa(i)+"\r\n"), int64(ix))
    }
    file7.Close()

    // 删除文件
    del := os.Remove("/tmp/1.txt")
    if del != nil {
        fmt.Println(del)
    }

    // 删除指定 path 下的所有文件
    delDir := os.RemoveAll("/tmp/testdir")
    if delDir != nil {
            fmt.Println(delDir)
    }
}
阅读全文

Go delete map


清空 map

import (
    "fmt"
    "time"
)

func main() {
    testMap := make(map[string]string)
    testMap["k"] = "v"
    fmt.Println(testMap)
    time.Sleep(time.Second * 2)
    for key, value := range testMap {
        fmt.Println(value)
        delete(testMap, key)
    }
    fmt.Println(testMap)
}

阅读全文

Go map使用


先声明 map

var m1 map[string]string

再使用 make 函数创建一个非 nil 的 map,nil map 不能赋值

m1 = make(map[string]string)

最后给已声明的 map 赋值

m1["a"] = "aa"
m1["b"] = "bb"

阅读全文

Go 获取文件 md5 值


package main

import (
    "bufio"
    "crypto/md5"
    "fmt"
    "io"
    "os"

    "v.src.corp.qihoo.net/weblego/lib4go/convert"
)

func fileMdFir(filePath string) string {
    file, _ := os.Open(filePath)
    defer file.Close()
    h := md5.New()
    io.Copy(h, file)
    fileMd1 := convert.U2S(h.Sum(nil))
    return fileMd1
}

func fileMdSec(file string) string {
    f, _ := os.Open(file)
    defer f.Close()
    r := bufio.NewReader(f)
    h := md5.New()
    io.Copy(h, r)
    fileMd2 := convert.U2S(h.Sum(nil))
    return fileMd2
}

func main() {
    fileMd1 := fileMdFir("/tmp/conf/deploy.toml")
    fmt.Println(fileMd1)
    fileMd2 := fileMdSec("/tmp/conf/deploy.toml")
    fmt.Println(fileMd2)
}
阅读全文

Go 计算 md5


主要是使用 crypto/md5、encoding/hex 两个包

package process

import (
    "crypto/md5"
    "encoding/hex"
)

// MakeMD is make md5.
func MakeMD(initString string) string {
    m := md5.New()
    m.Write([]byte(initString))
    md := m.Sum(nil)
    mdString := hex.EncodeToString(md)
    return mdString
}
阅读全文

Go 中使用 base64


package main

import (
    "encoding/base64"
    "fmt"
    "log"
)

func main() {
    input := []byte("hello golang base64")

    // base64 encode
    encodeString := base64.StdEncoding.EncodeToString(input)
    fmt.Println(encodeString)

    // base decode
    decodeBytes, err := base64.StdEncoding.DecodeString(encodeString)
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(string(decodeBytes))
}
阅读全文

Go make 和 new 的区别


new 和 make 都可以用来分配空间,初始化类型,但是它们确有不同。
new(T)返回的是 T 的指针
new(T)为一个 T 类型新值分配空间并将此空间初始化为 T 的零值,返回的是新值的地址,也就是 T 类型的指针 *T,该指针指向 T 的新分配的零值。

package main

import "fmt"

func main() {
    p1 := new(int)
    fmt.Printf("p1 --> %#v \n ", p1)
    fmt.Printf("p1 point to --> %#v \n ", *p1)

    var p2 *int
    i := 0
    p2 = &i
    fmt.Printf("p2 --> %#v \n ", p2)
    fmt.Printf("p2 point to --> %#v \n ", *p2)
}


阅读全文

Go 字符串分割


将字符串 s 以空格为分隔符拆分成若干个字符串,若成功则返回分割后的字符串切片。

str := "Hello World Too"
for _, v := range strings.Fields(str) {
    fmt.Println(v)
}

将字符串 s 中的字符串以字符 sep 为分隔符拆分成若干个元素的字符串切片,并返回字符串切片。

for _, v := range strings.Split(str, " ") {
    fmt.Println(v)
}

将字符串 s 中的字符串以字符 sep 为分隔符拆分成若干个字符串切片并且保留原字符串中的分隔符号,并返回字符串切片。

for _, v := range strings.SplitAfter(str, ",") {
    fmt.Println(v)
}
阅读全文

Go 字符串替换


package main
 
import (
    "fmt"
    "strings"
)
 
func main() {
    str := "welcome to beijing"
    strF = strings.Replace(str, " ", ",", -1)
    fmt.Println(strF)
    strS = strings.Replace(str, " ", ",", 1)
    fmt.Println(strS)
}
阅读全文