Go基础编程---异常处理和文件处理、json、字符串转换..

异常处理

error 接口 （非致命错误）

err := fmt.Errorf( "%s", "提示erro")
// 第二种：
import "errors"
err2 := errors.New("this is normal err")
eg：
import (
  "fmt"
  "errors"
)
func main () {
   a,b := 12 ,0
   result, err := divide(a, b)
   if err != nil{
     fmt.Println(err)
   }else{
     fmt.Println(result)
   }
}
func  divide (a,b int) (result int, err error) {
   err = nil
   if b == 0 {
     err = errors.New("分母不能为0")
   }else {
      result = a / b
   }
   return
}

panic( 致命错误，程序崩溃)

// 自己调用panic()
func aa(){
  fmt.Println("aaaa")
}
func bb(){
  panic("cuowu ")
  fmt.Println("bbbb")
}
func cc(){
  fmt.Println("cccc")
}
   aa()
   bb()
   cc()  // 只会打 aaa 然后报错，程序停止

// 内部自动调用的panic场景有，数组下标访问出界....

recover （防止程序崩溃导致不运行）

func testc ( x int) {
   defer func (){
      if err := recover(); err !=nil{
        fmt.Println(err)
      }
   }()
   a := [10]int{}
   a[x] = 11
}
func main () {
   testc(20)
   fmt.Println("ok----------------------------")
}

文件处理

字符串处理 需要 import "strings"

   fmt.Println(strings.Contains("hellow", "hell")) // 包含返回true，否则返回false
    s := []string{"abc","efg","hgk"}
    fmt.Println(strings.Join(s,"#")) // abc#efg #hgk 将切片组合成字符串
    fmt.Println(strings.Index("hellow","ow")) // 4 ，若查不到返回 -1
    fmt.Println(strings.Repeat("he", 3))  // hehehe
    fmt.Println(strings.Split("aa-bb-cc-dd", "-")) //[aa bb cc dd] 切片
    fmt.Println(strings.Trim("  xx xx  "," ")) // xx xx 去前后空格
    fmt.Println(strings.Fields("xx bb cc  dd ")) // [xx bb cc dd] 按照空格，把元素放入到切片中

字符串转换 import "strconv"

   slice := make([]byte,0,1024)
   slice = strconv.AppendBool(slice, true) //把bool类型转为字符串类型
   slice = strconv.AppendInt(slice, 112, 10) // 最后一个参数指定10进制的方式追加
   slice = strconv.AppendQuote(slice, "aaa") // 追加字符串
   fmt.Println(string(slice))  // 转换成字符串后打印---true112"aaa"

// 其他类型转为字符串
  var str string
  str  = strconv.FormatBool(false)  // 把 bool转为string
  str  = strconv.FormatFloat(3.14, 'f' , -1 ,64) //f 指打印格式，-1指小数点位数，64以float64
   str = strconv.Itoa(666)  // 整型转字符串 （常用）

// 字符串转为其他类型
   a,err := strconv.ParseBool("true") //true --- 
   a,err := strconv.Atoi("555")   //555--- 
   fmt.Println(a,"---",err)

正则表达式 import "regexp"

 buf := "avnvv sdsds adc"
 reg := regexp.MustCompile(`a.c`) // 创建匹配规则
   if reg == nil {
     return
   }
   res := reg.FindAllStringSubmatch(buf, -1) // -1指从头到尾
   fmt.Println(res) // 返回一个分组的切片 [[adc]]

JSON处理

通过结构体生成json

package main

