随笔

记录一些在写代码看书中得到的小细节


-------- Code 0 --------

// 本来向研究 os/exec 包的，结果反过来研究 reflect 包了
// 注意，
//	结构体字段的名字，属于结构体类型的定义
//	结构体字段的值，属于结构体值的定义
//	不可以直接对非导出字段的 reflect.Value 值使用 Interface()
//	但可以对非导出字段的 reflect.Value 值使用 reflect.ValueOf() 后再使用 Interface()
//	若要处理一个指针指向的对象的 reflect.Type 和 reflect.Value 请对两者都取 Elem()


package main

import (
	"fmt"
	"os"
	"os/exec"
	"reflect"
)

func PokeStruct(o interface{}) {
	refT := reflect.TypeOf(o)
	refV := reflect.ValueOf(o)
	if strings.Contains(refT.String(), "*") {
		fmt.Println("Indirect pointer to struct")
		refT = refT.Elem()
		refV = refV.Elem()
	}
	fmt.Printf("Struct Type Name: %v\n", refT.String())
	for i := 0; i < refV.NumField(); i++ {
		refF := refT.Field(i)
		refFN := refF.Name
		refFT := refF.Type.String()
		refFV := reflect.ValueOf(refV.Field(i)).Interface()
		fmt.Printf(
			"Field %d\n"+
				"\tname:  %v\n"+
				"\ttype:  %v\n"+
				"\tvalue: %v\n",
			i, refFN, refFT, refFV)
	}
}

func main() {
	p, e := exec.LookPath("cmd")
	if e != nil {
		panic(e)
	}

	cmd := new(exec.Cmd)
	cmd.Path = p
	cmd.Args = []string{"/c", "echo", "Hello! World!"}
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	PokeStruct(*cmd)

	cmd.Start()
	cmd.Wait()
}


-------- Code 1 --------

// 有关 非 unicode 字编码与 unicode 字符编码的转换
// go get golang.org/x/text/
// golang.org/x/text/transform 包提供转换工具
// golang.org/x/text/encoding/<blahblah> 包提供编码表

package main

import (
	"fmt"
	"os/exec"

	"golang.org/x/text/encoding/simplifiedchinese"
	"golang.org/x/text/transform"
)

func main() {
	cmd1 := exec.Command("cmd", "/c", "echo", "Hello!")
	buf, _ := cmd1.CombinedOutput()
	utf8, _, _ := transform.Bytes(simplifiedchinese.GBK.NewDecoder(), buf)
	fmt.Printf("%v\n", string(utf8))
}


-------- Code 2 --------

// 在 Linux 下，子进程的 Stdin Stdout 和 Stderr 是不会连接当前进程的 os.Stdin os.Stdout os.Stderr 的
// 也就是说，需要手动指定 exec.Cmd 的 Stdin Stdout 与 Stderr 属性值为 os.Stdin os.Stdout os.Stderr
//
// 最后，命令行参数 exec.Cmd.Args 遵循 [<程序名>,<参数标签1>,<参数1>,<参数标签2>,<参数2>...] 的分类标准
// 在下面的程序中 由于 echo Hello world 都是 -c 同一个参数，所以不能分为两组写入

package main

import (
	"os"
	"os/exec"
)

func main() {
	cmd := exec.Command("bash", "-c", "echo Hello world")
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Run()
}


-------- Code 3 --------

// 对于如 序数/月份/星期 等等的数据，如何进行
// 类型定制
// 标准格式化

// <1> 新建类型，类型依托在现有类型上
// <2> 设置全局常量，常量本身为新建的类型
// <3> 维护 新建类型的数据的字符串化表示
// <4> String 方法的设置

package main

import (
	"fmt"
	"os"
	"os/signal"
	"time"
)

type Ordinal int

const (
	Zeroth Ordinal = iota
	First
	Second
	Third
	Fourth
	Fifth
	Sixth
	Seventh
	Eighth
	Nineth
	Tenth
)

var ordinals = [...]string{
	"Zeroth",
	"First",
	"Second",
	"Third",
	"Fourth",
	"Fifth",
	"Sixth",
	"Seventh",
	"Eighth",
	"Nineth",
	"Tenth",
}

func (n Ordinal) String() string {
	if Zeroth <= n && n <= Tenth {
		return ordinals[n]
	}
	panic("ordinal out of range")
}

func main() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	i := 0
	for {
		s := <-c
		i++
		fmt.Printf("Got signal: %v, %s time\n", s, ordinals[i])
		if i > 6 {
			break
		}
	}
	fmt.Println("Program now will exit")
	time.Sleep(time.Millisecond * 500)
}


-------- Code 4 --------

// 有关 os.Stdin /dev/pts/* 和 bufio 的一些想法

// 下面的代码测试了用 bufio.NewReaderSize 函数包裹 os.Stdin，用另一个 pts 接受统计数据的方法，测试 bufio 所提供的缓存的效果
// 在测试过程中发现了一些有趣的现象
// <1> 对于 /dev/pts/* 设备，也就是虚拟终端机，它们自带缓存，每次提交缓存中的数据的命令是 Enter 键
// <2> /dev/pts/* 设备是不需要 root 也可以打开的
// <3> 即便底层为 os.Stdin 的 bufio.Reader 被充满，也不会报错，至是 br.Buffered() 的数值会被重写，数据依然会留存在 os.Stdin 的区域中
// 这个特性应该是 bufio.NewReaderSize 在底层 buffer 大小大于其自身指定的时候，返回了底层的 Reader 导致的


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"time"
)

func main() {
	// os.Stdin 所在的设备为 /dev/pts/1
	br := bufio.NewReaderSize(os.Stdin, 20)
	// 手动开启 /dev/pts/0 设备文件
	f, e := os.OpenFile("/dev/pts/0", os.O_WRONLY, 0600)
	defer f.Close()
	if e != nil {
		panic(e)
	}

	// 启动新的 goroutine 防止阻塞
	// 每两秒输出一次 br 缓存的数据量
	go func() {
		f.Write([]byte("\n"))
		for {
			time.Sleep(time.Second * 2)
			s := []byte(strconv.Itoa(br.Buffered()) + "\n")
			// 不要对 /dev/pts/0 这个设备使用 WriteString 方法
			f.Write(s)
		}
	}()

	// 用逗号作为间隔符，以检测回车的作用
	fmt.Println(br.ReadString(','))
}