本节主要分享：延迟（defer），集合，字符串函数，字符串格式。

以下代码在存放于github中如下仓库:github

Go延迟（defer）实例

defer用于确保稍后在程序执行中执行函数调用，通常用于清理目的。延迟（defer）常用于例如，ensure 和 finally 常见于其他编程语言中。

假设要创建一个文件，写入内容，然后再完成之后关闭。这里可以这样使用延迟(defer)处理。

在使用 createFile 获取文件对象后，立即使用closeFile推迟该文件的关闭。这将在writeFile() 完成后封装函数 (main)结束时执行。

package main

import (
    "os"
    "fmt"
)

func main(){
    f := createFile("defer_panic_test.txt")
    defer closeFile(f)
    writeFile(f)
}

func createFile(p string) *os.File{
    fmt.Println("creating")
    f,err := os.Create(p)
    if err != nil{
        panic(err)
    }
    return f
}

func writeFile(f *os.File){
    fmt.Println("writing")
    fmt.Fprintln(f,"data")
}

func closeFile(f *os.File){
    fmt.Println("closing")
    f.Close()
}

Go 集合函数实例

我们经常需要在程序中对数据集合执行操作，例如选择满足给定集合的项目，或者将所有项目映射到具有自定义函数的新集合。

在某些语言中，通用数据结构和算法是惯用的。Go 不支持泛型。

这里是一些字符串切片的示例收集函数。可以使用这些示例来构建自己的函数。注意，某些情况下，直接内联集合操作代码可能是最清楚的，而不用创建和调用辅助函数。

代码实现功能如下：返回目标字符串 t 的第一个索引，如果没找到就返回 -1 。如果目标字符串 t 在切片中，则返回 true。如果切片中的第一个字符串满足词 f ，则返回 true。 如果切片中所有的字符串都满足 f ，则返回 true。返回一个新的切片，包含将函数 f 应用于原始切片中的每一个字符串的结果。

package main

import (
    "fmt"
    "strings"
)

//找寻单词排第几
func Index(vs []string,t string ) int{
    for i,v := range vs {
        if v == t {
            return i
        }
    }
    return -1
}

//判断是否包含有该单词
func Include(vs []string,t string) bool{
    return Index(vs,t)>=0
}

//当含有目标单词，返回true
func Any(vs []string, f func(string) bool) bool{
    for _,v := range vs{
        if f(v) {
            return true
        }
    }
    return false
}
//当所有单词都在里面时，才返回true
func All(vs [] string,f func(string)bool)bool{
    for _,v := range vs{
        if !f(v){
            return false
        }
    }
    return true
}

//过滤包含某单词的
func Filter(vs []string, f func(string)bool) []string{
    vsf := make([]string , 0)
    for _,v := range vs {
        if f(v){
            vsf = append(vsf,v)
        }
    }
    return vsf
}
//新切片
func Map(vs []string, f func(string)string)[]string{
    vsm := make([]string,len(vs))
    for i,v := range vs{
        vsm[i] = f(v)
    }
    return vsm
}

func main(){
    var strs = []string{"peach","apple","pear","plum"}

    fmt.Println(Index(strs,"pear"))

    fmt.Println(Include(strs,"grape"))

    fmt.Println(Any(strs, func(v string) bool {
        return strings.HasPrefix(v,"p")
    }))

    fmt.Println(All(strs, func(v string) bool {
        return strings.HasPrefix(v,"p")
    }))

    fmt.Println(Filter(strs, func(v string) bool {
        return strings.Contains(v,"e")
    }))

    fmt.Println(Map(strs,strings.ToUpper))

}

Go字符串函数实例

标准库的字符串包提供了许多有用的字符串相关函数。这里有一些例子就像是用一个包的感觉。将 fmt.Println 取一个别名，缩写成一个较短的名称，下面示例代码中将使用它。

下面是一些来自包的函数，而不是字符串对象本身的方法，所以我们需要将待处理字符串作为函数的第一个参数传入。还有更多的函数可以在 字符串包 的文档中找到。

注意： Len 函数和索引均工作在字节级别上。Go 使用 UTF-8 编码字符串，如果使用潜在的多字节字符，将需要使用编码转换操作。

package main

import (
    "fmt"
    s "strings"
)

var p = fmt.Println


