go语言基础 seek光标位置os包的使用

语法：

os.open()-->*file,err *****

file.seek(offset, whence)，设置光标的未知

offset,偏移量

whence，从哪开始：0从头，1当前，2末尾

package main
import (
   "os"
   "fmt"
)
func main()  {
   /*
   seek(offset int, whence int),表示设置光标的位置
      offset int，设置多少个字节
   whence int，从哪开始
      0，距离文件开头
      1，当前的位置
      2，距离文件末尾
    */
    //file,_:= os.open("c:\\liu\\pro\\aa.txt") //rdonly
    file,_:=os.openfile("c:\\liu\\pro\\aa.txt",os.o_rdwr,0)
    //1.打开文件后，光标默认在文件开头。
    bs := make([] byte, 1)
    defer file.close()
    //2.seek()
    //设置光标的位置在：距离文件开头，4个字节处。
    //file.seek(8,0)
    count, _:= file.read(bs)
   fmt.println(string(bs[:count])) //a
    file.seek(4,2)
   //count, _= file.read(bs)
   //fmt.println(string(bs[:count])) //
   file.write([]byte{65,66,67})
   fmt.println("写完了。。")
}

补充：go语言-命令行参数（os.args, flag包）

大部分go程序都是没有ui的，运行在纯命令行的模式下，该干什么全靠运行参数。

这里介绍下go语言命令行程序和他们的参数。

1. os.args

程序获取运行他时给出的参数，可以通过os包来实现。先看代码：

package main
import (
 "fmt"
 "os"
 "strconv"
)
func main () {
 for idx, args := range os.args {
  fmt.println("参数" + strconv.itoa(idx) + ":", args)
 }
}

运行起来得到的如下：

$go run main.go 1 3 -x ?

参数0: /tmp/go-build116558042/command-line-arguments/_obj/exe/main

参数1: 1

参数2: 3

参数3: -x

参数4: ?

可以看到，命令行参数包括了程序路径本身，以及通常意义上的参数。

程序中os.args的类型是 []string ，也就是字符串切片。所以可以在for循环的range中遍历，还可以用 len(os.args) 来获取其数量。

如果不想要输出os.args的第一个值，也就是可执行文件本身的信息，可以修改上述程序：

for idx, args := range os.args[1:] {

将range后面的切片，去掉第一个元素。

输出切片的所有元素，还有更简洁的方式：

fmt.println(strings.join(os.args[1:], "\n"))
fmt.println(os.args[1:])
/*
后一种方式的结果是[1 3 -x ?]，这是fmt.println输出切片的格式
*/

2. flag包

flag包相比单纯的通过os.args切片分析命令行参数，提供了更强的能力。

来看个例子：

package main
import (
	"fmt"
	"flag"
)
var b = flag.bool("b", false, "bool类型参数")
var s = flag.string("s", "", "string类型参数")
func main() {
	flag.parse()
	fmt.println("-b:", *b)
	fmt.println("-s:", *s)
	fmt.println("其他参数：", flag.args())
}
------------------------------------
$ go run main.go
-b: false
-s: 
其他参数： []
------------------------------------
$ go run main.go -b
-b: true
-s: 
其他参数： []
------------------------------------
$ go run main.go -b -s test others
-b: true
-s: test
其他参数： [others]
------------------------------------
$ go run main.go  -help
usage of /tmp/go-build080353851/command-line-arguments/_obj/exe/main:
  -b	bool类型参数
  -s string
    	string类型参数
exit status 2

2.1 定义参数

使用flag包，首先定义待解析命令行参数，也就是以"-"开头的参数，比如这里的 -b -s -help等。-help不需要特别指定，可以自动处理。

这里指定了两个参数，-b和-s：

var b = flag.bool("b", false, "bool类型参数")
var s = flag.string("s", "", "string类型参数")
-----------------
原型：
func bool(name string, value bool, usage string) *bool
func string(name string, value string, usage string) *string

通过flag.bool和flag.string，建立了2个指针b和s，分别指向bool类型和string类型的变量。所以后续要通过 *b 和 *s 使用变量值。

flag.bool和flag.string的参数有3个，分别是命令行参数名称，默认值，提示字符串。

参数	功能
name	命令行参数名称，比如 -b, -help
value	默认值，未显式指定的参数，给出隐式的默认值，比如本例中-b未给出的话，*b=false
usage	提示信息，如果给出的参数不正确或者需要查看帮助 -help，那么会给出这里指定的字符串

2.2 解析参数

flag使用前，必须首先解析：

flag.parse()

2.3 使用参数

上文已经说明，通过flag方法定义好的参数变量指针，通过间接引用操作即可使用其内容：

fmt.println("-b:", *b)
fmt.println("-s:", *s)

2.4 未解析参数

参数中没有能够按照预定义的参数解析的部分，通过flag.args()即可获取，是一个字符串切片。

fmt.println("其他参数：", flag.args())

需要注意的是，从第一个不能解析的参数开始，后面的所有参数都是无法解析的。即使后面的参数中含有预定义的参数：

$ go run main.go -b stop -s test others
-b: true
-s: 
其他参数： [stop -s test others]

上面例子中，解析到stop，就已经无法继续解析了，即使后面给出了预定义好的-s，也是不能获取出来的。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。