import (
    "encoding/json"
    "fmt"
)
func main() {
    type IT struct {
        Company  string   `json:"company"`     // 二次编码，改为小写
        Subjects []string `json:"-"`           // - 代表此字段不输出
        IsOk     bool     `json:"isOk,string"` // 将布尔类型的以string输出
        Price    float64  `json:"price"`
    }
    s := IT{"aas", []string{"go", "c++", "node", "web"}, true, 3.22}
    //编码，根据内容生成json文本
    // buf,err := json.Marshal(s)  //json未格式化输出 {"company":"aas","isOk":"true","price":3.22}
    buf, err := json.MarshalIndent(s, "", " ") //json格式化代码输出,两个参数表示每一行的前缀和缩进方式,固定写法
    if err != nil {
        return
    }
    fmt.Println("buf= ", string(buf))
    /*
    buf = {
         "company": "aas",
         "isOk": "true",
         "price": 3.22
        }
    */
}

通过map生成json

//创建一个map
m := make(map[string]interface{},4)
m["company"] = "aas"
m["subjectes"] = []string{"go","c++"}
m["isok"] = true
// 编码成json
result, err := json.MarshalIndent(m,"","  ")
if err != nil{
   return
}
fmt.Println("res = ", string(result))

json解析到结构体

jsonBuf :=`
   "company": "aas",
   "subjects" :[
       "go",
       "c++"
     ],
    "isok" : true,
    "price" : 1.33
`
// 定义结构体：
type IT struct{
     Company string  `json:"company"` // 二次编码，改为大写
     Subjects []string `json:"subjects"`   // 定义多少字段会显示多少字段
     IsOk  bool `json:"isok"`  
     Price float64 `json:"price"`
   }
//  定义一个结构体实体
var tmp IT
err := json.Unmarshal([]byte(jsonBuf), &tmp)  // 第二个参数要传地址
if err!= nil{
  return
}
fmt.Printf("tmp= %+v\n", tmp)

json解析到map

jsonBuf :=`
   "company": "aas",
   "subjects" :[
       "go",
       "c++"
     ],
    "isok" : true,
    "price" : 1.33
`
m :=make(map[string]interface{},4) 
err :=json.Unmarshal([]byte(jsonBuf), &m)
fmt.Printf("m = %+v \n", m)
//但是要用json数据的话就要使用类型断言，一步步反推，才可以，一般json转结构体。

文件操作 import "os"

os.Create(filename)  // 返回一个文件对象和error，如果有清空，不存在就创建

path := "./demo.txt"
WriteFile(path)
// 写文件
func WriteFile( path string){
   f,err := os.Create(path)  
   if err != nil { return }
   defer f.Close()
   var buf string
   for i:=0 ; i <10; i++{
       buf = fmt.Sprintf("%d\n",i) // 将保存在buf里面
       n, err := f.WriteString(buf)
       if err ! = nil{ return }
    }
}
// 读文件
func ReadFile(path string){
  f,err := os.Open(path)
  if err != nil{ return}
  defer f.Close()
  buf := make([]byte,1024*2) // 定义一个2kb长的切片
  n,err1 :=f.Read(buf) // n代表从文件读取内容的长度
  if err1 !=nil && err1 != io.EOF{return } //文件出错同时也没到结尾
  fmt.Println("buf = ",string(buf[:n]))
}

// 按照行读取，需要bufio这个库，引入
import  "bufio"

文件拷贝小列子

package main
import (
  "fmt"
  "os"
  "io"
)
func main () {
  orPath, newPath := getPath()
  orf,err := os.Open(orPath)
  if err != nil { return }
  defer orf.Close()
  // 创建新的文件目录
  f,err2 := os.Create(newPath)
  if err2 != nil{ return }
  defer f.Close()
  // 创建buffer 大小4kb
  buf := make([]byte, 4*1024) 
  for{
    n, err := orf.Read(buf)
    if err !=nil{
      if err == io.EOF{ // 判断读取出错是否由于已经读完引起
        break
      }
    }
    f.Write(buf[:n])  // 有多少读多少
  }
}
// 获取用户刷
func getPath()(orPath, newPath string){
  list := os.Args
  if len(list) != 3{
    fmt.Println("输入错误")
    return
  }
  orPath = list[1]
  newPath = list[2]
  return
}