func main(){

    //在 http://golang.org/pkg/strings/ 中有更多的解释
    p("Contains:  ",s.Contains("test","es"))

    p("Count:     ",s.Count("Test","t"))
    p("HasPrefix: ",s.HasPrefix("test","te"))
    p("HasSuffix: ",s.HasSuffix("test","st"))
    p("Index:     ",s.Index("test","e"))
    p("Join:      ",s.Join([]string{"a","b"},"-"))
    p("Repeat:    ",s.Repeat("a",5))
    p("Replace:   ",s.Replace("foo","o","0",-1))
    p("Replace:   ",s.Replace("foo","o","0",1))
    p("Split:     ",s.Split("a-b-c-d-e","-"))
    p("ToLoer:    ",s.ToLower("TEST"))
    p("ToUpper:   ",s.ToUpper("test"))
    p()

    p("Len:       " ,len("Hello"))
    p("Char:       ","Hello"[1])

}

Go字符串格式实例

Go 语言为传统的 Printf 字符串格式化输出提供了极好的支持。以下是常见的字符串格式化示例。

Go 提供了几种打印动词，设计用于格式化一般的值。

如果值是一个结构体， %+v 变体将包括结构体的字段名。

%#v 变体打印Go语法表示，将会生成该值的源代码片段。

要打印值的类型，请使用 %T。格式化布尔是比较直接了当的。有许多格式化整数的选项。对于标准的 base-10 格式化，请使用 %d。

package main

import (
    "fmt"
    "os"
)

type point struct {
    x,y int
}

func main(){
    p := point{1,2}
    fmt.Printf("%v\n" ,p)
    fmt.Printf("%+v\n",p)
    fmt.Printf("%#v\n",p)
    fmt.Printf("%T\n" ,p)

    fmt.Printf("%t\n",true)

    fmt.Printf("%d\n",123)

    //二进制形式打印
    fmt.Printf("%b\n",p)
    //字符串形式
    fmt.Printf("%c\n",33)
    //十六进制
    fmt.Printf("0x%x\n",456)
    //浮点
    fmt.Printf("%f\n",78.9)

    //不同的科学计数法
    fmt.Printf("%e\n",123400000.0)
    fmt.Printf("%E\n",123400000.0)

    //基本字符串输出
    fmt.Printf("%s\n","\"string\"")

    fmt.Printf("%q\n","\"string\"")
    //十六进制打印
    fmt.Printf("%x\n","hex this")
    //指针
    fmt.Printf("%p\n",&p)

    /*含间距格式化*/
    fmt.Printf("|%6d|%6d|\n",12,345)
    //使用 - 可以左对齐
    fmt.Printf("|%-6.2f|%-6.2f|\n",1.2,3.45)
    fmt.Printf("|%6.2f|%6.2f|\n",1.2,3.45)

    fmt.Printf("|%6s|%6s|\n","foo","b")
    fmt.Printf("|%-6s|%-6s|\n","foo","b")

    //sprintf也有的
    s := fmt.Sprintf("a %s","string")
    fmt.Println(s)

    //错误通道打印信息
    fmt.Fprintf(os.Stderr,"an %s\n","error")
}

Go 正则表达式实例

Go 提供了对正则表达式的内置支持，下面是Go 常见的 regexp 的一部分例子。正则表达式本身很强大，规则需要多用才能够熟练。

package main

import (
    "regexp"
    "fmt"
    "bytes"
)

func main(){
    //测试规则是否能匹配字符串
    match,_:=regexp.MatchString("p([a-z]+)ch","peach")
    fmt.Println(match)

    //使用regexp其他函数的时候需要先 使用 compile 函数进行优化
    r,_:= regexp.Compile("p([a-z]+)ch")

    fmt.Println(r.MatchString("peach"))
    //找寻符合规则的字符串
    fmt.Println(r.FindString("peach punch"))
    //找寻符合规则的字符串所在位置 这里返回时开始和结束的位置
    fmt.Println(r.FindStringIndex("peach punch"))
    //匹配 "p([a-z]+)ch" 和 "([a-z]+)" 两个表达式
    fmt.Println(r.FindStringSubmatch("peach punch"))
    //匹配上面两个表达式找到的字符所在的位置
    fmt.Println(r.FindStringSubmatchIndex("peach punch"))
    //找寻所有符合的字符串
    fmt.Println(r.FindAllString("peach punch pinch",-1))
    //找寻所有子规则符合的字符串所在位置
    fmt.Println(r.FindAllStringSubmatchIndex("peach punch pinch",-1))
    //限制只找两个
    fmt.Println(r.FindAllString("peach punch pinch",2))

    fmt.Println(r.Match([]byte("peach")))

    r = regexp.MustCompile("p([a-z]+)ch")
    fmt.Println(r)

    fmt.Println(r.ReplaceAllString("a peach","<fruit>"))

    in  := []byte("a peach")
    out := r.ReplaceAllFunc(in,bytes.ToUpper)
    fmt.Println(string(out))
}

如需进一步讨论可以加群：295023494