Nim中文件IO

打开文件模式：

fileMode = enum

fmRead, #打开文件，只读

fmWrite, #打开文件，只写

fmReadWrite, #打开文件，读或写，如果该文件不存在，则创建文件

fmReadWriteExisting, #打开文件，读或写，如果该文件不存在，将不创建文件

fmAppend #打开文件，只写，在最后面添加数据。

读文件

var file:File
file = open(r"E:\Nim\test.txt",fmRead)        #以只读模式打开文件
echo file.readChar()                              #读取一个字符

file.close()

file = open(r"E:\Nim\test.txt")                   #默认为只读模式
echo file.readAll()                               #读取文件所有内容，如果`file`流的位置不在文件的开始处，将会引起IO异常。
file.close()

file = open(r"E:\Nim\test.txt")
echo file.readLine()                              #从文件`f` 读取一行文本。可能抛出一个IO异常。
file.close()

file = open(r"E:\Nim\test.txt")
echo file.getFileSize()                            #返回文件字节数。
file.close()

var file:File
file = open(r"E:\Nim\test1.txt",fmReadWrite)       #打开文件，读或写，如果该文件不存在，则创建文件。如果文件存在，里面的内容会被清空。
echo file.readAll()
file.close()

discard """
file = open(r"E:\Nim\test2.txt",fmReadWriteExisting)   #打开文件，读或写，如果该文件不存在，将不创建文件,抛出异常。
echo file.readAll()
file.close()
"""

直接读取文件所有内容

var filename = r"E:\Nim\test.txt"
var content = readFile(filename)
echo content

##读取一个名为`filename`的文件。
##然后调用 `readAll <#readAll>` 和之后关闭文件。返回字符串。

写文件

var file:File
file = open(r"E:\Nim\write.txt",fmWrite)
file.write(12)
file.close()

echo readFile(r"E:\Nim\write.txt")

file = open(r"E:\Nim\write.txt",fmWrite)       #打开文件，写入的内容覆盖之前的内容。
file.write("Hello Nim")
file.close()

echo readFile(r"E:\Nim\write.txt")

file = open(r"E:\Nim\write.txt",fmAppend)       #打开文件，写入的内容添加到最后面。
file.write("\n")
file.write("How are you")
file.close()

file = open(r"E:\Nim\write.txt",fmAppend)
file.writeln("\n","nn","=",44)                   #变参传入，最后写入'\n'
file.close()

echo readFile(r"E:\Nim\write.txt")

直接写文件

var content:string
var filename = r"E:\Nim\test1.txt"

content = "Hello ,wellcome to china"

writeFile (filename,content)

file.close()

echo readFile(filename)

##把`content`全部写进路径名为filename的文件中，之后关闭文件。

标准输入流

echo("What's your name? ")
var name: string = readLine(stdin)
echo("Hi, ", name, "!")

标准输出流

proc myWriteln(f: File, a: varargs[string, `$`]) =
for s in items(a):
write(f, s)
write(f,"  ")
write(f, "\n")

myWriteln(stdout, 123, "abc", 4.0)

更多的操作过程

proc open*(f: var File, filename: string,

mode: FileMode = fmRead, bufSize: int = -1): bool {.tags: [],

benign.}

##以‘mode’ 模式打开一个文件名 `filename` 的文件

##默认的模式为只读，如果能够打开这个文件将返回 true。

## 如果文件不能打开，不会抛出异常。

proc open*(f: var File, filehandle: FileHandle,

mode: FileMode = fmRead): bool {.tags: [], benign.}

## 以`mode`模式从一个 `filehandle` 创建一个``TFile``

##默认的模式是只读，如果文件能够打开将返回 true。

proc open*(filename: string,

mode: FileMode = fmRead, bufSize: int = -1): File =

## 以`mode`模式打开文件名为`filename`的文件。

##默认的模式为只读。如果文件不能打开将会引起一个``IO`` 异常。

proc reopen*(f: File, filename: string, mode: FileMode = fmRead): bool {.

tags: [], benign.}

## 重新打开名字为`filename`的文件`f`，模式为`mode` 。这个经常被用到重定向 ##`stdin`, `stdout` or `stderr` 文件变量。

##默认的模式为只读， 如果文件能够被重新打开将返回true。

proc close*(f: File) {.importc: "fclose", header: "<stdio.h>", tags: [].}

## 关闭文件。

proc endOfFile*(f: File): bool {.tags: [], benign.}

##如果以`f`结尾，将返回true。

proc readChar*(f: File): char {.

importc: "fgetc", header: "<stdio.h>", tags: [ReadIOEffect].}

##从 `f` 流读取一个字符。

proc flushFile*(f: File) {.

importc: "fflush", header: "<stdio.h>", tags: [WriteIOEffect].}

##刷新缓冲区。

proc readAll*(file: File): TaintedString {.tags: [ReadIOEffect], benign.}

