baliance/gooxml

gooxml是可以對整個office document提供支援的golang庫，功能很強大，這裡簡單給出對word文件的讀取案例

安裝

go get baliance.com/gooxml/

go build -i baliance.com/gooxml/…

解析word程式碼

package main
import (
 "fmt"
 "log"
 "baliance.com/gooxml/document"
)
func main() {
 doc,err := document.Open("ml.docx")
 if err != nil {
  log.Fatalf("error opening document: %s",err)
 }
 //doc.Paragraphs()得到包含文件所有的段落的切片
 for i,para := range doc.Paragraphs() {
  //run為每個段落相同格式的文字組成的片段
  fmt.Println("-----------第",i,"段-------------")
  for j,run := range para.Runs() {
   fmt.Print("\t-----------第",j,"格式片段-------------")
   fmt.Print(run.Text())
  }
  fmt.Println()
 }
}

舉個例子：

下圖為word文件的截圖，總共四行，第一行有三種字型

執行程式碼結果如下：

補充：golang go doc 與 godoc 文件生成檢視

Go語言專案十分重視程式碼的文件，在軟體設計中，文件對於軟體的可維護和易使用具有重大的影響。因此，文件必須是書寫良好並準確的，與此同時它還需要易於書寫和維護。

Go語言註釋

Go語言中註釋一般分為兩種，分別是單行註釋和多行註釋

單行註釋是以 // 開頭的註釋，可以出現在任何地方。

多行註釋也叫塊註釋，以 /* 開頭，以 */ 結尾，不可以巢狀使用，一般用於包的文件描述或註釋成塊的程式碼片段。

每一個 package 都應該有相關注釋，在 package 語句之前的註釋內容將被預設認為是這個包的文件， package 的註釋應該提供一些相關資訊並對整體功能做簡要的介紹。

在日常開發過程中，可以使用go doc和godoc命令生成程式碼的文件。

go doc

go doc 命令列印Go語言程式實體上的文件。可以使用引數來指定程式實體的識別符號。

Go語言程式實體是指變數、常量、函式、結構體以及介面。

程式實體識別符號就是程式實體的名稱。

go doc 用法

go doc [-u] [-c] [package|[package.]symbol[.methodOrField]]

可用的標識：

示例

輸出指定 package ，指定型別，指定方法的註釋

$ go doc sync.WaitGroup.Add

輸出指定 package ，指定型別的所有程式實體，包括未匯出的

$ go doc -u -all sync.WaitGroup

輸出指定 package 的所有程式實體（非所有詳細註釋）

$ go doc -u sync

godoc

godoc命令主要用於在無法聯網的環境下，以web形式，檢視Go語言標準庫和專案依賴庫的文件。

在 go 1.12 之後的版本中，godoc不再做為go編譯器的一部分存在。依然可以通過go get命令安裝：

go get -u -v golang.org/x/tools/cmd/godoc

國內的安裝方法

mkdir -p $GOPATH/src/golang.org/x
cd $GOPATH/src/golang.org/x
git clone https://github.com/golang/tools.git
cd tools/cmd/godoc
go install 
ls -alh $GOPATH/bin

通過終端檢視文件

go doc命令

$ go doc help

usage: go doc [-u] [-c] [package|[package.]symbol[.method]]

可以看到，go doc接受的引數，可以是包名，也可以是包裡的結構、方法等，預設為顯示當前目錄下的文件。

檢視系統log包資訊

linux@ubuntu:/usr/local/go/src/log$ go doc
package log // import "log"
 
Package log implements a simple logging package. It defines a type,Logger,with methods for formatting output. It also has a predefined 'standard'
Logger accessible through helper functions Print[f|ln],Fatal[f|ln],and
Panic[f|ln],which are easier to use than creating a Logger manually. That
logger writes to standard error and prints the date and time of each logged
message. Every log message is output on a separate line: if the message
being printed does not end in a newline,the logger will add one. The Fatal
functions call os.Exit(1) after writing the log message. The Panic functions
call panic after writing the log message.
 
const Ldate = 1 << iota ...
func Fatal(v ...interface{})
func Fatalf(format string,v ...interface{})
func Fatalln(v ...interface{})
func Flags() int
func Output(calldepth int,s string) error
func Panic(v ...interface{})
func Panicf(format string,v ...interface{})
func Panicln(v ...interface{})
func Prefix() string
func Print(v ...interface{})
func Printf(format string,v ...interface{})
func Println(v ...interface{})
func SetFlags(flag int)
func SetOutput(w io.Writer)
func SetPrefix(prefix string)
type Logger struct{ ... }
 func New(out io.Writer,prefix string,flag int) *Logger

