golang 解析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()
 }
}

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

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

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).

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, prefix string, 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)

/*
简易计算器计算自定义包
 */
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
}

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
}