## 从`file`流中读取所有数据。

##如果`file`流的位置不在文件的开始处，这是一个错误，

## 如果出错将引起一个IO异常。

proc readFile*(filename: string): TaintedString {.tags: [ReadIOEffect], benign.}

## 读取一个名为`filename`的文件。

##然后调用 `readAll <#readAll>` 和之后关闭文件。

## 返回字符串。如果出错会引起IO异常。

##你需要在编译时调用这个宏可以使用`staticRead <#staticRead>`_.

proc writeFile*(filename, content: string) {.tags: [WriteIOEffect], benign.}

##去写一个名为`filename`的文件夹。

##然后把`content`全部写进文件中，之后关闭文件。

##如果出现错误将引起IO异常。

向文件 `f` 写入一个值。可能抛出一个IO异常。

proc write*(f: File, r: float32) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, i: int) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, i: BiggestInt) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, r: BiggestFloat) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, s: string) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, b: bool) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, c: char) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, c: cstring) {.tags: [WriteIOEffect], benign.}

proc write*(f: File, a: varargs[string, `$`]) {.tags: [WriteIOEffect], benign.}

proc readLine*(f: File): TaintedString {.tags: [ReadIOEffect], benign.}

##从文件`f` 读取一行文本。可能抛出一个IO异常。

##一行文本可能被回车、换行或者回车换行界定。

## 换行符不是返回字符串的一部分。

proc readLine*(f: File, line: var TaintedString): bool {.tags: [ReadIOEffect],

benign.}

##从文件 `f` 中读取一行文本到 `line`。`line`不能是``nil``! 可能抛出一个IO异常。

##一行文本可能被回车、换行或者回车换行界定。换行符不是返回字符串的一部分。

##如果已经到达文件结尾，将返回``false``，否则返回 ``true``。

##如果false被返回，则`line`没有包含新数据。

proc writeln*[Ty](f: File, x: varargs[Ty, `$`]) {.inline,

tags: [WriteIOEffect], benign.}

## 写`x`值到文件`f`,然后写入"\n"。可能抛出一个IO异常。

proc getFileSize*(f: File): int64 {.tags: [ReadIOEffect], benign.}

## 检索文件`f`的大小（以字节为单位）。

proc readBytes*(f: File, a: var openArray[int8|uint8], start, len: Natural): int {.

tags: [ReadIOEffect], benign.}

## Natural* = range[0..high(int)]

##读取`len`字节到 `a` 缓冲区，从 ``a[start]``开始。

## 返回实际读取的字节数，它可能比`len`小（如果没有尽可能多的剩余字节），但是##不会比它大。

proc readChars*(f: File, a: var openArray[char], start, len: Natural): int {.

tags: [ReadIOEffect], benign.}

## Natural* = range[0..high(int)]

##读取`len`字节到 `a` 缓冲区，从 ``a[start]``开始。

## 返回实际读取的字节数，它可能比`len`小（如果没有尽可能多的剩余字节），但是##不会比它大。

proc readBuffer*(f: File, buffer: pointer, len: Natural): int {.

tags: [ReadIOEffect], benign.}

##pointer* {.magic: Pointer.} 内置的指针类型，使用 addr 操作符可以得到一个指针变量

##读取`len`字节到`buffer`指定的缓冲区。

## 返回实际读取的字节数，它可能比`len`小（如果没有尽可能多的剩余字节），但是不会##比它大。

proc writeBytes*(f: File, a: openArray[int8|uint8], start, len: Natural): int {.

tags: [WriteIOEffect], benign.}

##写入 ``a[start..start+len-1]`` 字节到文件`f`。

##返回实际写入的字节数，如果出错它可能小于`len`。

proc writeChars*(f: File, a: openArray[char], start, len: Natural): int {.

tags: [WriteIOEffect], benign.}

##写入 ``a[start..start+len-1]`` 字节到文件`f`。

##返回实际写入的字节数，如果出错它可能小于`len`。

proc writeBuffer*(f: File, buffer: pointer, len: Natural): int {.

tags: [WriteIOEffect], benign.}

##pointer* {.magic: Pointer.} 内置的指针类型，使用addr操作符可以得到一个指针变量。

##把参数 `buffer` 指向的缓冲区中`len`字节写到文件`f`中。

## 返回实际写入的字节数，如果出现错误它可能比`len`小。

proc setFilePos*(f: File, pos: int64) {.benign.}

##设置用于读/写操作的文件指针的位置。

## 文件的第一个字节的索引为0。

proc getFilePos*(f: File): int64 {.benign.}

##检索用于读取文件`f`的指针的当前位置。

##文件的第一个字节的索引为0。

proc getFileHandle*(f: File): FileHandle {.importc: "fileno",header: "<stdio.h>"}

##返回文件`f` 的操作系统文件句柄，这个仅仅对特定的编程平台有用。