scheme I/0 输入输出操做

2.1. open-input-file, read-char, and eof-object?

The function (open-input-file filename) is available to open a file. This function return a port for input. The function (read-char port) is to read a character from the port. As this function returns eof-object when it reaches the end of the file (EOF), you can check it by using eof-object?. The function (close-input-port port) is to close the input port. The [code 1] shows a function that returns file contents as string.

[code 1]

(define (read-file file-name)
  (let ((p (open-input-file file-name)))
    (let loop((ls1 '()) (c (read-char p)))
     (if (eof-object? c)
	  (begin
	    (close-input-port p)
	    (list->string (reverse ls1)))
	  (loop (cons c ls1) (read-char p))))))
为何要reverse，由于cons c ls1 是把先前读取的放在后面，而c放在前面，为何不(cons ls1 c)

#\!)
> (define c (cons 1 2))
> (cons c 3)
'((1 . 2) . 3)

> (cons 3 c)
'(3 1 . 2)

把cons放在car位置上，会有一个（），而放在第二个则没有。

 

For instance, the result shown in [example 1] is obtained by applying the [code 1] to a file [hello.txt]. As the newline character is represented by '\n', it is not easy to read. Function display is available, however, for formatting ([example 2]).

[hello.txt]

Hello world!
Scheme is an elegant programming language.

[example 1]

(cd "C:\\doc")
(read-file "hello.txt")
;Value 14: "Hello world!\nScheme is an elegant programming language.\n"

[example 2]

(display (read-file "hello.txt"))
Hello world!
Scheme is an elegant programming language.
;Unspecified return value

2.2. Syntaxes call-with-input-file and with-input-from-file

You can open a file for input using the syntax call-with-input-file or with-input-from-file. These syntaxes are convenient because they handle errors.

( call-with-input-file  filename  procedure)

It opens a file named  filename for input. The  procedure is a function that takes input port as an argument. The file should be closed explicitly because it is not closed when the control is returned from the  procedure if the input port is potentially used again. The [code 1] can be rewritten like [code 2] using  call-with-input-file.

它打开一个文件来做为输入，接受一个函数（port作为参数）

[code 2]

(define (read-file file-name)
  (call-with-input-file file-name
    (lambda (p)
      (let loop((ls1 '()) (c (read-char p)))
	(if (eof-object? c)
	    (begin
	      (close-input-port p)
	      (list->string (reverse ls1)))
	    (loop (cons c ls1) (read-char p)))))))

( with-input-from-file  filename  procedure) 自动关闭

It opens a file named filename as the standard input. The  procedure is a function with no argument. The file is closed when the control is returned from the  procedure. [code 3] shows the rewritten function of [code 1] using  with-input-from-file.

[code 3]

(define (read-file file-name)
  (with-input-from-file file-name
    (lambda ()
      (let loop((ls1 '()) (c (read-char)))
	(if (eof-object? c)
	    (list->string (reverse ls1))
	    (loop (cons c ls1) (read-char)))))))

2.3. read

The function (read port) reads a S-expression from the port. It is convenient to read contents with parentheses like [paren.txt]. （这个真是为lisp专门设计的。

[paren.txt]

'(Hello world!
Scheme is an elegant programming language.)

'(Lisp is a programming language ready to evolve.)

[code 4]

(define (s-read file-name)
  (with-input-from-file file-name
    (lambda ()
      (let loop ((ls1 '()) (s (read)))
	(if (eof-object? s)
	    (reverse ls1)
	    (loop (cons s ls1) (read)))))))

The following shows the result of reading paren.txt by s-read.

(s-read "paren.txt")
⇒ ((quote (hello world! scheme is an elegant programming language.))
(quote (lisp is a programming language ready to evolve.)))
demo1：

'(hello wrodl)
'(you )
'(can)

输出:'('(hello wrodl) '(you) '(can))

demo2:

(you) (can)

'((you) (can))

demo3:
(you (we)) (can)
输出：'((you (we)) (can))

Exercise 1

Write the function read-lines that returns a list of strings which correspond to each line of file contents. The newline character is represented by#\Linefeed in Scheme. Following is the result of applying this function to the hello.txt.

(read-lines "hello.txt") ⇒ ("Hello world!" "Scheme is an elegant programming language.")

3. Output to files

3.1. Making a Port for output

Similar functions to those for input are available to make output ports.

( open-output-file  filename)

It opens a file for output and returns a output port.

(close-output-port port)

It closes the port for output.

(call-with-output-file filename procedure)

It opens a file named  filename for output and calls  procedure. The function  procedure takes the port as an argument.

(with-output-to-file filename procedure)

It opens a file named  filename as the standard output and calls  procedure. The  procedure is a function with no argument. The file is closed when the control is returned from the  procedure.

3.1. Functions for output

Following functions for output are available. These functions output to the standard output if the port is omitted.

( write  obj  port)

It outputs the  obj to the  port. Strings are enclosed in double quotes and characters are combined with the  #\.

( display  obj  port)

It outputs the  obj to the  port. Strings are  not enclosed in double quotes and characters are  not combined with the  #\.

( newline  port)

It begins a new line.

( write-char  char  port)

It outputs the  char to the  port.

转自： http://www.shido.info/lisp/scheme9_e.html

 

scheme 提供了一些输入输出过程，能够调用它们读取输入端口，写入输出端口，而这些端口<port>能够与控制台<console>、文件<file>或者字符串<string>相关联。

 

1.Reading<读取>

 

scheme 读取<reader>过程有一个可选输入端口参数，默认是当前输入端口<一般是控制台>。

 

读取能够是基于字符、行或者是符号表达式。 在每一次读取过程当中，端口的状态都会更新，以使下一次读取时从已经读过的后面开始。若是一个端口已经读取到结尾，读取过程就返回 end-of-file 或 eof-object 对象，这个对象能够用 eof-object? 函数来判断。

• read-char 过程读取指定端口下一个字符;
• read-line 过程读取指定端口的下一行，返回一个字符串<换行符会自动去掉>;
• read 过程读取指定端口的下一个符号表达式。

2.Writing<写入>

 

scheme 写入过程以一个被写入对象和一个可选输出端口为参数，输出端口默认是当前输出端口<一般为控制台>。

• write-char 过程把一个字符<不带 #\>写入到指定端口；
• write 过程把一个符号表达式以一种 machine-readable 的形式写入指定端口，好比，一个字符串会被双引号括着，而字符会带有 #\；
• display 过程把一个符号表达式以一种 human-readable 的形式写入指定端口，好比，一个字符串不会被双引号括着，而一个字符不会带有 #\。

3.File ports<文件端口>

 

scheme　输入（输出）过程以标准输入（输出）为默认输入（输出）端口，因此当从标准输入（输出）读取（写入）时，不用指定端口，可是若是你想显式的给出端口，能够调用无参数的 current-input-port 和 current-out-port 过程：

?

1 2 3

scheme@(guile-user) > (display 9) 9scheme@(guile-user) > (display 9 (current-output-port)) 9scheme@(guile-user) >

• open-input-file 以一个文件名为参数，返回与这个文件相关联的输入端口，当所给文件不存在时会报错；
• open-output-file 以一个文件名为参数，返回与这个文件相关联的输出端口，当所给文件已存在时会报错。

当对一个端口完成全部操做时，你应当用 close-input-port 和 close-output-port 来关闭它。

 

下面例子中，假设当前文件夹下 hello.txt 文件只含有 hello 一个词：

scheme@(guile-user)> (define i (open-input-file "hello.txt"))
scheme@(guile-user)> (read-char i)
#\h
scheme@(guile-user)> (define j (read i))
scheme@(guile-user)> j
ello
scheme@(guile-user)> (read-char i)
#\newline
scheme@(guile-user)> (read-char i)
#<eof>

下面例子，假设当前文件夹下没有 greeting.txt 文件：

 

1 2 3 4 5 6

scheme@(guile-user) > (define o (open-output-file "greeting.txt" )) scheme@(guile-user) > (display "hello" o) scheme@(guile-user) > (write-char #\space o) scheme@(guile-user) > (display 'world o) scheme@(guile-user) > (newline o) scheme@(guile-user) > (close-output-port o)

此时，在当前文件夹下会有一个 greeting.txt 文件，文件内容为：hello world

 

3.1 Automatic opening and closing of file ports<自动开关文件端口>

 

scheme 中的 call-with-input-file 和 call-with-output-file 过程会为你自动打开一个端口，而且当你再也不用它时会自动关闭它。

 

call-with-input-file 过程以一个文件名和一个过程为参数，而参数过程是以一个端口为参数，而 call-with-input-file 过程的做用就是把与一个文件名相关的端口传给其过程参数，而且当过程参数返回时确保该端口被关闭：

scheme@(guile-user) > (call-with-input-file "hello.txt" ...                     ( lambda (i) ...                        ( let * ((a (read-char i)) ...                               (b (read-char i)) ...                               (c (read-char i))) ...                           ( list a b c)))) (#\h #\e #\l)

call-with-output-file 过程与 call-with-input-file 过程类似，可是其所服务的对象是输出文件。

 

4.String ports<字符串端口>

 

open-input-string 过程使一个字符串与一个端口相关联，而那些读取过程对该端口的操做就是读出字符串中的内容：

scheme@(guile-user) > (define i (open-input-string "hello world" )) scheme@(guile-user) > (read-char i) #\h scheme@(guile-user) > (read i) ello scheme@(guile-user) > (read i) world scheme@(guile-user) > (read i) # < eof >

 

5.Loading file<加载文件>

 

load 过程会在当前模块中顺序执行当前文件夹下给定文件名中全部 scheme 语句。

参考：
http://www.shido.info/lisp/scheme9_e.html

http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-9.html

http://lispor.is-programmer.com/posts/23271.html