课程表

Julia课程

工具箱
速查手册

Julia 网络和流

当前位置：免费教程 » 程序设计 » Julia

Julia 提供了一个丰富的接口处理终端、管道、tcp套接字等等I/O流对象。

接口在系统层的实现是异步的，开发者以同步的方式调用该接口、一般无需关注底层异步实现。 接口实现主要基于Julia支持的协程(coroutine)功能。

基本流 I/O

所有 Julia 流都至少提供一个 read 和一个 write 方法，且第一个参数都是流对象，例如:

  1.     julia> write(STDOUT,"Hello World")
  2.     Hello World
  4.     julia> read(STDIN,Char)
  6.     '\n'

注意我又输入了一次回车，这样 Julia 会读入换行符。现在，由例子可见，write 方法的第二个参数是将要写入的数据，read 方法的第二个参数是即将读入的数据类型。例如，要读入一个简单的字节数组，我们可以:

  1.     julia> x = zeros(Uint8,4)
  2.     4-element Uint8 Array:
  3.      0x00
  4.      0x00
  5.      0x00
  6.      0x00
  8.     julia> read(STDIN,x)
  9.     abcd 
  10.     4-element Uint8 Array:
  11.      0x61
  12.      0x62
  13.      0x63
  14.      0x64

不过像上面这么写有点麻烦，还提供了一些简化的方法。例如，我们可以将上例重写成:

  1.     julia> readbytes(STDIN,4)
  2.     abcd 
  3.     4-element Uint8 Array:
  4.      0x61
  5.      0x62
  6.      0x63
  7.      0x64

或者直接读入整行数据:

  1.     julia> readline(STDIN)
  2.     abcd
  3.     "abcd\n"

注意这取决于你的终端配置，你的 TTY 可能是行缓冲、需要多输入一个回车才会把数据传给 julia。

如果你想要通过 STDIN 去读每一行，你可以使用 eachline 方法：

  1.     for line in eachline(STDIN)
  2.         print("Found $line")
  3.     end

或者如果你想要以字符为单位去读，则如下：

  1.     while !eof(STDIN)
  2.         x = read(STDIN, Char)
  3.         println("Found: $x")
  4.     end

文本 I/O

注意上面提到的写方法是对二进制流进行操作的。特别是，值不会被转换成任何规范的文本表示，而是会被写成如下：

  1.     julia> write(STDOUT,0x61)
  2.     a

对于文本 I/O，可以使用 print 或 show 方法，这取决你的需求（可以查看标准库中对于两者不同之处的细节描述）：

  1.     julia> print(STDOUT,0x61)
  2.     97

使用文件

像其他的环境一样，Julia 有一个开放的函数，它以一个文件名作为参数并且返回一个 IO 流对象，通过这个 IO 流，你可以从文件中读或者写其中的内容。举个例子来说，如果我们有一个文件，hello.txt，它的内容为 “Hello, World!”:

  1.     julia> f = open("hello.txt")
  2.     IOStream(<file hello.txt>)
  4.     julia> readlines(f)
  5.     1-element Array{Union(ASCIIString,UTF8String),1}:
  6.      "Hello, World!\n"

如果你想要写入某些内容到文件当中，你可以用写标志 (“w”) 打开它：

  1.     julia> f = open("hello.txt","w")
  2.     IOStream(<file hello.txt>)
  4.     julia> write(f,"Hello again.")
  5.     12

如果你用这种方式检查 hello.txt 的内容，你将会注意到它是空的；其实没有任何东西被写入磁盘。这是因为 IO 流在数据真正写到磁盘之前必须被关掉：

  1.     julia> close(f)

再次检查 hello.txt 将会显示它的内容已经被改变了。

打开一个文件，对它的内容做一些改变，然后关闭它是一个常见的模式。为了让这个过程更简单，这里存在另一个 open 的调用，用一个方法作为其第一个参数，用文件名作为他的第二个参数，打开文件，调用该文件的方法作为一个参数，然后再次关闭它。举一个例子，给出一个方法：

  1.     function read_and_capitalize(f::IOStream)
  2.         return uppercase(readall(f))
  3.     end

你可以调用：

  1.     julia> open(read_and_capitalize, "hello.txt")
  2.     "HELLO AGAIN."

为了打开 hello.txt，调用它的 read_and_capitalize 方法，关闭 hello.txt 然后返回大写的内容。

