0
点赞
收藏
分享

微信扫一扫

GO 学习笔记——第五天 / 异常，文本文件处理

代码敲到深夜 2022-06-05 阅读 13
GOjsonc++javaGo语言编程语言

1.error接口，panic，recover

  • error：输出错误信息
package main

import "fmt"
import "errors"

func main() {

    err1 := fmt.Errorf("ERROR")
    fmt.Println(err1)

    err2 := errors.New("THIS IS ERROR")
    fmt.Println(err2)

    result, err := Div(10, 2)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(result)
    }
}

//相除
func Div(a, b int) (result int, err error) {
    err = nil
    if b == 0 {
        err = errors.New("除数不能为0")
    } else {
        result = a / b
    }
    return result, err
}
  • panic
  • 致命错误
package main

import "fmt"

func main() {

    TestA()
    TestB()
    TestC()
}

func TestA() {
    fmt.Println("A")
}

func TestB() {
    fmt.Println("B")
    //panic会直接中断程序
    //panic("Error")
}

func TestC() {
    fmt.Println("C")

    //模拟数组越界
    x := [2]int{1, 2}
    x[3] = 10
}
  • recover
  • 出错但不停止程序
package main

import "fmt"

func main() {

    TestA()
    TestB(3)
    TestC()

    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }

    }()
}

func TestA() {
    fmt.Println("A")
}

func TestB(x int) {
    fmt.Println("B")
    //panic会直接中断程序
    //panic("Error")

    //模拟数组越界
    i := [2]int{1, 2}
    i[x] = 10
}

func TestC() {
    fmt.Println("C")
}

2.字符串处理

  • 字符串操作
  • Contains:是否包含
  • Join:拼接
  • Index:位置
  • Repeat:拼接重复
  • Replace:替换
  • Split:分离
  • Trim:两头去除
  • Fieids:分离更加强大
package main

import "fmt"
import "strings"

//字符串操作
func main() {

    s := "Hello World"

    fmt.Println(strings.Contains(s, "W"))
    //true
    fmt.Println(strings.Contains(s, "A"))
    //false

    s1 := []string{"abc", "def", "ghi", "jk"}
    fmt.Println(strings.Join(s1, "&"))
    //abc&def&ghi&jk

    fmt.Println(strings.Index(s, "W"))
    //6

    s = strings.Repeat("go", 3)
    fmt.Println(s)
    //gogogo

    s = "Hello World"
    fmt.Println(strings.Split(s, " "))
    //[Hello World]

    fmt.Println(strings.Trim("    are you ok ? ", " "))
    //are you ok  ?

    fmt.Println(strings.Fields("    are you ok ?  "))
    //[are you ok ?]
}
  • 字符串转换
  • Append：将整数转换成字符串并且追加
  • Format：把其他类型转换成字符串
  • Parse：把字符串转换成其他类型
package main

import "fmt"
import "strconv"

//字符串转换
func main() {

    slice := make([]byte, 0, 1024)
    slice = strconv.AppendBool(slice, true)
    //十进制方式追加
    slice = strconv.AppendInt(slice, 1234, 10)

    fmt.Println(string(slice))
    //true1234

    var str string
    str = strconv.FormatBool(true)
    fmt.Println(str)
    //true
    str = strconv.FormatFloat(3.14, 'f', -1, 32)
    fmt.Println(str)
    //3.14
    str = strconv.Itoa(6556)
    fmt.Println(str)
    //6556

    var flag bool
    var err error
    flag, err = strconv.ParseBool("true")
    if err == nil {
        fmt.Println(flag)
        //true
    } else {
        fmt.Println(err)
    }

    i, err := strconv.Atoi("1867")
    if err == nil {
        fmt.Println(i + 9)
        //1876
    } else {
        fmt.Println(err)
    }

}

3.正则表达式

package main

import "fmt"
import "regexp"

func main() {

    buf := "abc azc a7c aac 888 a9c tac"
    reg := regexp.MustCompile(`a.c`)
    if reg == nil {
        fmt.Println("error")
        return
    }
    result := reg.FindAllStringSubmatch(buf, -1)
    fmt.Println(result)
    //[[abc] [azc] [a7c] [aac] [a9c]]

    //提取有效的小数
    buff := "3.14 ddd wr5 6. 7.12 www 92.1"
    rege := regexp.MustCompile(`\d+\.\d+`)
    if rege != nil {
        result := rege.FindAllStringSubmatch(buff, -1)
        fmt.Println(result)
        //[[3.14] [7.12] [92.1]]
    }

}

4.JSON处理

  • Json生成
package main

import "fmt"
import "encoding/json"

//Json 生成
func main() {

    //1.通过结构体生成
    s := IT{"大学", []string{"Java", "C/C++", "GO"}, true, 3.14}
    //buf, err := json.Marshal(s)
    //格式化打印
    buf, err := json.MarshalIndent(s, "", " ")
    if err == nil {
        fmt.Println(string(buf))
        //{"Company":"大学","Subjects":["Java","C/C++","GO"],"IsOk":true,"Price":3.14}
    } else {
        fmt.Println(err)
    }

    fmt.Println("-------------------------------------")

    //2.通过Map生成
    m := make(map[string]interface{}, 4)
    m["company"] = "大学"
    m["subjects"] = []string{"Java", "C/C++", "GO"}
    m["isOk"] = true
    m["price"] = 3.14
    buff, errs := json.MarshalIndent(m, "", " ")
    if errs == nil {
        fmt.Println(string(buff))
        //{"company":"大学","isOk":true,"price":3.14,"subjects":["Java","C/C++","GO"]}
    } else {
        fmt.Println(errs)
    }

    fmt.Println("-------------------------------------")
}

