网络和流

    所有 Julia stream 都暴露了 和 write 方法，将 stream 作为它们的第一个参数，如：

    注意， 返回 11，字节数（）写入 stdout，但是返回值使用 ; 抑制。

    这里按了两次回车，以便 Julia 能够读取到换行符。正如你在这个例子中所看到的， 以待写入的数据作为其第二个参数，而 read 以待读取的数据的类型作为其第二个参数。

    例如，为了读取一个简单的字节数组，我们可以这样做：

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

    但是，因为这有些繁琐，所以提供了几个方便的方法。例如，我们可以把上面的代码编写为：

    1. julia> read(stdin, 4)
    2. abcd
    3. 4-element Array{UInt8,1}:
    4.  0x61
    5.  0x62
    6.  0x63
    7.  0x64

    或者如果我们想要读取一整行：

    1. julia> readline(stdin)
    2. abcd
    3. "abcd"

    请注意，根据你的终端设置，你的 TTY 可能是行缓冲的，因此在数据发送给 Julia 前可能需要额外的回车。

    若要读取 的每一行，可以使用 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

    请注意，上面提到的 write 方法对二进制流进行操作。具体来说，值不会转换为任何规范的文本表示形式，而是按原样输出：

    1. julia> write(stdout, 0x61);  # suppress return value 1 with ;
    2. a

    对于文本 I/O，请根据需要使用 或 show 方法（有关这两个方法之间的差异的详细讨论，请参阅它们的文档）：

    有关如何实现自定义类型的显示方法的更多信息，请参阅 。

    有时，IO 输出可受益于将上下文信息传递到 show 方法的能力。IOContext 对象提供了将任意元数据与 IO 对象相关联的框架。例如，:compact => true 向 IO 对象添加一个参数来提示调用的 show 方法应该打印一个较短的输出（如果适用）。有关常用属性的列表，请参阅 文档。

    和其他环境一样，Julia 有 open 函数，它接收文件名并返回一个 对象，你可以用该对象来对文件进行读取和写入。例如，如果我们有文件 hello.txt，其内容为 Hello, World!：

    1. IOStream(<file hello.txt>)
    3. julia> readlines(f)
    4. 1-element Array{String,1}:

    若要写入文件，则可以带着 write（"w"）标志来打开它：

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

    你如果在此刻检查 hello.txt 的内容，会注意到它是空的；改动实际上还没有写入到磁盘中。这是因为 IOStream 必须在写入实际刷新到磁盘前关闭：

    1. julia> close(f)

    再次检查 hello.txt 将显示其内容已被更改。

    打开文件，对其内容执行一些操作，并再次关闭它是一种非常常见的模式。为了使这更容易，open 还有另一种调用方式，它以一个函数作为其第一个参数，以文件名作为其第二个参数，以该文件为参数调用该函数，然后再次关闭它。例如，给定函数：

    1. function read_and_capitalize(f::IOStream)
    2.     return uppercase(read(f, String))
    3. end

    可以调用：

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

    来打开 hello.txt，对它调用 read_and_capitalize，关闭 hello.txt 并返回大写的内容。

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

    让我们直接进入一个 TCP 套接字相关的简单示例。此功能位于名为 Sockets 的标准库中。让我们先创建一个简单的服务器：

    对于那些熟悉 Unix 套接字 API 的人，这些方法名称会让人感觉很熟悉，可是它们的用法比原始的 Unix 套接字 API 要简单些。在本例中，首次调用 会创建一个服务器，等待传入指定端口（2000）的连接。

    1. julia> listen(2000) # 监听（IPv4 下的）localhost:2000
    2. Sockets.TCPServer(active)
    4. julia> listen(ip"127.0.0.1",2000) # 等价于第一个
    5. Sockets.TCPServer(active)
    7. julia> listen(ip"::1",2000) # 监听（IPv6 下的）localhost:2000
    8. Sockets.TCPServer(active)
    10. julia> listen(IPv4(0),2001) # 监听所有 IPv4 接口的端口 2001
    11. Sockets.TCPServer(active)
    13. julia> listen(IPv6(0),2001) # 监听所有 IPv6 接口的端口 2001
    14. Sockets.TCPServer(active)
    16. julia> listen("testsocket") # 监听 UNIX 域套接字
    17. Sockets.PipeServer(active)
    19. julia> listen("\\\\.\\pipe\\testsocket") # 监听 Windows 命名管道
    20. Sockets.PipeServer(active)

    请注意，最后一次调用返回的类型是不同的。这是因为此服务器不监听 TCP，而是监听命名管道（Windows）或 UNIX 域套接字。还请注意 Windows 命名管道格式必须具有特定的模式，即名称前缀（\\.\pipe\），以便唯一标识文件类型。TCP 和命名管道或 UNIX 域套接字之间的区别是微妙的，这与 和 connect 方法有关。 方法检索到连接到我们刚创建的服务器的客户端的连接，而 connect 函数使用指定的方法连接到服务器。 函数接收与 listen 相同的参数，因此，假设环境（即 host、cwd 等）相同，你应该能够将相同的参数传递给 ，就像你在监听建立连接时所做的那样。那么让我们尝试一下（在创建上面的服务器之后）：

    1. TCPSocket(open, 0 bytes waiting)
    3. julia> Hello World

    不出所料，我们看到「Hello World」被打印出来。那么，让我们分析一下幕后发生的事情。在我们调用 connect 时，我们连接到刚刚创建的服务器。与此同时，accept 函数返回到新创建的套接字的服务器端连接，并打印「Hello World」来表明连接成功。

    Julia 的强大优势在于，即使 I/O 实际上是异步发生的，API 也以同步方式暴露，我们不必担心回调，甚至不必确保服务器能够运行。在我们调用 时，当前任务等待建立连接，并在这之后才继续执行。在此暂停中，服务器任务恢复执行（因为现在有一个连接请求是可用的），接受该连接，打印信息并等待下一个客户端。读取和写入以同样的方式运行。为了理解这一点，请考虑以下简单的 echo 服务器：

    1. julia> errormonitor(@async begin
    2.            server = listen(2001)
    3.            while true
    4.                sock = accept(server)
    5.                @async while isopen(sock)
    6.                    write(sock, readline(sock, keep=true))
    7.                end
    8.            end
    9.        end)
    10. Task (runnable) @0x00007fd31dc12e60
    12. julia> clientside = connect(2001)
    13. TCPSocket(RawFD(28) open, 0 bytes waiting)
    15. julia> errormonitor(@async while isopen(clientside)
    16.            write(stdout, readline(clientside, keep=true))
    17.        end)
    18. Task (runnable) @0x00007fd31dc11870
    20. julia> println(clientside,"Hello World from the Echo Server")
    21. Hello World from the Echo Server

    与其他流一样，使用 close 即可断开该套接字：

    1. julia> close(clientside)

    解析 IP 地址

    与 方法不一致的 connect 方法之一是 connect(host::String,port)，它将尝试连接到由 host 参数给定的主机上的由 port 参数给定的端口。它允许你执行以下操作：

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

    此功能的基础是 ，它将执行适当的地址解析：

    1. julia> getaddrinfo("google.com")
    2. ip"74.125.226.225"

    Base.read 和 的所有 I/O 操作都可以通过使用 coroutines 异步执行。 你可以使用 宏创建一个新的协程来读取或写入流：

    通常会遇到您想要同时执行多个异步操作并等待它们全部完成的情况。你可以使用@ sync宏，这会阻塞你的程序直到它所包裹的所有协程运行完毕。

    1. julia> using Sockets
    3. julia> @sync for hostname in ("google.com", "github.com", "julialang.org")
    4.            @async begin
    5.                conn = connect(hostname, 80)
    6.                write(conn, "GET / HTTP/1.1\r\nHost:$(hostname)\r\n\r\n")
    7.                readline(conn, keep=true)
    8.                println("Finished connection to $(hostname)")
    9.            end
    10.        end
    11. Finished connection to google.com
    12. Finished connection to github.com