Go语言基础学习二－简单的代码分析

Go语言基础学习二
一点经验：
    main()函数作为整个程序的入口，没有参数，也没有返回值，还有一个函数init（）先于main（）执行，以后待讲。
    导入包中fmt提供格式化文本和读入格式文本的函数，os包提供了跨平台的操作系统层面变量及函数，包括保存命令行参数的类型os.Args 
strings包提供处理字符串的函数。
    go程序中不含有分号，分号由编译器自动添加。
    filepath.Base()函数会返回传入路径的基础名,Go语言采用单引号表达字符，Go语言具有强类型转换，将int16与int32不能直接相加，需要进行类型转换。
     栈－自定义类型及其方法，自定义栈可以通过空接口来实现将异构（类型不同的）的元素混合存储，因为go语言的所有类型都实现了空接口。
     func (stack *Stack) Top() (interface{},error){
       return stack[len(stack)-1],nil
}   函数的声明，第一个圆括号 stack *Stack表示一个类型为指向Stack的参数，名为stack，最后一个圆括号表示返回的值，返回两个值，一个是空接口，一个是错误信息。
      切片（在我的理解，就是数组），切片的内容可以通过索引来表示［first：end］一定范围的值。
      buffo包提供了带缓冲的I/O处理能力，io包提供了底层I/O能力，包含有io.Reader及io.Writer接口，io/ioutil包提供了一系列高级文件处理函数。regexp包则提供了强大的正则表达式支持。
package main

import (
    "bufio"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "os"
    "path/filepath"
    "regexp"
    "strings"
)
var britishAmerican = "british-american.txt"

func init() {／＊进入函数main（）之前，首先要执行init（）内部的内容，获取当前目录并构建单词转化所需的文本路径＊／
    dir, _ := filepath.Split(os.Args[0])
    britishAmerican = filepath.Join(dir, britishAmerican)
}

func main() {
    inFilename, outFilename, err := filenamesFromCommandLine()
／＊调用filenamesFromCommandLine（）函数获取命令行中的数据输入文件和输出文件，返回值为输入文件名和输出文件名及错误信息＊／
    if err != nil {／＊当错误信息不为空时，输出并退出程序＊／
        fmt.Println(err)
        os.Exit(1)
    }
    inFile, outFile := os.Stdin, os.Stdout
    if inFilename != "" {
        ／＊打开只读输入文件，返回指向文件的指针和错误信息＊／
        if inFile, err = os.Open(inFilename); err != nil {
            log.Fatal(err)
        }
        ／＊defer是指推迟执行，直到main（）函数正常返回会调用该执行语句，关闭文件，回收内存，当程序崩溃时，不会执行，但是go语言系统会自动关闭所有打开的文件，垃圾回收器会回收内存＊／
        defer inFile.Close()
    }
    if outFilename != "" {
        ／＊os.Create（）读取一个文件，若文件不存在创建该文件，若存在，将该文件长度截为0*／
        if outFile, err = os.Create(outFilename); err != nil {
            log.Fatal(err)
        }
        defer outFile.Close()
    }
     ／＊americanise该函数用于替换英式单词为美式单词＊／
    if err = americanise(inFile, outFile); err != nil {
        log.Fatal(err)
    }
}

／＊该函数用于分析命令行＊／
func filenamesFromCommandLine() (inFilename, outFilename string,
    err error) {
    ／＊os.Args保存有命令行参数，命令行参数大于1，且可以分析－h及－－help等参数为命令解释请求＊／
    if len(os.Args) > 1 && (os.Args[1] == "-h" || os.Args[1] == "--help") {
        err = fmt.Errorf("usage: %s [<]infile.txt [>]outfile.txt",
            filepath.Base(os.Args[0]))
        return "", "", err
    }
    if len(os.Args) > 1 {
        inFilename = os.Args[1]
        if len(os.Args) > 2 {
            outFilename = os.Args[2]
        }
    }
    if inFilename != "" && inFilename == outFilename {
        log.Fatal("won't overwrite the infile")
    }
    return inFilename, outFilename, nil
}

／＊该函数实现替换英式单词为美式单词＊／
func americanise(inFile io.Reader, outFile io.Writer) (err error) {
    ／＊向bufio.NewReader传入实现io.Rreader接口的值，提供缓冲机制＊／
    reader := bufio.NewReader(inFile)
    writer := bufio.NewWriter(outFile)
    ／＊延迟至main（）函数返回，刷新写缓冲区，确保全部写入＊／
    defer func() {
        if err == nil {
            err = writer.Flush()
        }
    }()
    ／＊定义一个替换器函数，参数为string，返回string＊／
    var replacer func(string) string
    ／＊makeReplacerFunction根据单词替换文本britishAmerican生成替换器replacer＊／
    if replacer, err = makeReplacerFunction(britishAmerican); err != nil {
        return err
    }
    ／＊正则表达式＊／
    wordRx := regexp.MustCompile("[A-Za-z]+")
    eof := false
    ／＊循环读取文件，直到读到文件末尾＊／
    for !eof {
        var line string
        line, err = reader.ReadString('\n')
        if err == io.EOF {
            err = nil   // io.EOF isn't really an error
            eof = true  // this will end the loop at the next iteration
        } else if err != nil {
            return err  // finish immediately for real errors
        }
        ／＊对读取的每一行进行替换器替换并写入输出文件＊／
        line = wordRx.ReplaceAllStringFunc(line, replacer)
        ／＊这里的_表示空标记符，作为一个占位符放在一个需要变量的地方，并忽略掉该变量的值。＊／
        if _, err = writer.WriteString(line); err != nil {
            return err
        }
    }
    return nil
}
／＊根据单词替换文本生成替换器replacer＊／
func makeReplacerFunction(file string) (func(string) string, error) {
    ／＊首先读取单词替换文本＊／
    rawBytes, err := ioutil.ReadFile(file)
    if err != nil {
        return nil, err
    }
    text := string(rawBytes)
    ／＊创建一个映射对象＊／
    usForBritish := make(map[string]string)
    ／＊将文本逐行分解＊／
    lines := strings.Split(text, "\n")
    for _, line := range lines {
        ／＊每一行将根据空格符生成对应切片，strings.Fields这个函数就是以空白分割符来分隔字符串＊／
        fields := strings.Fields(line)
        if len(fields) == 2 {
            ／＊将切片填充到映射对象中去＊／
            usForBritish[fields[0]] = fields[1]
        }
    }

    return func(word string) string {
        ／＊根据映射对象的映射关系生成替换器＊／
        if usWord, found := usForBritish[word]; found {
            return usWord
        }
        return word
    }, nil
}
go语言中字符串类型的内部表示统一为utf－8编码的。
go语言中的映射，切片和通道都是要通过make（）函数来创建的。
for。。range语法用于遍历切片和数组非常方便，每次迭代它会返回切片的索引和在该切片上的元素值。