//成员变量名首字母必须大写
type IT struct {
    //需要小写字段 二次编码
    Company  string `json:"company"`
    Subjects []string
    //二次编码转换string
    IsOk  bool `json:",string"`
    Price float64
}
  • Json解析
package main

import "fmt"
import "encoding/json"

//Json 解析
func main() {

    sJson := `{"company":"大学","isOk":true,"price":3.14,"subjects":["Java","C/C++","GO"]}`

    //1.解析到结构体
    var tmp IT
    err := json.Unmarshal([]byte(sJson), &tmp)
    if err == nil {
        fmt.Println(tmp)
        //{大学 [Java C/C++ GO] true 3.14}
    }
    //2.解析到map
    m := make(map[string]interface{}, 4)
    json.Unmarshal([]byte(sJson), &m)
    if err == nil {
        fmt.Println(m)
        //map[subjects:[Java C/C++ GO] company:大学 isOk:true price:3.14]
        fmt.Println(m["company"])
        //大学
    }
}

type IT struct {
    Company  string   `json:"company"`
    Subjects []string `json:",subjects"`
    IsOk     bool     `json:",isOK"`
    Price    float64  `json:",price"`
}

5.文件操作

  • 设备文件:屏幕（标准输出设备）,键盘（标准输入设备）
  • 磁盘文件：放在存储设备上的文件
package main

import "fmt"
import "os"
import "bufio"
import "io"

//Json 解析
func main() {

    //关闭后无法输出
    //os.Stdout.Close()
    fmt.Println("Hello")
    os.Stdout.WriteString("World\n")

    path := "./test.txt"

    //文件的写
    WhiteFile(path)
    //文件的读
    ReadFile(path)
    //换行读取
    ReadLineFile(path)
}

func ReadLineFile(path string) {
    file, err := os.Open(path)
    if err == nil {
        buf := make([]byte, 1024*2)
        //n代表读取内容的长度
        _, err1 := file.Read(buf)
        if err1 == nil {
            //新建一个缓冲区，内容先放在缓冲区
            r := bufio.NewReader(file)
            for {
                bufs, err2 := r.ReadBytes('\n')
                if err2 == nil {
                    fmt.Println(string(bufs))
                } else {
                    //文件结束
                    if err2 == io.EOF {
                        break
                    }
                    fmt.Println(err2)
                }
            }
        } else {
            fmt.Println(err)
        }
    } else {
        fmt.Println(err)
    }
    defer file.Close()
}

func ReadFile(path string) {
    file, err := os.Open(path)
    if err == nil {
        buf := make([]byte, 1024*2)
        //n代表读取内容的长度
        n, err1 := file.Read(buf)
        if err1 == nil {
            fmt.Println(string(buf[:n]))
        } else {
            fmt.Println(err)
        }
    } else {
        fmt.Println(err)
    }
    defer file.Close()
}

func WhiteFile(path string) {
    file, err := os.Create(path)
    if err == nil {
        for i := 0; i < 10; i++ {
            file.WriteString("Hello")
        }
    } else {
        fmt.Println(err)
    }
    defer file.Close()
}

6.拷贝文件案例

package main

import "fmt"
import "os"
import "io"

func main() {
    //获取命令行参数
    list := os.Args
    if len(list) == 3 {
        srcFileName := list[1]
        dstFileName := list[2]
        fmt.Println("srcFileName:", srcFileName, "dstFileName:", dstFileName)
        if srcFileName != dstFileName {
            //只读方式打开源文件
            sF, err1 := os.Open(srcFileName)
            if err1 == nil {
                dF, err2 := os.Create(dstFileName)
                defer sF.Close()
                defer dF.Close()
                if err2 == nil {
                    //从源文件读 写入
                    buf := make([]byte, 1024*4)
                    for {
                        n, err3 := sF.Read(buf)
                        fmt.Println("n:", n)
                        if err3 == nil {
                            //写入
                            dF.Read(buf[:n])
                        } else {
                            fmt.Println(err3)
                            if err3 == io.EOF {
                                break
                            }
                        }
                    }
                } else {
                    fmt.Println(err2)
                }
            } else {
                fmt.Println(err1)
            }
        } else {
            fmt.Println("name == name")
        }
    } else {
        fmt.Println("xxx srcFile dstFile")
    }
}

举报

相关推荐

第五天笔记

网络服务器运维

GO面试第五天

GO面试题赋值强类型指针变量Go语言编程语言

Nginx第五天学习笔记

Nginx负载均衡服务器云服务云计算

第五天学习

跳出循环i++循环语句C/C++编程语言

学习第五天

#include不定方程i++编程语言

kafka第五天学习笔记

最佳实践高级特性幂等性云服务云计算

MySQL学习笔记第五天

linux运维软硬链接原力计划

ORALE学习第五天笔记

触发器存储过程sql云服务云计算

HarmonyOS第五天学习笔记

智能家居物联网数据管理HarmonyOS后端开发

# 第五天

函数传值调用和传址调用递归调用判断质数C/C++编程语言
0 条评论