为了避免去定义一个已经命名的函数，你可以使用 do 语法，动态的去创建一个匿名函数：

  1.     julia> open("hello.txt") do f
  2.               uppercase(readall(f))
  3.            end
  4.     "HELLO AGAIN."

简单的 TCP 例子

让我们直接用一个简单的 Tcp Sockets 的示例来说明。我们首先需要创建一个简单地服务器：

  1.     julia> @async begin
  2.              server = listen(2000)
  3.              while true
  4.                sock = accept(server)
  5.                println("Hello World\n")
  6.              end
  7.            end
  8.     Task
  10.     julia>

那些熟悉 Unix socket API 的人，会觉得方法名和 Unix socket 很相似，尽管他们的用法比原生 Unix socket API 要简单。第一次调用 listen 将会创建一个服务器来等待即将到来的连接，在这个案例中监听的端口为 2000。相同的方法可能会用来去创建不同的其他种类的服务器：

  1.     julia> listen(2000) # Listens on localhost:2000 (IPv4)
  2.     TcpServer(active)
  4.     julia> listen(ip"127.0.0.1",2000) # Equivalent to the first
  5.     TcpServer(active)
  7.     julia> listen(ip"::1",2000) # Listens on localhost:2000 (IPv6)
  8.     TcpServer(active)
  10.     julia> listen(IPv4(0),2001) # Listens on port 2001 on all IPv4 interfaces
  11.     TcpServer(active)
  13.     julia> listen(IPv6(0),2001) # Listens on port 2001 on all IPv6 interfaces
  14.     TcpServer(active)
  16.     julia> listen("testsocket") # Listens on a domain socket/named pipe
  17.     PipeServer(active)

注意最后一次调用的返回值类型是不同的。这是因为这个服务器没有监听 TCP，而是在一个命名管道（Windows 术语）- 同样也称为域套接字（UNIX 的术语）。他们的不同之处非常微小，并且与他们的接收和连接方法有关系。接受方法会检索一个到客户端的连接，连接到我们刚刚创建的服务器端，而连接到服务器的函数使用的是特定的方法。连接方法和监听方法的参数是一样的，所以使用的环境（比如主机，cwd 等等）能够传递和监听方法相同的参数来建立一个连接。所以让我们来尝试一下（前提是已经创建好上面的服务器）：

  1.     julia> connect(2000)
  2.     TcpSocket(open, 0 bytes waiting)
  4.     julia> Hello World

正如我们预期的那样，我们会看到 “Hello World” 被打印出来了。所以我让我们分析一下在后台发生了什么。当我们调用连接函数时，我们连接到了我们刚刚创建的服务器。同时，接收方法返回一个服务器端的连接到最新创建的套接字上，然后打印 “Hello World” 来表明连接成功了。

Julia 的一个强大功能是尽管 I/O 实际上是异步发生的，但 API 仍然是同步的，我们甚至不必担心回调或服务器是否继续正常运行。当我们调用连接时，当前任务会等待连接建立，并且在连接建立之后，当前任务才会继续执行。在暂停期间，服务器任务会恢复执行（因为现在一个连接请求可用），接受这个连接，打印出信息并且等待下一个客户端。读和写的工作是相同的。为了更好地理解，请看以下一个简单的 echo 服务器：

  1.     julia> @async begin
  2.              server = listen(2001)
  3.              while true
  4.                sock = accept(server)
  5.                @async while true
  6.                  write(sock,readline(sock))
  7.                end
  8.              end
  9.            end
  10.     Task
  12.     julia> clientside=connect(2001)
  13.     TcpSocket(open, 0 bytes waiting)
  15.     julia> @async while true
  16.               write(STDOUT,readline(clientside))
  17.            end
  19.     julia> println(clientside,"Hello World from the Echo Server")
  21.     julia> Hello World from the Echo Server

解析 IP 地址

一种不伴随监听方法的 connect 函数为 connect(host::ASCIIString,port),它会尝试去连接到主机端口参数给出的端口提供的主机参数给出的主机。它允许你如下操作：

  1.     julia> connect("google.com",80)
  2.     TcpSocket(open, 0 bytes waiting)

这个功能的基础是 getaddrinfo 方法，将提供适当的地址解析:

  1.     julia> getaddrinfo("google.com")
  2.     IPv4(74.125.226.225)
转载本站内容时，请务必注明来自W3xue，违者必究。
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
皖ICP备17017327号-2　皖公网安备34020702000426号