列出當前包中方法、結構、常量等

檢視系統log包中Fatal方法

linux@ubuntu:/usr/local/go/src/log$ go doc log.Fatal
func Fatal(v ...interface{})
 Fatal is equivalent to Print() followed by a call to os.Exit(1).

列出當前函式和註釋說明

檢視系統log包中Logger結構

linux@ubuntu:/usr/local/go/src/log$ go doc Logger
type Logger struct {
  // Has unexported fields.
}
 A Logger represents an active logging object that generates lines of output
 to an io.Writer. Each logging operation makes a single call to the Writer's
 Write method. A Logger can be used simultaneously from multiple goroutines;
 it guarantees to serialize access to the Writer.
func New(out io.Writer,flag int) *Logger
func (l *Logger) Fatal(v ...interface{})
func (l *Logger) Fatalf(format string,v ...interface{})
func (l *Logger) Fatalln(v ...interface{})
func (l *Logger) Flags() int
func (l *Logger) Output(calldepth int,s string) error
func (l *Logger) Panic(v ...interface{})
func (l *Logger) Panicf(format string,v ...interface{})
func (l *Logger) Panicln(v ...interface{})
func (l *Logger) Prefix() string
func (l *Logger) Print(v ...interface{})
func (l *Logger) Printf(format string,v ...interface{})
func (l *Logger) Println(v ...interface{})
func (l *Logger) SetFlags(flag int)
func (l *Logger) SetOutput(w io.Writer)
func (l *Logger) SetPrefix(prefix string)

列出Logger結構定義以及Logger結構操作的方法集

通過網頁檢視文件

godoc命令

$ godoc -http=:6060

godoc會監聽6060埠，通過網頁訪問 http://127.0.0.1:6060，godoc基於GOROOT和GOPATH路徑下的程式碼生成文件的。開啟首頁如下，我們自己專案工程文件和通過go get的程式碼文件都在Packages中的Third party裡面。

編寫自己的文件

1、設計介面函式程式碼

建立documents/calc.go檔案

/*
簡易計算器計算自定義包
 */
package documents
 
// 一種實現兩個整數相加的函式，
// 返回值為兩整數相加之和
func Add(a,b int) int {
 return a + b
}
 
// 一種實現兩個整數相減的函式，
// 返回值為兩整數相減之差
func Sub(a,b int) int {
 return a - b
}
 
// 一種實現兩個整數相乘的函式，
// 返回值為兩整數相乘之積
func Mul(a,b int) int {
 return a * b
}
 
// 一種實現兩個整數相除的函式，
// 返回值為兩整數相除之商
func Div(a,b int) int {
 if b == 0 {
  panic("divide by zero")
 } 
 return a / b
}

2、設計Example示例程式碼

建立documents/calc_test.go檔案，給calc.go中每個函式編寫Example函式

package documents 
import (
 "fmt"
)
 
func ExampleAdd() {
 result := Add(4,2)
 fmt.Println("4 + 2 =",result)
 
 // Output:
 // 4 + 2 = 6
}
 
func ExampleSub() {
 result := Sub(4,2)
 fmt.Println("4 - 2 =",result)
 
 // Output:
 // 4 - 2 = 2
}
 
func ExampleMul() {
 result := Mul(4,2)
 fmt.Println("4 * 2 =",result)
 
 // Output:
 // 4 * 2 = 8
}
 
func ExampleDiv() {
 result := Div(4,2)
 fmt.Println("4 / 2 =",result)
 
 // Output:
 // 4 / 2 = 2
}

3、網頁檢視文件

注意以上兩個檔案必須在$GOPATH/src路徑下，使用godoc命令建立文件，用網頁開啟顯示如下

編寫文件規則

1、文件中顯示的詳細主體內容，大多是由使用者註釋部分提供，註釋的方式有兩種，單行註釋"//"和程式碼塊"/* */"註釋。

2、在原始碼檔案中，在package語句前做註釋，在文件中看到的就是Overview部分， 注意：此註釋必須緊挨package語句前一行，要作為Overview部分的，註釋塊中間不能有空行。

3、在函式、結構、變數等前做註釋的，在文件中看到的就是該項詳細描述。註釋規則同上。

4、編寫的Example程式，函式名必須以Example為字首，可將測試的輸出結果放在在函式尾部，以"// Output:"另起一行，然後將輸出內容註釋，並追加在後面。

以上為個人經驗，希望能給大家一個參考，也希望大家多多支援我們。如有錯誤或未考慮完全的地方，望不吝賜教。