Ruby 1.9.3 リファレンスマニュアル > ライブラリ一覧 > socketライブラリ > Socketクラス

class Socket + BasicSocket + IO + Enumerable + File::Constants

クラスの継承リスト: Socket < BasicSocket < IO < Enumerable < File::Constants < Object < Kernel < BasicObject

要約

汎用ソケットクラス。

システムコールレベルから高水準の機能までを提供します。

ソケットオブジェクトを生成する汎用的な方法として Socket.new がありますが、以下のようなより便利なメソッドがあります。

TCP のクライアントソケット Socket.tcp TCPSocket.open
TCP のサーバソケット Socket.tcp_server_loop, Socket.tcp_server_sockets, TCPServer.open
UNIX socket のクライアントソケット Socket.unix UNIXSocket.open
UNIX socket のサーバソケット Socket.unix_server_loop, Socket.unix_server_socket, UNIXServer.open

また、クライアントソケットは Addrinfo#connect で、サーバソケットを Addrinfo#bind や Addrinfo#listen で作ることもできます。

特異メソッド

accept_loop(sockets) {|sock, client_addrinfo| ...} -> ()

sockets でサーバソケットを受け取り、接続を待ち受け、クライアントとの接続が確立するたびにブロックにその接続ソケットを渡し呼び出します。

ブロックの引数はクライアントと接続したソケットオブジェクトと Addrinfo オブジェクトです。

Socket.tcp_server_loop と同様、ブロックは逐次的に呼び出されます。つまりブロックか終了するまで次の接続は accept されません。並列に通信したい場合はスレッドのような並列実行機構を使う必要があります。

[PARAM] sockets:: 待ち受けたいサーバソケットの配列

[SEE_ALSO] Socket.tcp_server_loop, Socket.unix_server_loop,

binread(path, length = nil, offset = 0) -> String | nil

path で指定したファイルを open し、offset の所まで seek し、 length バイト読み込みます。

length を省略するとファイルの末尾まで読み込みます。

ファイルを開くときの mode は "rb:ASCII-8BIT" です。

[SEE_ALSO] IO.read

binwrite(path, string, offset=nil) -> Integer

path で指定されるファイルを開き、string を書き込み、閉じます。

offset を指定するとその位置までシークします。

offset を指定しないと、書き込みの末尾でファイルを切り捨てます。

[PARAM] path:: ファイル名文字列
[PARAM] string:: 書き込む文字列
[PARAM] offset:: 書き込み開始位置

[SEE_ALSO] IO.write

copy_stream(src, dst, copy_length = nil) -> Integer

copy_stream(src, dst, copy_length, src_offset) -> Integer

指定された src から dst へコピーします。コピーしたバイト数を返します。

コピー元の src が IO オブジェクトの場合は、src のオフセットからファイル名の場合はファイルの最初からコピーを開始します。コピー先の dst に関しても同様です。

dst にファイル名を指定し、そのファイルが存在しない場合、ファイルは作成されます。ファイルが存在する場合は長さ 0 に切り詰められます。

src が IO オブジェクトでかつ src_offset が指定されている場合、 src のオフセット(src.pos)は変更されません。

[PARAM] src:: コピー元となる IO オブジェクトかファイル名を指定します。
[PARAM] dst:: コピー先となる IO オブジェクトかファイル名を指定します。
[PARAM] copy_length:: コピーする長さをバイト単位で指定します。最大 copy_length までコピーされます。 nil を指定した場合、コピーする長さに制限はありません。
[PARAM] src_offset:: コピーを始めるオフセットを数値で指定します。

do_not_reverse_lookup -> bool

Socket#do_not_reverse_lookup の Socket オブジェクト生成時のデフォルト値を返します。

この設定は大域的に作用します。

デフォルトは true です。

do_not_reverse_lookup=(bool)

BasicSocket#do_not_reverse_lookup の値を変更します。

[PARAM] bool:: この値が真ならアドレスからホスト名への逆引きを行わなくなります。

例:

require 'socket'

p TCPSocket.new('localhost', 'telnet').addr
TCPSocket.do_not_reverse_lookup = true
p TCPSocket.new('localhost', 'telnet').addr

=> ["AF_INET", 2253, "localhost", "127.0.0.1"]
   ["AF_INET", 2254, "127.0.0.1", "127.0.0.1"]

for_fd(fd) -> BasicSocket

ファイルディスクリプタ fd に対する新しいソケットを生成します。

返り値のクラスはどのクラスの for_fd を呼びだしたかによって決まります。

BasicSocket.for_fd(fd) # BasicSocket のインスタンスを返す
TCPSocket.for_fd(fd) # TCPSocket のインスタンスを返す

[PARAM] fd:: ファイルディスクリプタを指定します。
[RETURN]: 任意のソケットである fd から対応するソケットクラスのインスタンスを作り、それを返します。

new(fd, mode = "r", opt={}) -> IO

for_fd(fd, mode = "r", opt={}) -> IO

open(fd, mode = "r", opt={}) -> IO

open(fd, mode = "r" opt={}) {|io| ... } -> object

オープン済みのファイルディスクリプタ fd に対する新しい IO オブジェクトを生成して返します。

IO.open にブロックが与えられた場合、IO オブジェクトを生成しそれを引数としてブロックを実行します。ブロックの終了とともに fd はクローズされます。ブロックの結果を返します。 IO.new, IO.for_fd はブロックを受け付けません。

オプション引数

このメソッドは以下のオプションを利用できます。

:mode mode引数と同じ意味です
:external_encoding 外部エンコーディング。"-" はデフォルト外部エンコーディングの別名です。
:internal_encoding 内部エンコーディング。"-" はデフォルト内部エンコーディングの別名です。nilなら変換しません。
:encoding "extenc:intenc" の形で外部/内部エンコーディングを指定します。
:textmode 真を渡すと mode の "t" と同じ意味になります。
:binmode 真を渡すと mode の "b" と同じ意味になります。
:autoclose 偽を渡すと close時/GCでのファイナライザ呼出時に fd を close しません。

また、String#encode で説明されている :invalid => :replace などの変換オプションも指定することができます。外部エンコーディングから内部エンコーディングへの変換をするときに用いられます。

[PARAM] fd:: ファイルディスクリプタである整数を指定します。
[PARAM] mode:: Kernel.#open と同じ形式で IO のモードを指定します。File::Constants::RDONLY などの定数(数値)でモードを指定できます。詳細は組み込み関数 Kernel.#open を参照してください。 mode は省略可能で、省略時のデフォルトのモードは、 fcntl(2) で F_GETFL フラグが利用できる環境では第一引数で指定した fd のモードを引き継ぎ、利用できない環境では "r" になります。
[PARAM] opt:: オプション引数
[EXCEPTION] Errno::EXXX:: IO オブジェクトの生成に失敗した場合に発生します。

foreach(path, rs = $/) {|line| ... } -> nil

foreach(path, rs = $/) -> Enumerator

path で指定されたファイルの各行を引数としてブロックを繰り返し実行します。 path のオープンに成功すれば nil を返します。

ブロックが与えられなかった場合は、path で指定されたファイルの各行を繰り返す Enumerator オブジェクトを生成して返します。

テキスト読み込みメソッドとして動作します。 path が空ファイルの場合、何もせずに nil を返します。 Kernel.#open と同様 path の先頭が "|" ならば、"|" に続くコマンドの出力を読み取ります。

[PARAM] path:: ファイル名を表す文字列か "|コマンド名" を指定します。
[PARAM] rs:: 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。
[EXCEPTION] Errno::EXXX:: path のオープンに失敗した場合、発生します。

[SEE_ALSO] $/

getaddrinfo(nodename, servname, family=nil, socktype=nil, protocol=nil, flags=nil) -> Array

[RFC2553]で定義された getaddrinfo() の機能を提供するクラスメソッド。この関数は gethostbyname() や getservbyname() の代わりとして用意されており、 IP のバージョンに依存しないプログラムを書くための標準的な API です。

[PARAM] nodename:: ホスト名を指定します。必須引数です。 (socket/ホスト指定形式を参照)
[PARAM] servname:: サービス名を指定します。必須引数です。 (socket/サービス指定形式を参照)
[PARAM] family:: アドレスファミリー。Socket::Constants::AF_INET など、AF_ で始まる定数を指定します。
[PARAM] socktype:: ソケットタイプ。 Socket::Constants::SOCK_STREAM など、 SOCK_ で始まる定数を指定します。
[PARAM] protocol:: プロトコル。Socket::Constants::IPPROTO_IP など、IPPROTO_ で始まる定数を指定します。
[PARAM] flags:: getaddrinfo(3) の第3引数に指定する addrinfo 構造体の ai_flags メンバに相当する Fixnum。 Socket::AI_PASSIVEなど。
[RETURN]: 7つの要素からなるアドレス情報に関する配列を返します。
[EXCEPTION] SocketError:: getaddrinfo(3)がエラーを返したときに発生する例外です

[SEE_ALSO] Addrinfo#getaddrinfo

アドレス情報について

アドレス情報とは7つの要素からなる次の形の配列です。

第0要素 - アドレスファミリー (String)
第1要素 - ポート番号 (Integer)
第2要素 - ホスト名 (String)
第3要素 - アドレス (String)
第4要素 - アドレスファミリーに対応する Integer
第5要素 - ソケットタイプに対応する Integer
第6要素 - プロトコルに対応する Integer

必須引数について

必須引数の意味は以下の通りです。

nodename - ホスト名 (socket/ホスト指定形式を参照)
servname - サービス名 (socket/サービス指定形式を参照)

省略可能な引数について

残りの引数は省略可能です。

family - アドレスファミリー。 Socket::Constants::AF_INET など、AF_ で始まる定数を指定します。
socktype - ソケットタイプ。 Socket::Constants::SOCK_STREAM など、SOCK_ で始まる定数を指定します。
protocol - プロトコル。 Socket::Constants::IPPROTO_IP など、IPPROTO_ で始まる定数を指定します。
flags - getaddrinfo(3) の第3引数に指定する addrinfo 構造体の ai_flags メンバに相当する Fixnum。 Socket::AI_PASSIVE、 Socket::AI_CANONNAME、 Socket::AI_NUMERICHOST が用意されている場合があります。

定数の意味について

引数に指定できる定数の意味については getaddrinfo(3) を参照して下さい。

使用例

例:

p Socket.getaddrinfo(Socket.gethostname, "ftp")
#=> [["AF_INET", 21, "helium.ruby-lang.org", "210.251.121.214", 2, 1, 6]]

pp Socket.getaddrinfo(Socket.gethostname, nil)
#=> [["AF_INET", 0, "helium.ruby-lang.org", "210.251.121.214", 2, 1, 6],
#    ["AF_INET", 0, "helium.ruby-lang.org", "210.251.121.214", 2, 2, 17],
#    ["AF_INET", 0, "helium.ruby-lang.org", "210.251.121.214", 2, 3, 0]]

gethostbyaddr(host, type = Socket::AF_INET) -> Array

sockaddr 構造体をパックした文字列からホスト情報を返します。ホスト情報の構造は Socket.gethostbyname と同じです。 type には、アドレスタイプ(デフォルトは Socket::AF_INET)を指定します。

[PARAM] host:: ホストを文字列で指定します。
[PARAM] type:: アドレスタイプ(デフォルトはSocket::AF_INET)を指定します。
[EXCEPTION] SocketError:: gethostbyaddr(3) の呼び出しにエラーがあった場合に発生します。

gethostbyname(host) -> Array

ホスト名または IP アドレス(指定方法に関しては socket/ホスト指定形式を参照) からホストの情報を返します。

[PARAM] host:: 文字列でホストを指定します。
[RETURN]: ホスト情報を含んだ４要素の配列を返します。

返り値のホスト情報について

ホスト情報は以下の 4 要素の配列で表現されています。

ホスト名
ホストの別名の配列
ホストのアドレスタイプ (整数定数)
ホストのアドレス

第四要素のホストのアドレスは、各アドレスタイプに対応する C のアドレス構造体を pack した文字列として表現されています。例えばアドレスタイプが AF_INET (定数 2) ならば Socket.unpack_sockaddr_in で unpack できます。

使用例

irb(main):009:0> Socket.gethostbyname("210.251.121.214")
["helium.ruby-lang.org", ["helium"], 2, "\322\373y\326"]

irb(main):009:0> Socket.unpack_sockaddr_in(Socket.gethostbyname("210.251.121.214")[3])[1]
"210.251.121.214"

gethostname -> String

システムの標準のホスト名を取得します。

ホストの別名やアドレスなど他の情報を得るには Socket.getaddrinfo を使ってください。ただし、これは不可能な場合もあります。

例:

p Socket.gethostname   #=> "helium.ruby-lang.org"

getnameinfo(sa, flags = 0) -> Array

[RFC2553] で定義された getnameinfo() の機能を提供するクラスメソッド。 gethostbyaddr() や getservbyport() の代わりとして用意されています。IPのバージョンに依存しないプログラムを書くための標準的なAPIです。

[PARAM] sa:: 文字列か配列を与えます。
[PARAM] flags:: 省略可能な第2引数 flags には getnameinfo(3) の第7番目の引数に指定する flags に相当する Fixnum を与えます。
[RETURN]: 配列を返し、その要素はアドレスとポートを表す文字列です。
[EXCEPTION] SocketError:: getnameinfo(3) がエラーを起こした場合に生じる例外

[SEE_ALSO] Addrinfo#getnameinfo

引数 sa について

引数 sa には文字列か配列を与えます。文字列の場合は sockaddr 構造体のパック文字列を与えます。具体的には BasicSocket#getsockname の値が利用できます。配列を与える場合には、要素が3つの場合と4つの場合があります。

要素が3つの場合: [アドレスファミリー, サービス, ホスト]
要素が4つの場合: [アドレスファミリー, サービス, 任意, アドレスを表す文字列]

アドレスファミリーには Socket::AF_INET 等の定数の他に文字列で "AF_INET" もしくは "AF_INET6" もしくは nil が指定できます。ただしIPv6が使えないようにコンパイルされている場合は "AF_INET6" は無効な指定となります。アドレスファミリーに nil を指定することは Socket::AF_UNSPEC を指定することと等価です。

サービス、ホストの指定に関しては socket/サービス指定形式、 socket/ホスト指定形式を参照してください。

要素が3つの場合でも、ホストにはアドレスを指定できますが、要素が4つの場合には、最後の要素を名前解決しないことが保証されます。

引数flagsについて

省略可能な第2引数 flags には getnameinfo(3) の第7番目の引数に指定する flags に相当する Fixnum を与えます。

引数flagsを構成するための定数として Socket::NI_MAXHOST、 Socket::NI_MAXSERV、 Socket::NI_NOFQDN、 Socket::NI_NUMERICHOST、 Socket::NI_NAMEREQD、 Socket::NI_NUMERICSERV、 Socket::NI_DGRAM が用意されている場合があります。

これらの定数の意味については getnameinfo(3)を参照して下さい。

使用例

Socket.getnameinfo(Socket.sockaddr_in('21','127.0.0.1'))
#=> ["localhost", "ftp"]

Socket.getnameinfo([nil, 21,'127.0.0.1'])
#=> ["localhost", "ftp"]

getservbyname(service, proto = "tcp") -> Fixnum

service, protoに対応するポート番号を返します。protoの省略値は"tcp"です。

[PARAM] service:: サービス名を文字列で指定します。例えば、"ftp", "telnet" が相当します。
[PARAM] proto:: プロトコル名を文字列で指定します。省略値は"tcp" です。
[RETURN]: ポート番号を整数で返します。

getservbyport(port, protocol_name="tcp") -> String

ポート番号に対応するサービスの正式名を返します。

[PARAM] port:: ポート番号
[PARAM] protocol_name:: "tcp" や "udp" などのプロトコル名
[RETURN]: サービスの正式名

Socket.getservbyport(80)         #=> "www"
Socket.getservbyport(514, "tcp") #=> "shell"
Socket.getservbyport(514, "udp") #=> "syslog"

ip_address_list -> [Addrinfo]

ローカルの IP アドレスを配列で返します。

open(domain, type, protocol=0) -> Socket

new(domain, type, protocol=0) -> Socket

新しいソケットを生成します。domain、type、 protocol はインクルードファイルにある定数で指定します。ほとんどの定数は Socket::AF_INET のように Socket クラスの定数として定義されています。domain とtype に関しては、"AF_INET", "SOCK_STREAM" のように文字列でも指定できますが、文字列ですべての機能を指定できる保証はありません。

例えば、IPv4 の TCP ソケットは以下のように生成されます。

s = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)

なお、socket(2) の domain 引数において AF_ と PF_ のどちらの定数を使用するかについては混乱がありますが、 Stevens の「UNIX ネットワークプログラミング第2版 Vol.1」4.2節に述べられているように、現実的にはどちらでも問題なく、また、既存のコーディング習慣として AF_ が用いられることが多いため、ここでは AF_ を使用しています。

[PARAM] domain:: 例えば、<sys/socket.h> のようなインクルードファイルに定義されている定数を指定します。
[PARAM] type:: 例えば、<sys/socket.h> のようなインクルードファイルに定義されている定数を指定します。
[PARAM] protocol:: プロトコルに使用する数値を指定します。

sockaddr_in(port, host) -> String

pack_sockaddr_in(port, host) -> String

指定したアドレスをsocket/ソケットアドレス構造体を pack した文字列で返します。port は、ポート番号を表す Fixnum あるいは、ポート番号、サービス名を表す文字列です。

[PARAM] port:: ポート番号を表す Fixnum あるいは、ポート番号、サービス名を表す文字列を指定します。
[PARAM] host:: ホストを文字列で指定します。
[RETURN]: 指定したアドレスを返します。

例:

require 'socket'
p Socket.sockaddr_in("echo", "localhost")
=> "\002\000\000\a\177\000\000\001\000\000\000\000\000\000\000\000"
p Socket.sockaddr_in("echo", "::1")
=> "\n\000\000\a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000"

sockaddr_un(path) -> String

pack_sockaddr_un(path) -> String

指定したアドレスをsocket/ソケットアドレス構造体を pack した文字列で返します。

[PARAM] path:: パスを文字列で指定します。

例:

require 'socket'
p Socket.sockaddr_un("/tmp/.X11-unix/X0")
=> "\001\000/tmp/.X11-unix/X0\000...."

pair(domain, type, protocol) -> Array

socketpair(domain, type, protocol) -> Array

相互に結合されたソケットのペアを含む2要素の配列を返します。引数の指定は Socket.open と同じです。

[PARAM] domain:: Socket.open を参照してください。
[PARAM] type:: Socket.open を参照してください。
[PARAM] protocol:: Socket.open を参照してください。

[SEE_ALSO] Socket.open

pipe -> [IO]

pipe(ext_enc) -> [IO]

pipe(enc_str, opts={}) -> [IO]

pipe(ext_enc, int_enc, opts={}) -> [IO]

pipe {|read_io, write_io| ... } -> object

pipe(ext_enc) {|read_io, write_io| ... } -> object

pipe(enc_str, opt={}) {|read_io, write_io| ... } -> object

pipe(ext_enc, int_enc, opt={}) {|read_io, write_io| ... } -> object

pipe(2) を実行して、相互につながった2つの IO オブジェクトを要素とする配列を返します。

戻り値の配列は最初の要素が読み込み側で、次の要素が書き込み側です。

ブロックが渡された場合は、そのブロックに2つの IO オブジェクトが渡され、ブロックの返り値がこのメソッドの返り値となります。ブロック終了時に IO オブジェクトがもし close されていないならば close します(close されていてるオブジェクトはそのままです)。

得られる2つの IO オブジェクトのエンコーディングを引数で指定することができます。

[PARAM] enc_str:: 読み込み側の外部エンコーディングを文字列で指定します。文字列がコロンを挟んだ二つのエンコーディング名 "A:B" である場合最初のものが外部エンコーディング、次が内部エンコーディングを意味します。
[PARAM] ext_enc:: 読み込み側の外部エンコーディングを Encoding オブジェクトで指定します。
[PARAM] int_enc:: 読み込み側の内部エンコーディングを Encoding オブジェクトで指定します。
[PARAM] opt:: エンコーディングなどを設定するオプション引数(see IO.new)
[EXCEPTION] Errno::EXXX:: IO オブジェクトの作成に失敗した場合に発生します。

r, w = IO.pipe
p [r, w]            # => [#<IO:0x401b90f8>, #<IO:0x401b7718>]
Thread.new do
  w.puts "foo"
  w.close
end
p r.gets           # => "foo\n"

popen(command, mode = "r", opt={}) -> IO

popen(command, mode = "r", opt={}) {|io| ... } -> object

command をサブプロセスとして実行し、そのプロセスの標準入出力との間にパイプラインを確立します。生成したパイプを IO オブジェクトとして返します。

command が文字列の場合は、シェルを経由して子プロセスを実行します。 command が配列の場合は、シェルを経由せずに子プロセスを実行します。

p io = IO.popen("cat", "r+")  # => #<IO:0x401b75c8>
io.puts "foo"
io.close_write
p io.gets                     # => "foo\n"

ブロックが与えられた場合は生成した IO オブジェクトを引数にブロックを実行し、その結果を返します。ブロックの実行後、生成したパイプは自動的にクローズされます。

p IO.popen("cat", "r+") {|io|
  io.puts "foo"
  io.close_write
  io.gets
}
# => "foo\n"

[PARAM] command:: コマンド名を文字列か配列で指定します。配列が指定された場合には、シェルを経由せずに子プロセスを実行します。
[PARAM] mode:: オープンする IO ポートのモードを指定します。mode の詳細は Kernel.#open 参照して下さい。
[PARAM] opt:: エンコーディングなどを設定するオプション引数(see IO.new)
[EXCEPTION] Errno::EXXX:: パイプ、あるいは子プロセスの生成に失敗した場合に発生します。

popen("-", mode = "r", opt={}) -> IO

popen("-", mode = "r", opt={}) {|io| ... } -> object

第一引数に文字列 "-" が指定された時、fork(2) を行い子プロセスの標準入出力との間にパイプラインを確立します。親プロセスでは IO オブジェクトを返し、子プロセスでは nil を返します。

io = IO.popen("-", "r+")
if io  # parent
  io.puts "foo"
  p io.gets                   # => "child output: foo\n"
  io.close
else   # child
  s = gets
  print "child output: " + s
  exit
end

ブロックを与えられた場合、親プロセスでは生成した IO オブジェクトを引数にブロックを実行し、その結果を返します。ブロックの実行後、生成したパイプは自動的にクローズされます。子プロセスでは nil を引数にブロックを実行し終了します。

p IO.popen("-", "r+") {|io|
  if io   # parent
    io.puts "foo"
    io.gets
  else    # child
    s = gets
    puts "child output: " + s
  end
}
# => "child output: foo\n"

[PARAM] mode:: オープンする IO ポートのモードを指定します。mode の詳細は Kernel.#open 参照して下さい。
[PARAM] opt:: エンコーディングなどを設定するオプション引数(see IO.new)
[EXCEPTION] Errno::EXXX:: パイプ、あるいは子プロセスの生成に失敗した場合に発生します。

read(path, opt = {}) -> String | nil

read(path, length = nil, opt = {}) -> String | nil

read(path, length = nil, offset = 0, opt = {}) -> String | nil

path で指定されたファイルを offset 位置から length バイト分読み込んで返します。

既に EOF に達している場合は nil を返します。ただし、length に nil か 0 が指定されている場合は、空文字列 "" を返します。例えば、IO.read(空ファイル) は "" を返します。

引数 length が指定された場合はバイナリ読み込みメソッド、そうでない場合はテキスト読み込みメソッドとして動作します。

Kernel.#open と同様 path の先頭が "|" ならば、"|" に続くコマンドの出力を読み取ります。

[PARAM] path:: ファイル名を表す文字列か "|コマンド名" を指定します。
[PARAM] length:: 読み込む長さを整数で指定します。nil であるか省略した場合には、EOF まで読み込みます。
[PARAM] offset:: 読み込みを始めるオフセットを整数で指定します。
[PARAM] opt:: ファイル path を open する時に使われるオプションを Hash で指定します。
[EXCEPTION] Errno::EXXX:: path のオープン、offset 位置への設定、ファイルの読み込みに失敗した場合に発生します。
[EXCEPTION] ArgumentError:: length が負の場合に発生します。

引数 opt で有効なキーと値は以下のとおりです。キーはいずれも Symbol オブジェクトです。

:encoding: 読み込んだ文字列のエンコーディングを指定します。読み込む長さを指定した場合はこれは無視されます。
:mode: IO.open のモードを指定します。 "r" で始まる文字列である必要があります。
:open_args: IO.open に渡される引数を配列で指定します。

これらの他、 :external_encoding など IO.open のオプション引数が指定できます。

[SEE_ALSO] IO.binread

例:

IO.read(empty_file)             #=> ""
IO.read(empty_file, 1)          #=> nil
IO.read(one_byte_file, 0, 10)   #=> ""
IO.read(one_byte_file, nil, 10) #=> ""
IO.read(one_byte_file, 1, 10)   #=> nil

readlines(path, rs = $/, opts={})

readlines(path, limit, opts={})

readlines(path, rs, limit, opts={})

path で指定されたファイルを全て読み込んで、その各行を要素としてもつ配列を返します。

Kernel.#open と同様 path の先頭が "|" ならば、"|" に続くコマンドの出力を読み取ります。

テキスト読み込みメソッドとして動作します。

limit で最大読み込みバイト数を指定します。ただしマルチバイト文字が途中で切れないように余分に読み込む場合があります。

opts でファイルを開くときのオプションを指定します。エンコーディングなどを指定できます。 File.open と同様なのでそちらを参照してください。

[PARAM] path:: ファイル名を表す文字列か "|コマンド名" を指定します。
[PARAM] rs:: 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。
[PARAM] limit:: 最大の読み込みバイト数
[PARAM] opts:: ファイルを開くときのオプション引数
[EXCEPTION] Errno::EXXX:: path のオープン、ファイルの読み込みに失敗した場合に発生します。

select(reads, writes = [], excepts = [], timeout = nil) -> [[IO]] | nil

select(2) を実行します。

与えられた入力/出力/例外待ちの IO オブジェクトの中から準備ができたものをそれぞれ配列にして、配列の配列として返します。タイムアウトした時には nil を返します。

Kernel.#select と同じです。

[PARAM] reads:: 入力待ちする IO オブジェクトの配列を渡します。
[PARAM] writes:: 出力待ちする IO オブジェクトの配列を渡します。
[PARAM] excepts:: 例外待ちする IO オブジェクトの配列を渡します。
[PARAM] timeout:: タイムアウトまでの時間を表す数値または nil を指定します。数値で指定したときの単位は秒です。nil を指定した時には IO がどれかひとつレディ状態になるまで待ち続けます。
[EXCEPTION] IOError:: 与えられた IO オブジェクトが閉じられていた時に発生します。
[EXCEPTION] Errno::EXXX:: select(2) に失敗した場合に発生します。

rp, wp = IO.pipe
mesg = "ping "
100.times{
  rs, ws, = IO.select([rp], [wp])
  if r = rs[0]
    ret = r.read(5)
    print ret
    case ret
    when /ping/
      mesg = "pong\n"
    when /pong/
      mesg = "ping "
    end
  end
  if w = ws[0]
    w.write(mesg)
  end
}

sysopen(path, mode = "r", perm = 0666) -> Integer

path で指定されるファイルをオープンし、ファイル記述子を返します。

IO.for_fd などで IO オブジェクトにしない限り、このメソッドでオープンしたファイルをクローズする手段はありません。

[PARAM] path:: ファイル名を表す文字列を指定します。
[PARAM] mode:: モードを文字列か定数の論理和で指定します。Kernel.#open と同じです。
[PARAM] perm:: open(2) の第 3 引数のように、ファイルを生成する場合のファイルのパーミッションを整数で指定します。Kernel.#open と同じです。
[EXCEPTION] Errno::EXXX:: ファイルのオープンに失敗した場合に発生します。

[SEE_ALSO] Kernel.#open

tcp(host, port, local_host=nil, local_port=nil) -> Socket

tcp(host, port, local_host=nil, local_port=nil) {|socket| ... } -> object

TCP/IP で host:port に接続するソケットオブジェクトを作成します。

local_host や local_port を指定した場合、ソケットをそこにバインドします。

ブロックを渡すと、生成したソケットをそのブロックに渡し呼び出します。ブロック終了時にソケットオブジェクトを閉じます。

[PARAM] host:: 接続先のホスト名
[PARAM] port:: 接続先のポート番号
[PARAM] local_host:: 接続元のホスト名
[PARAM] local_port:: 接続元のポート番号
[RETURN]: ブロック付きで呼ばれた場合はブロックが返した値です。ブロックなしで呼ばれた場合はソケットオブジェクトを返します。

Socket.tcp("www.ruby-lang.org", 80) {|sock|
  sock.print "GET / HTTP/1.0\r\nHost: www.ruby-lang.org\r\n\r\n"
  sock.close_write
  puts sock.read
}

tcp_server_loop(port) {|sock,addr| ...} -> ()

tcp_server_loop(host, port) {|sock,addr| ...} -> ()

TCP/IP で host:port で待ち受けるサーバ側のソケットを作成し、新しい接続を受け入れるごとにブロックを呼び出します。

ブロックには新しい接続を表すソケットオブジェクトと、クライアントアドレスを表す Addrinfo オブジェクトが渡されます。

ブロックの実行が終わってもソケットは close されません。アプリケーション側が明示的に close する必要があります。

このメソッドはブロックを逐次的に呼び出します。つまりブロックからリターンするまで次のコネクションを受け入れません。そのため、同時に複数のクライアントと通信したい場合はスレッドのような並列機構を使う必要があります。

サーバのソケットアドレスを決めるために Addrinfo.getaddrinfo が用いられることに注意してください。 Addrinfo.getaddrinfo は複数のアドレスを返す(IPv4 と IPv6 など) 場合があり、その場合その全てが用いられます。つまり IPv4 と IPv6 の両方を待ち受けます。getaddrinfo が 0 個のアドレスを返す場合はエラーになります。1つ以上を返した場合にそれが用いられます。

# 逐次的な echo サーバ
# 一度に一つのクライアントした取り扱えない
Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
  begin
    IO.copy_stream(sock, sock)
  ensure
    sock.close
  end
}

# スレッドを使った echo サーバ
# 同時に複数のクライアントを取り扱える
# 以下の例だと接続制限がない(つまり接続過剰になりえる)ことに注意
Socket.tcp_server_loop(16807) {|sock, client_addrinfo|
  Thread.new {
    begin
      IO.copy_stream(sock, sock)
    ensure
      sock.close
    end
  }
}

内部的には Socket.tcp_server_sockets で生成したソケットを Socket.accept_loop で処理しています。

[PARAM] host:: 割り当てるホスト名
[PARAM] port:: 割り当てるポート番号

[SEE_ALSO] Socket.tcp_server_sockets, Socket.accept_loop

tcp_server_sockets(port) -> [Socket]

tcp_server_sockets(host, port) -> [Socket]

tcp_server_sockets(port) {|sockets| ...} -> object

tcp_server_sockets(host, port) {|sockets| ...} -> object

TCP/IP で host:port で待ち受けるサーバ側のソケットを作成します。

ブロックなしの場合は、ソケットオブジェクトの配列を返します。

ブロック付きの場合は、ソケットオブジェクトをそのブロックに渡して呼び出します。ブロック終了時にそれらのソケットを閉じます。返り値はブロックの評価値となります。

port が 0 の場合は、実際のポート番号は動的に選ばれます。ただし返り値のソケットはすべて同じ番号を持ちます。

# tcp_server_sockets returns は2つのソケットを返す
sockets = Socket.tcp_server_sockets(1296)
p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]

# それぞれは IPv4 と IPv6 のソケット
sockets.each {|s| p s.local_address }
#=> #<Addrinfo: [::]:1296 TCP>
#   #<Addrinfo: 0.0.0.0:1296 TCP>

# ポート番号を動的に選んでも IPv6 と IPv4 で同じポート番号を持つ
sockets = Socket.tcp_server_sockets(0)
sockets.each {|s| p s.local_address }
#=> #<Addrinfo: [::]:53114 TCP>
#   #<Addrinfo: 0.0.0.0:53114 TCP>

# ブロックにソケットの配列が渡される
Socket.tcp_server_sockets(0) {|sockets|
  p sockets #=> [#<Socket:fd 3>, #<Socket:fd 4>]
}

[PARAM] host:: 割り当てるホスト名
[PARAM] port:: 割り当てるポート番号

[SEE_ALSO] Socket.tcp_server_loop

try_convert(obj) -> IO | nil

obj を to_io メソッドによって IO オブジェクトに変換します。変換できなかった場合は nil を返します。

IO.try_convert(STDOUT)     # => STDOUT
IO.try_convert("STDOUT")   # => nil

udp_server_loop(port) {|msg, msg_src| ... } -> ()

udp_server_loop(host, port) {|msg, msg_src| ... } -> ()

UDP のサーバを起動して、メッセージが来るごとにブロックを呼び出します。

ブロックに渡される引数は msg と msg_src の 2 つで、 msg は受け取ったメッセージ文字列で、 msg_src は通信相手の Socket::UDPSource オブジェクトです。

[PARAM] host:: 割り当てるホスト名
[PARAM] port:: 割り当てるポート番号

[SEE_ALSO] Socket.udp_server_sockets, Socket.udp_server_loop_on

udp_server_loop_on(sockets) {|msg, msg_src| ... } -> ()

sockets (UDP のソケット)に対し、通信を待ち受けます。

Socket.udp_server_sockets の返り値がこれの引数に適切です。

ソケットからメッセージを受け取るたびにブロックを呼び出します。ブロックに渡される引数は msg と msg_src の 2 つで、 msg は受け取ったメッセージ文字列で、 msg_src は通信相手の Socket::UDPSource オブジェクトです。

無限ループ構造になっています。

[PARAM] sockets:: 通信を待ち受けるソケットの配列

[SEE_ALSO] Socket.udp_server_recv, Socket.udp_server_loop

udp_server_recv(sockets) {|msg, msg_src| ... } -> ()

socketsで与えられた各 UDP ソケットからデータを読み取ります。

各ソケットからメッセージを読み取るごとにブロックを呼び出します。ブロックに渡される引数は msg と msg_src の 2 つで、 msg は受け取ったメッセージ文字列で、 msg_src は通信相手の Socket::UDPSource オブジェクトです。

Socket.udp_server_loop はこのメソッドの用いて以下のようにして実装できます。

udp_server_sockets(host, port) {|sockets|
  loop {
    readable, _, _ = IO.select(sockets)
    udp_server_recv(readable) {|msg, msg_src| ... }
  }
}

[PARAM] sockets:: 読み込むソケットの配列

udp_server_sockets(port) -> [Sockets]

udp_server_sockets(host, port) -> [Sockets]

udp_server_sockets(port) {|sockets| ... } -> object

udp_server_sockets(host, port) {|sockets| ... } -> object

UDP で host:port を待ち受けるサーバ側のソケットを作成します。

ブロックなしの場合は、ソケットオブジェクトの配列を返します。

ブロック付きの場合は、ソケットオブジェクトをそのブロックに渡して呼び出します。ブロック終了時にそれらのソケットを閉じます。

port が 0 の場合は、実際のポート番号は動的に選ばれます。ただし返り値のソケットはすべて同じ番号を持ちます。

# UDP/IP echo server
Socket.udp_server_sockets(0) {|sockets|
  p sockets.first.local_address.ip_port     #=> 32963
  Socket.udp_server_loop_on(sockets) {|msg, msg_src|
    msg_src.reply msg
  }
}

[PARAM] host:: 割り当てるホスト名
[PARAM] port:: 割り当てるポート番号

unix(path) -> Socket

unix(path) {|sock| ... } -> object

Unix クライアントソケットを生成します。

ブロックが省略されたときは、生成されたソケットが返されます。

ブロックが渡されたときは、生成されたソケットを引数としてブロックを呼び出します。メソッドの返り値はブロックの評価値となります。また、ブロックの終了後にソケットを IO#close します。

# /tmp/sock と通信する
Socket.unix("/tmp/sock") {|sock|
  t = Thread.new { IO.copy_stream(sock, STDOUT) }
  IO.copy_stream(STDIN, sock)
  t.join
}

[PARAM] path:: 接続対象のパス(文字列)

unix_server_loop(path) {|socket, client_addrinfo| ... } -> ()

Unix サーバソケットを生成し、新しい接続を受け入れるごとにブロックを呼び出します。

ブロックには新しい接続を表すソケットオブジェクトと、クライアントアドレスを表す Addrinfo オブジェクトが渡されます。

ブロックの実行が終わってもソケットは close されません。アプリケーション側が明示的に close する必要があります。

path という名前のファイルが既に存在するときは、そのファイルのオーナである場合は先にそのファイルを削除してしまいます。これは path が悪意あるユーザによって変更されない場合に限りは安全です。つまり、 /tmp/malicious-users-directory/socket という名前のパスは使うべきではありません。 /tmp にスティッキービットが立っている場合、/tmp/socket や /tmp/your-private-directory/socket というパス名は安全と考えて良いでしょう。

[PARAM] path:: 接続を待ち受けるパス(文字列)

unix_server_socket(path) -> Socket

unix_server_socket(path) {|sock| ... } -> object

Unix サーバソケットを生成します。

ブロックが省略されたときは、生成されたソケットが返されます。

socket = Socket.unix_server_socket("/tmp/s")
p socket                  #=> #<Socket:fd 3>
p socket.local_address    #=> #<Addrinfo: /tmp/s SOCK_STREAM>

Socket.unix_server_socket("/tmp/sock") {|s|
  p s                     #=> #<Socket:fd 3>
  p s.local_address       #=> # #<Addrinfo: /tmp/sock SOCK_STREAM>
}

[PARAM] path:: 接続を待ち受けるパス(文字列)

unpack_sockaddr_in(sockaddr) -> Array

socket/ソケットアドレス構造体を pack した文字列を unpack したアドレスを返します。返される値は [port, ipaddr] の配列です。

[PARAM] sockaddr:: ソケットアドレス構造体を pack した文字列socket/ソケットアドレス構造体を pack した文字列を指定します。

例:

require 'socket'
p Socket.unpack_sockaddr_in(Socket.sockaddr_in("echo", "localhost"))
=> [7, "127.0.0.1"]
p Socket.unpack_sockaddr_in(Socket.sockaddr_in("echo", "::1"))
=> [7, "::1"]

unpack_sockaddr_un(sockaddr) -> String

socket/ソケットアドレス構造体を pack した文字列を unpack したソケットパス名を返します。

[PARAM] sockaddr:: ソケットアドレス構造体を pack した文字列socket/ソケットアドレス構造体を pack した文字列を指定します。

例:

require 'socket'
p Socket.unpack_sockaddr_un(Socket.sockaddr_un("/tmp/.X11-unix/X0"))
=> "/tmp/.X11-unix/X0"

write(path, string, offset=nil, opt={}) -> Integer

path で指定されるファイルを開き、string を書き込み、閉じます。

offset を指定するとその位置までシークします。

offset を指定しないと、書き込みの末尾でファイルを切り捨てます。

引数最後のハッシュはファイルを開くときに使われます。エンコーディングなどを指定することができます。詳しくは IO.open を見てください。

[PARAM] path:: ファイル名文字列
[PARAM] string:: 書き込む文字列
[PARAM] offset:: 書き込み開始位置
[PARAM] opt:: ファイルを開くときのオプション引数

[SEE_ALSO] IO.binwrite

インスタンスメソッド

self << object -> self

object を出力します。object が文字列でない時にはメソッド to_s を用いて文字列に変換します。

以下のような << の連鎖を使うことができます。

STDOUT << 1 << " is a " << Fixnum << "\n"

[PARAM] object:: 出力したいオブジェクトを与えます。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

accept -> Array

新しい接続を受け付けて、新しい接続に対するソケットとアドレスのペアを返します。accept(2) を参照。

たとえば IPv4 の TCP サーバソケットを生成し、accept でクライアントからの接続を受け付けるには以下のようにします。

例:

serv = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
sockaddr = Socket.sockaddr_in(8080, "0.0.0.0")
serv.bind(sockaddr)
serv.listen(5)
sock = serv.accept

accept_nonblock -> Array

ソケットをノンブロッキングモードに設定した後、 accept(2) を呼び出します。

引数、返り値は Socket#accept と同じです。

accept(2) がエラーになった場合、 EAGAIN, EINTR を含め例外 Errno::EXXX が発生します。

advise(advice, offset=0, len=0) -> nil

posix_fadvise(2) を呼びだし、ファイルへのアクセスパターンをOSに知らせます。

advice には以下のいずれかのシンボルを指定します。

:normal - デフォルト
:sequential - データは前から順にアクセスされる
:random - データはランダムアクセスされる
:willneed - データはこの直後にアクセスされる
:dontneed - データは直後にはアクセスしない
:noreuse - データは一度しかアクセスされない

これらの advice が具体的に何をするのかはプラットフォーム依存です。

ここでいう「データ」は offset と len で特定することができます。 len が 0 ならば、offset からファイル末尾までを指定したことになります。デフォルトでは offset と len がともに 0 なので、ファイル全体を指定したことになります。

posix_fadvise をサポートしていないプラットフォーム上では何もしません。

[PARAM] advice:: アクセスパターンを表すシンボル
[PARAM] offset:: パターンを指定するデータの先頭位置
[PARAM] len:: パターンを指定するデータの長さ
[EXCEPTION] IOError:: ストリームが既に閉じられているときに発生する例外
[EXCEPTION] Errno::EBADF:: ファイルデスクリプタが不正であるときに発生する例外
[EXCEPTION] Errno::EINVAL:: advice が不正
[EXCEPTION] Errno::ESPIPE:: ファイルデスクリプタが FIFO か pipe を指している場合に発生する例外(Linux はこの場合には Errno::EINVAL を発生する)
[EXCEPTION] RangeError:: offset,lenが有効範囲から出ている場合に発生する例外

all? -> bool

all? {|item| ... } -> bool

すべての要素が真である場合に true を返します。偽である要素があれば、ただちに false を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果が真である場合に true を返します。ブロックが偽を返した時点で、ただちに false を返します。

例:

# すべて正の数か？
p [5,  6, 7].all? {|v| v > 0 }   # => true
p [5, -1, 7].all? {|v| v > 0 }   # => false

any? -> bool

any? {|item| ... } -> bool

すべての要素が偽である場合に false を返します。真である要素があれば、ただちに true を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果が偽である場合に false を返します。ブロックが真を返した時点で、ただちに true を返します。

例:

p [1, 2, 3].any? {|v| v > 3 }   # => false
p [1, 2, 3].any? {|v| v > 1 }   # => true

autoclose=(bool)

auto-close フラグを設定します。

フラグが設定されているオブジェクトは close時/GCでのファイナライザ呼出時にファイルデスクリプタを close します。設定されていない場合は close しません。

[PARAM] bool:: 真偽値でフラグを設定します

[SEE_ALSO] IO#autoclose?

f = open("/dev/null")
IO.for_fd(f.fileno)
# ...
f.gets # may cause IOError

f = open("/dev/null")
IO.for_fd(f.fileno).autoclose = true
# ...
f.gets # won't cause IOError

autoclose? -> bool

auto-close フラグを返します。

[SEE_ALSO] IO#autoclose=

bind(my_sockaddr) -> 0

ソケットを my_sockaddr に結合します。bind(2) と同じ働きをします。

[PARAM] my_sockaddr:: ソケットアドレス構造体を pack した文字列socket/ソケットアドレス構造体を pack した文字列もしくはAddrinfoオブジェクトを指定します。
[RETURN]: 0 を返します。

binmode -> self

ストリームをバイナリモードにします。MSDOS などバイナリモードの存在する OS でのみ有効です。そうでない場合このメソッドは何もしません。

バイナリモードから通常のモードに戻す方法は再オープンしかありません。

[EXCEPTION] Errno::EXXX:: モードの変更に失敗した場合に発生します。

binmode? -> bool

自身がバイナリモードなら true を返します。そうでない場合、false を返します。

bytes -> Enumerator

自身を 1 バイトずつ整数としてイテレートするような Enumerator オブジェクトを生成して返します。

"hello".bytes.to_a        #=> [104, 101, 108, 108, 111]

each_char {|c| ... } -> self

chars {|c| ... } -> self

each_char -> Enumerator

chars -> Enumerator

self に含まれる文字を一文字つつブロックに渡して評価します。

self は読み込み用にオープンされていなければなりません。

ブロックを省略した場合は各文字について繰り返す Enumerator を返します。

[EXCEPTION] IOError:: self が読み込み用にオープンされていない場合に発生します。

f = File.new("testfile")
f.each_char {|c| print c, ' ' }   #=> #<File:testfile>

chunk {|elt| ... } -> Enumerator

chunk(initial_state) {|elt, state| ... } -> Enumerator

要素を前から順にブロックで評価し、その結果によって要素をチャンクに分けた(グループ化した)要素を持つ Enumerator を返します。

ブロックの評価値が同じ値が続くものを一つのチャンクとして取り扱います。すなわち、ブロックの評価値が一つ前と異なる所でチャンクが区切られます。

返り値の Enumerator は各チャンクのブロック評価値と各チャンクの要素を持つ配列のペアを各要素とします。そのため、eachだと以下のようになります。

enum.chunk {|elt| key }.each {|key, ary| ... }
enum.chunk(initial_state) {|elt, state| key }.each {|key, ary| ... }

例として、整数列を連続する奇数/偶数に分ける例を見てみます。「n.even?」が変換するところで区切られているのがわかるでしょう。

[3,1,4,1,5,9,2,6,5,3,5].chunk {|n|
  n.even?
}.each {|even, ary|
  p [even, ary]
}
#=> [false, [3, 1]]
#   [true, [4]]
#   [false, [1, 5, 9]]
#   [true, [2, 6]]
#   [false, [5, 3, 5]]

このメソッドは各要素が既にソートされている場合に便利です。以下の例では、テキスト辞書ファイル(中身がソートされている) に含まれる単語を先頭の文字ごとに数えています。

# line.ord は先頭の文字のコードポイントを返す
open("/usr/share/dict/words", "r:iso-8859-1") {|f|
  f.chunk {|line| line.ord }.each {|ch, lines| p [ch.chr, lines.length] }
}
#=> ["\n", 1]
#   ["A", 1327]
#   ["B", 1372]
#   ["C", 1507]
#   ["D", 791]
#   ...

さらにこのメソッドは以下の値を特別扱いします。

ブロックの評価値が nil もしくは :_separator であった場合、その要素を捨てます。チャンクはこの前後で区切られます。
ブロックの評価値 :_alone であった場合はその要素は単独のチャンクをなすものと解釈されます。

アンダースコアで始まるシンボルはこのメソッドでは予約されています。ブロックの返り値としては用いないでください。

nil、 :_separator はある要素を無視したい場合に用います。例として svn log の出力のハイフンの所で区切りたい場合を考えます。

sep = "-"*72 + "\n" # ハイフンが72個の行
IO.popen("svn log README") {|f|
  f.chunk {|line|
    line != sep || nil
  }.each {|_, lines|
    pp lines
  }
}
#=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n",
#    "\n",
#    "* README, README.ja: Update the portability section.\n",
#    "\n"]
#   ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n",
#    "\n",
#    "* README, README.ja: Add a note about default C flags.\n",
#    "\n"]
#   ...

テキストを空行で区切られた段落に分けたい場合にも nil が使えます。

File.foreach("README").chunk {|line|
  /\A\s*\z/ !~ line || nil
}.each {|_, lines|
  pp lines
}

「:_alone」は要素を素通ししたい場合に用います。以下の例では「Foo#bar」という形式の行が連続している場合のみチャンク化し、それ以外は素通しします。

pat = /\A[A-Z][A-Za-z0-9_]+\#/
open(filename) {|f|
  f.chunk {|line| pat =~ line ? $& : :_alone }.each {|key, lines|
    if key != :_alone
      print lines.sort.join('')
    else
      print lines.join('')
    end
  }
}

チャンク化に状態遷移が必要な場合は、オプション引数 initial_state に状態を保持するオブジェクトを渡します。この場合、ブロックの第2引数にはこのオブジェクトが dup で複製されて渡されます。

[PARAM] initial_state:: 状態を保持するオブジェクト
[EXCEPTION] RuntimeError:: 予約されている値を用いた場合に発生します

clone -> IO

dup -> IO

レシーバと同じ IO を参照する新しい IO オブジェクトを返します。参照しているファイル記述子は dup(2) されます。

clone の際に self は一旦 IO#flush されます。フリーズした IO の clone は同様にフリーズされた IO を返しますが、 dup は内容の等しいフリーズされていない IO を返します。

[EXCEPTION] IOError:: 既に close されていた場合に発生します。

close -> nil

入出力ポートをクローズします。

以後このポートに対して入出力を行うと例外 IOError が発生します。ガーベージコレクトの際にはクローズされていない IO ポートはクローズされます。 self がパイプでプロセスにつながっていれば、そのプロセスの終了を待ち合わせます。

[EXCEPTION] Errno::EXXX:: close に失敗した場合に発生します。
[EXCEPTION] IOError:: 既に close されていた場合に発生します。

close_on_exec=(bool)

自身に close-on-exec フラグを設定します。

このフラグをセットすると exec(2) 時にそのファイルデスクリプタを close します。

[SEE_ALSO] fcntl(2)

[PARAM] bool:: 自身の close-on-exec フラグを true か false で指定します。

f = open("/dev/null")
f.close_on_exec = true
system("cat", "/proc/self/fd/#{f.fileno}") # cat: /proc/self/fd/3: No such file or directory
f.closed?                #=> false

[SEE_ALSO] IO#close_on_exec?

close_on_exec? -> bool

自身に close-on-exec フラグが設定されていた場合 true を返します。そうでない場合に false を返します。

f = open("/dev/null")
f.close_on_exec?                 #=> false
f.close_on_exec = true
f.close_on_exec?                 #=> true
f.close_on_exec = false
f.close_on_exec?                 #=> false

[SEE_ALSO] IO#close_on_exec=

close_read -> nil

読み込み用の IO を close します。主にパイプや読み書き両用に作成した IO オブジェクトで使用します。

[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: close に失敗した場合に発生します。

close_write -> nil

書き込み用の IO を close します。

[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: close に失敗した場合に発生します。

closed? -> bool

ポートがクローズされている時に真を返します。

each_codepoint {|c| ... } -> self

codepoints {|c| ... } -> self

each_codepoint -> Enumerator

codepoints -> Enumerator

IO の各コードポイントに対して繰り返しブロックを呼びだします。

ブロックの引数にはコードポイントを表す整数が渡されます。

ブロックを省略した場合には、Enumerator を返します。

collect -> Enumerator

map -> Enumerator

collect {|item| ... } -> [object]

map {|item| ... } -> [object]

各要素に対してブロックを評価した結果を全て含む配列を返します。

ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として得られる配列を返すような Enumerator オブジェクトを返します。

例:

# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 }  # => [3, 6, 9]

flat_map -> Enumerator

collect_concat -> Enumerator

flat_map {| obj | block } -> Array

collect_concat {| obj | block } -> Array

各要素をブロックに渡し、その返り値を連結した配列を返します。

ブロックの返り値は基本的に配列を返すべきです。

ブロックを省略した場合は、ブロックを受けとり上で説明した評価をし、その結果の配列を返す Enumerator オブジェクトを返します。

[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]

connect(server_sockaddr) -> 0

connect(2) でソケットを接続します。

server_sockaddr は、 socket/ソケットアドレス構造体を pack した文字列もしくは Addrinfo オブジェクトです。

0 を返します。

[PARAM] server_sockaddr:: 接続先アドレス
[EXCEPTION] Errno::EXXX:: connect(2) がエラーを報告した場合に発生します。詳しくは man を参照してください。

たとえば IPv4 の TCP ソケットを生成し、connect で www.ruby-lang.org:80 に接続するには以下のようにします。

例:

s = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
sockaddr = Socket.sockaddr_in(80, "www.ruby-lang.org")
s.connect(sockaddr)
s.write "GET / HTTP/1.0\r\n\r\n"
print s.read

connect_address -> Addrinfo

ローカルマシン内で接続するのに適当なアドレスを Addrinfo オブジェクトで返します。

BasicSocket#local_address の返り値以下の点を除いては同じものを返します。

IPv4 の不定アドレス(0.0.0.0) は IPv4 のループバックアドレス(127.0.0.1) に置換される
IPv6 の不定アドレス(::) は IPv6 のループバックアドレス(::1) に置換される

BasicSocket#local_address が接続先として不適なアドレスを返す場合は例外 SocketError が発生します。

Addrinfo.tcp("0.0.0.0", 0).listen {|serv|
  p serv.connect_address #=> #<Addrinfo: 127.0.0.1:53660 TCP>
  serv.connect_address.connect {|c|
    s, _ = serv.accept
    p [c, s] #=> [#<Socket:fd 4>, #<Socket:fd 6>]
  }
}

[EXCEPTION] SocketError:: アドレスが接続に不適な場合に返します

[SEE_ALSO] BasicSocket#local_address

connect_nonblock(server_sockaddr) -> 0

ソケットをノンブロッキングモードに設定した後、 connect(2) を呼び出します。

引数、返り値は Socket#connect と同じです。

connect が EINPROGRESS エラーを報告した場合、その例外(Errno::EINPROGRESS) には IO::WaitWritable が Object#extend されます。これを connect_nonblock をリトライするために使うことができます。

# Pull down Google's web page
require 'socket'
include Socket::Constants
socket = Socket.new(AF_INET, SOCK_STREAM, 0)
sockaddr = Socket.sockaddr_in(80, 'www.google.com')
begin # emulate blocking connect
  socket.connect_nonblock(sockaddr)
rescue IO::WaitWritable
  IO.select(nil, [socket]) # wait 3-way handshake completion
  begin
    socket.connect_nonblock(sockaddr) # check connection failure
  rescue Errno::EISCONN
  end
end
socket.write("GET / HTTP/1.0\r\n\r\n")
results = socket.read

[PARAM] server_sockaddr:: 接続先アドレス
[EXCEPTION] Errno::EXXX:: connect(2) がエラーを報告した場合に発生します。詳しくは man を参照してください。

count -> Integer

count(item) -> Integer

count {|obj| ... } -> Integer

レシーバの要素数を返します。

引数を指定しない場合は、レシーバの要素数を返します。このとき、レシーバが size メソッドを持っていればそちらを使用します。レシーバが size メソッドを持っていない場合は、要素数を一つずつカウントします。

引数を一つ指定した場合は、レシーバの要素のうち引数に一致するものの個数をカウントして返します(一致は == で判定します)。

ブロックを指定した場合は、ブロックを評価して真になった要素の個数をカウントして返します。

[PARAM] item:: カウント対象となる値。

例:

ary = [1, 2, 4, 2]
ary.count             # => 4
ary.count(2)          # => 2
ary.count{|x|x%2==0}  # => 3

cycle(n=nil) -> Enumerator

cycle(n=nil) {|obj| ... } -> object | nil

Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返しブロックを呼びだします。

n に 0 もしくは負の値を渡した場合は何もしません。繰り返しが最後まで終了した場合(つまりbreakなどで中断しなかった場合) は nil を返します。このメソッドは内部の配列に各要素を保存しておくため、一度 Enumerable の終端に到達した後に自分自身を変更してもこのメソッドの動作に影響を与えません。

a = ["a", "b", "c"]
a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
a.cycle(2) {|x| puts x }  # print, a, b, c, a, b, c.

ブロックを省略した場合は、n 回 or 無限回 enum の各要素を繰り返す Enumerator を返します。

[RETURN]: ブロックを指定しなかった場合は、Enumerator を返します。レシーバが空の場合は nil を返します。

find(ifnone = nil) -> Enumerator

detect(ifnone = nil) -> Enumerator

find(ifnone = nil) {|item| ... } -> object

detect(ifnone = nil) {|item| ... } -> object

要素に対してブロックを評価した値が真になった最初の要素を返します。

真になる要素が見つからず、ifnone も指定されていないときは nil を返します。真になる要素が見つからず、ifnone が指定されているときは ifnone を call した結果を返します。

ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に真になった値を返すような Enumerator を返します。

[PARAM] ifnone:: call メソッドを持つオブジェクト (例えば Proc) を指定します。

例:

# 最初の 3 の倍数を探す
p [1, 2, 3, 4, 5].find {|i| i % 3 == 0 }   # => 3
p [2, 2, 2, 2, 2].find {|i| i % 3 == 0 }   # => nil

# ifnone の使用例
ifnone = proc { raise ArgumentError, "item not found" }
p [1, 2, 3, 4, 5].find(ifnone) {|i| i % 7 == 0 }
    # ArgumentError: item not found

do_not_reverse_lookup -> bool

ソケットごとのアドレスからホスト名への逆引きの設定を返します。

真ならアドレスからホスト名への逆引きを行いません。

初期値はソケットを生成したときの BasicSocket.do_not_reverse_lookup の値になります。

[SEE_ALSO] BasicSocket#do_not_reverse_lookup=

do_not_reverse_lookup=(bool)

アドレスからホスト名への逆引きの設定をソケットごとに設定します。

[PARAM] bool:: この値が真ならアドレスからホスト名への逆引きを行わなくなります。

[SEE_ALSO] BasicSocket#do_not_reverse_lookup

drop(n) -> Array

Enumerable オブジェクトの先頭の n 要素を捨てて、残りの要素を配列として返します。

[PARAM] n:: 捨てる要素数。

a = [1, 2, 3, 4, 5, 0]
a.drop(3)             # => [4, 5, 0]

drop_while -> Enumerator

drop_while {|element| ... } -> Array

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、残りの要素を配列として返します。

ブロックを指定しなかった場合は、Enumerator を返します。

a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]

each_byte {|ch| ... } -> self

each_byte -> Enumerator

IO の現在位置から 1 バイトずつ読み込み、それを整数として与え、ブロックを実行します。

ブロックが与えられなかった場合は、自身から生成した Enumerator オブジェクトを返します。

バイナリ読み込みメソッドとして動作します。

[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

each_cons(n) -> Enumerator

each_cons(n) {|list| ... } -> nil

要素を重複ありで n 要素ずつに区切り、ブロックに渡して繰り返します。

ブロックを省略した場合は重複ありで n 要素ずつ繰り返す Enumerator を返します。

[PARAM] n:: ブロックに渡す要素の数です。正の整数を与えます。要素数より大きな数を与えると、ブロックは一度も実行されません。

例:

(1..10).each_cons(3){|v| p v }
# => [1, 2, 3]
#    [2, 3, 4]
#    [3, 4, 5]
#    [4, 5, 6]
#    [5, 6, 7]
#    [6, 7, 8]
#    [7, 8, 9]
#    [8, 9, 10]

[SEE_ALSO] Enumerable#each_slice

each_entry -> Enumerator

each_entry {|obj| block} -> self

ブロックを各要素に一度ずつ適用します。

一要素として複数の値が渡された場合はブロックには配列として渡されます。

class Foo
  include Enumerable
  def each
    yield 1
    yield 1,2
  end
end
Foo.new.each_entry{|o| print o, " -- "}
# => 1 -- [1, 2] --

ブロックを省略した場合は Enumerator が返されます。

[SEE_ALSO] Enumerable#slice_before

each_line(rs = $/) {|line| ... } -> self

each_line(limit) {|line| ... } -> self

each_line(rs, limit) {|line| ... } -> self

each_line(rs = $/) -> Enumerator

each_line(limit) -> Enumerator

each_line(rs, limit) -> Enumerator

lines(rs = $/) {|line| ... } -> self

lines(limit) {|line| ... } -> self

lines(rs, limit) {|line| ... } -> self

lines(rs = $/) -> Enumerator

lines(limit) -> Enumerator

lines(rs, limit) -> Enumerator

IO の現在位置から 1 行ずつ文字列として読み込み、それを引数として与えられたブロックを実行します。

ブロックが与えられなかった場合は、自身から生成した Enumerator オブジェクトを返します。

テキスト読み込みメソッドとして動作します。

limit で最大読み込みバイト数を指定します。ただしマルチバイト文字が途中で切れないように余分に読み込む場合があります。

[PARAM] rs:: 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。
[PARAM] limit:: 最大の読み込みバイト数
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

[SEE_ALSO] $/, IO#gets

each_slice(n) -> Enumerator

each_slice(n) {|list| ... } -> nil

n 要素ずつブロックに渡して繰り返します。

要素数が n で割り切れないときは、最後の回だけ要素数が減ります。

ブロックを省略した場合は n 要素ずつ繰り返す Enumerator を返します。

[PARAM] n:: 区切る要素数を示す整数です。

例:

(1..10).each_slice(3) {|a| p a}
    # => [1, 2, 3]
    #    [4, 5, 6]
    #    [7, 8, 9]
    #    [10]

[SEE_ALSO] Enumerable#each_cons

each_with_index -> Enumerator

each_with_index {|item, index| ... } -> self

要素とそのインデックスをブロックに渡して繰り返します。

self を返します。

ブロックを省略した場合は、要素とそのインデックスを繰り返すような Enumerator を返します。

例:

[5, 10, 15].each_with_index do |n, idx|
  p [n, idx]
end
    # => [5, 0]
    #    [10, 1]
    #    [15, 2]

each_with_object(obj) -> Enumerator

each_with_object(obj) {|(*args), memo_obj| ... } -> object

与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。

ブロックを省略した場合は、上の繰り返しをして、最初に与えたオブジェクトを最後に返す Enumerator を返します。

[PARAM] obj:: 任意のオブジェクトを指定します。

evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

[SEE_ALSO] Enumerator#with_object

to_a -> [object]

entries -> [object]

全ての要素を含む配列を返します。

eof -> bool

eof? -> bool

ストリームがファイルの終端に達した場合、true を返します。そうでない場合、false を返します。

f = File.new("testfile")
dummy = f.readlines
f.eof   #=> true

自身がパイプやソケットなどのストリームであった場合、相手がデータを送るか close するまでブロックします。

r, w = IO.pipe
Thread.new { sleep 10; w.close }
r.eof?  #=> 10秒ブロックしてから true を返す。

r, w = IO.pipe
Thread.new { sleep 10; w.puts "a" }
r.eof?  #=> 10秒ブロックしてから false を返す。

r, w = IO.pipe
r.eof?  # 永久にブロックします。

eof, eof? は入力バッファにデータを読み込むので、IO#sysread と同時に使うと正常に動作しません。

[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

external_encoding -> Encoding | nil

IO の外部エンコーディングを返します。外部エンコーディングが指定されていない場合は nil を返します。

fcntl(cmd, arg = 0) -> Integer

IOに対してシステムコール fcntl を実行します。機能の詳細は fcntl(2) を参照してください。 fcntl(2) が返した整数を返します。

[PARAM] cmd:: IO に対するコマンドを、添付ライブラリ fcntl が提供している定数で指定します。
[PARAM] arg:: cmd に対する引数を整数、文字列、booleanのいずれかで指定します。整数の時にはその値を fcntl(2) に渡します。文字列の場合には Array#pack した構造体だとみなして渡します。 arg が nil か false の場合には 0を、true の場合には 1 を渡します。
[EXCEPTION] Errno::EXXX:: fcntl の実行に失敗した場合に発生します。
[EXCEPTION] IOError:: 既に close されている場合に発生します。

fdatasync -> 0 | nil

IO のすべてのバッファされているデータを直ちにディスクに書き込みます。

fdatasync(2) をサポートしていない OS 上では代わりに IO#fsync を呼びだします。

IO#fsync との違いは fdatasync(2) を参照してください。

[EXCEPTION] NotImplementedError:: fdatasync(2) も fsync(2) もサポートされていない OS で発生します。

fileno -> Integer

to_i -> Integer

ファイル記述子を表す整数を返します。

[EXCEPTION] IOError:: 既に close されている場合に発生します。

find_all -> Enumerator

select -> Enumerator

find_all {|item| ... } -> [object]

select {|item| ... } -> [object]

各要素に対してブロックを評価した値が真であった要素を全て含む配列を返します。真になる要素がひとつもなかった場合は空の配列を返します。

ブロックを省略した場合は、各要素に対しブロックを評価し真になった値の配列を返すような Enumerator を返します。

find_index -> Enumerator

find_index {|obj| ... } -> Integer | nil

要素を先頭から順にブロックに渡して評価し、最初に真になった要素のインデックスを返します。一つも真にならなければ nil を返します。

(1..10).find_index  {|i| i % 5 == 0 and i % 7 == 0 }   #=> nil
(1..100).find_index {|i| i % 5 == 0 and i % 7 == 0 }   #=> 34

ブロックを指定しなかった場合は、Enumerator を返します。

first -> object | nil

first(n) -> Array

Enumerable オブジェクトの最初の要素、もしくは最初の n 要素を返します。

Enumerable オブジェクトが空の場合、引数を指定しない形式では nil を返します。引数を指定する形式では、空の配列を返します。

[PARAM] n:: 取得する要素数。

e = "abcd".each_byte
e.first #=> 97
e.first(2) #=> [97,98]
e = "".each_byte
e.first #=> nil
e.first(2) #=> []

flush -> self

IO ポートの内部バッファをフラッシュします。

[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: fflush(3) が失敗した場合に発生します。

fsync -> 0 | nil

書き込み用の IO に対して、システムコール fsync(2) を実行します。IO#flush を行ったあと、(OSレベルで)まだディスクに書き込まれていないメモリ上にあるデータをディスクに書き出します。

成功すれば 0 を返します。 fsync(2) がサポートされていない場合は nil を返します。

[EXCEPTION] Errno::EXXX:: 失敗した場合に発生します。
[EXCEPTION] IOError:: 既に close されている場合に発生します。

getbyte -> Integer | nil

IO から1バイトを読み込み整数として返します。既に EOF に達していれば nil を返します。

f = File.new("testfile")
f.getbyte   #=> 84
f.getbyte   #=> 104

getc -> String | nil

IO ポートから外部エンコーディングに従い 1 文字読み込んで返します。 EOF に到達した時には nil を返します。

テキスト読み込みメソッドとして動作します。 IO#readchar との違いは EOF での振る舞いのみです。

[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

例:

[SEE_ALSO] IO#readchar

getpeereid -> [Integer, Integer]

Unix ドメインソケットにおいて接続相手の euid と egid を返します。

配列の最初の要素が euid, 2番目の要素が egid です。

ソケットが Unix ドメインソケットでない場合の返り値は不定です。

Socket.unix_server_loop("/tmp/sock") {|s|
  begin
    euid, egid = s.getpeereid

    # Check the connected client is myself or not.
    next if euid != Process.uid

    # do something about my resource.
  ensure
    s.close
  end
}

getpeername -> String

接続の相手先のソケットの情報を取得します。sockaddr 構造体をパックした文字列を返します。getpeername(2) を参照してください。

例:

serv = TCPServer.open("", 0)
c = TCPSocket.open(*Socket.unpack_sockaddr_in(serv.getsockname).reverse)
s = serv.accept
addr = c.getpeername
p addr      #=> "\002\000\267\214\177\000\000\001\000\000\000\000\000\000\000\000"
p Socket.unpack_sockaddr_in(addr)   #=> [46988, "127.0.0.1"]
p addr == s.getsockname     #=> true

gets(rs = $/) -> String | nil

gets(limit) -> String | nil

gets(rs, limit) -> String | nil

一行読み込んで、読み込みに成功した時にはその文字列を返します。 EOF に到達した時には nil を返します。

テキスト読み込みメソッドとして動作します。読み込んだ文字列を変数 $_ にセットします。 IO#readline との違いは EOF での振る舞いのみです。

limit で最大の読み込みバイト数を指定します。ただしファイルのエンコーディングがマルチバイトエンコーディングである場合には読み込んだ文字列がマルチバイト文字の途中で切れないように数バイト余分に読み込む場合があります。

[PARAM] rs:: 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。
[PARAM] limit:: 最大の読み込みバイト数
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

f = File.new("oneline_file")
f.gets                          #=> "This is line one\n"
$_                              #=> "This is line one\n"
f.gets                          #=> nil
$_                              #=> nil

[SEE_ALSO] $/, IO#readline

getsockname -> String

ソケットの情報を取得します。sockaddr 構造体をパックした文字列を返します。getsockname(2) を参照してください。

例:

serv = TCPServer.open("", 0)
p serv.getsockname        #=> "\002\000\236C\000\000\000\000\000\000\000\000\000\000\000\000"
p Socket.unpack_sockaddr_in(serv.getsockname)     #=> [40515, "0.0.0.0"]
c = TCPSocket.open(*Socket.unpack_sockaddr_in(serv.getsockname).reverse)
s = serv.accept

getsockopt(level, optname) -> Socket::Option

ソケットのオプションを取得します。getsockopt(2) を参照してください。取得したオプションのデータを Socket::Option で返します。

level, optname には Socket::SOL_SOCKET や Socket::SO_REUSEADDR といった整数値の他、文字列("SOL_SOCKET", prefixなしの "SOCKET")やシンボル(:SO_REUSEADDR, :REUSEADDR)を用いることができます。

[PARAM] level:: getsockopt(2) の第二引数のlevel
[PARAM] optname:: getsockopt(2) の第三引数のoption_name

[SEE_ALSO] BasicSocket#setsockopt

例:

serv = Socket.tcp_server_sockets("", 0)[0]
c = serv.local_address.connect
s = serv.accept
opt = c.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY)
# c.getsockopt("TCP", "NODELAY"),  なども可能
p opt #=> #<Socket::Option: INET TCP NODELAY 0>
p opt.bool #=> false (Nagle アルゴリズム有効)
p opt.unpack("i")[0] #=> 0 (Socket::Option#unpack が互換性のために存在する)
# 整数値の場合は Socket::Option#int を用いる
p c.getsockopt(:IP, :TTL).int #=> 64

grep(pattern) -> [object]

grep(pattern) {|item| ... } -> [object]

pattern === item が成立する要素を全て含んだ配列を返します。

ブロックとともに呼び出された時には条件の成立した要素に対してそれぞれブロックを評価し、その結果の配列を返します。マッチする要素がひとつもなかった場合は空の配列を返します。

[PARAM] pattern:: 「===」メソッドを持つオブジェクトを指定します。

例:

  ['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/)  # => ["bb", "cc"]

Array.instance_methods.grep(/gr/) # => [:grep, :group_by]

group_by -> Enumerator

group_by {|obj| ... } -> Hash

ブロックを評価した結果をキー、対応する要素の配列を値とするハッシュを返します。

(1..6).group_by {|i| i%3}   #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

ブロックを省略した場合は、最後に Hash を返す Enumerator オブジェクトを返します。

member?(val) -> bool

include?(val) -> bool

val と == の関係にある要素を含むとき真を返します。

[PARAM] val:: 任意のオブジェクト

inject(init = self.first) {|result, item| ... } -> object

inject(sym) -> object

inject(init, sym) -> object

reduce(init = self.first) {|result, item| ... } -> object

reduce(sym) -> object

reduce(init, sym) -> object

リストのたたみこみ演算を行います。

最初に初期値 init と self の最初の要素を引数にブロックを実行します。 2 回目以降のループでは、前のブロックの実行結果と self の次の要素を引数に順次ブロックを実行します。そうして最後の要素まで繰り返し、最後のブロックの実行結果を返します。

要素が存在しない場合は init を返します。

初期値 init を省略した場合は、最初に先頭の要素と 2 番目の要素をブロックに渡します。また要素が 1 つしかなければブロックを実行せずに最初の要素を返します。要素がなければブロックを実行せずに nil を返します。

[PARAM] init:: 最初の result の値です。任意のオブジェクトが渡せます。
[PARAM] sym:: ブロックの代わりに使われるメソッド名を表す Symbol オブジェクトを指定します。実行結果に対して sym という名前のメソッドが呼ばれます。

例:

# 合計を計算する。
p [2, 3, 4, 5].inject {|result, item| result + item }        #=> 14

# 自乗和を計算する。初期値をセットする必要がある。
p [2, 3, 4, 5].inject(0) {|result, item| result + item**2 }  #=> 54

この式は以下のように書いても同じ結果が得られます。

result = 0
[1, 2, 3, 4, 5].each {|v| result += v }
p result   # => 15

p [1, 2, 3, 4, 5].inject(:+)                    #=> 15
p ["b", "c", "d"].inject("abbccddde", :squeeze) #=> "abcde"

internal_encoding -> Encoding | nil

IO の内部エンコーディングを返します。内部エンコーディングが指定されていない場合は nil を返します。

ioctl(cmd, arg = 0) -> Integer

IO に対してシステムコール ioctl を実行し、その結果を返します。機能の詳細は ioctl(2) を参照してください。

[PARAM] cmd:: IO に対するコマンドを整数で指定します。どのようなコマンドが使えるかはプラットフォームに依存します。
[PARAM] arg:: cmd に対する引数を指定します。整数の時にはその値を ioctl に渡します。文字列の場合には Array#pack した構造体だとみなして渡します。 arg が nil か false の場合には 0を、true の場合には 1 を渡します。
[EXCEPTION] IOError:: 既に close されている場合に発生します。

ipv6only! -> ()

ソケットの IPV6_V6ONLY オプションを有効にします。

IPV6_V6ONLY オプションが使えない場合はこのメソッドは何もしません。

isatty -> bool

tty? -> bool

入出力ポートがttyに結合している時、真を返します。そうでない場合 false を返します。

[EXCEPTION] IOError:: 既に close されている場合に発生します。

lineno -> Integer

現在の行番号を整数で返します。実際には IO#gets が呼ばれた回数です。改行以外のセパレータで gets が呼ばれた場合など、実際の行番号と異なる場合があります。

[EXCEPTION] IOError:: 読み込み用にオープンされていなければ発生します。

f = File.new("testfile")
f.lineno                 #=> 0
f.gets                   #=> "This is line one\n"
f.lineno                 #=> 1
f.gets                   #=> "This is line two\n"
f.lineno                 #=> 2

[SEE_ALSO] $.

lineno=(number)

現在の行番号を number にセットします。 $. は次回の読み込みの時に更新されます。

[PARAM] number:: 行番号を整数で指定します。
[EXCEPTION] IOError:: 読み込み用にオープンされていなければ発生します。

f = File.new("testfile")
f.gets                     #=> "This is line one\n"
$.                         #=> 1
f.lineno = 1000
f.lineno                   #=> 1000
$.                         #=> 1
f.gets                     #=> "This is line two\n"
$.                         #=> 1001

[SEE_ALSO] $.

listen(backlog) -> 0

listen(2) と同じ働きをします。

0 を返します。

[PARAM] backlog:: 接続を保留できる最大数
[RETURN]: 0 を返します。

local_address -> Addrinfo

getsockname(2) で得られたローカルアドレス情報を Addrinfo オブジェクトとして返します。

返されたオブジェクトの Addrinfo#protocol は 0 を返すことに注意してください。

TCPSocket.open("www.ruby-lang.org", 80) {|s|
  p s.local_address #=> #<Addrinfo: 192.168.0.129:36873 TCP>
}

TCPServer.open("127.0.0.1", 1512) {|serv|
  p serv.local_address #=> #<Addrinfo: 127.0.0.1:1512 TCP>
}

[SEE_ALSO] BasicSocket#getsockname

max -> object

最大の要素を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

要素が存在しなければ nil を返します。該当する要素が複数存在する場合、どの要素を返すかは不定です。

max {|a, b| ... } -> object

ブロックの評価結果で各要素の大小判定を行い、最大の要素を返します。要素が存在しなければ nil を返します。

ブロックの値は、a > b のとき正、 a == b のとき 0、a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

[EXCEPTION] TypeError:: ブロックが整数以外を返したときに発生します。

max_by -> Enumerator

max_by {|item| ... } -> object

各要素を順番にブロックに渡して実行し、その評価結果を <=> で比較して、最大であった値に対応する元の要素を返します。

要素が存在しないときは nil を返します。該当する要素が複数存在する場合、どの要素を返すかは不定です。

Enumerable#max と Enumerable#max_by の違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。

ブロックを省略した場合は、各要素を順番にブロックに渡して評価し、その結果が最小となる値に対応する要素を返す Enumerator を返します。

[SEE_ALSO] Enumerable#sort_by

min -> object

最小の要素を返します。全要素が互いに <=> メソッドで比較できることを仮定しています。

要素が存在しなければ nil を返します。該当する要素が複数存在する場合、どの要素を返すかは不定です。

min {|a, b| ... } -> object

ブロックの評価結果で各要素の大小判定を行い、最小の要素を返します。要素が存在しなければ nil を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

[EXCEPTION] TypeError:: ブロックが整数以外を返したときに発生します。

min_by -> Enumerator

min_by {|item| ... } -> object

各要素を順番にブロックに渡して評価し、その評価結果を <=> で比較して、最小であった値に対応する元の要素を返します。

要素が存在しないときは nil を返します。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

ブロックを省略した場合は、各要素を順番にブロックに渡して評価し、その結果が最小となる値に対応する要素を返す Enumerator を返します。

Enumerable#min と Enumerable#min_by の違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。

[SEE_ALSO] Enumerable#sort_by

minmax -> [object, object]

minmax {|a, b| ... } -> [object, object]

Enumerable オブジェクトの各要素のうち最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

一つ目の形式は、Enumerable オブジェクトのすべての要素が Comparable を実装していることを仮定しています。二つ目の形式では、要素同士の比較をブロックを用いて行います。

a = %w(albatross dog horse)
a.minmax                                 #=> ["albatross", "horse"]
a.minmax{|a,b| a.length <=> b.length }   #=> ["dog", "albatross"]
[].minmax # => [nil, nil]

[SEE_ALSO] Enumerable#sort

minmax_by -> Enumerator

minmax_by {|obj| ... } -> [object, object]

Enumerable オブジェクトの各要素をブロックに渡して評価し、その結果を <=> で比較して最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

Enumerable#minmax と Enumerable#minmax_by の違いは sort と sort_by の違いと同じです。詳細は Enumerable#sort_by を参照してください。

a = %w(albatross dog horse)
a.minmax_by {|x| x.length }   #=> ["dog", "albatross"]

[].minmax_by{} # => [nil, nil]

ブロックを省略した場合は、Enumerator オブジェクトを返します。

[SEE_ALSO] Enumerable#sort_by

none? -> bool

none? {|obj| ... } -> bool

ブロックを指定しない場合は、 Enumerable オブジェクトのすべての要素が偽であれば真を返します。そうでなければ偽を返します。

ブロックを指定した場合は、Enumerable オブジェクトのすべての要素をブロックで評価した結果が、すべて偽であれば真を返します。そうでなければ偽を返します。

%w{ant bear cat}.none? {|word| word.length == 5}  #=> true
%w{ant bear cat}.none? {|word| word.length >= 4}  #=> false
[].none?                                          #=> true
[nil].none?                                       #=> true
[nil,false].none?                                 #=> true

one? -> bool

one? {|obj| ... } -> bool

ブロックを指定しない場合は、 Enumerable オブジェクトの要素のうちちょうど一つだけが真であれば、真を返します。そうでなければ偽を返します。

ブロックを指定した場合は、Enumerable オブジェクトの要素をブロックで評価した結果、一つの要素だけが真であれば真を返します。そうでなければ偽を返します。

%w{ant bear cat}.one? {|word| word.length == 4}   #=> true
%w{ant bear cat}.one? {|word| word.length >= 4}   #=> false
[ nil, true, 99 ].one?                            #=> false
[ nil, true, false ].one?                         #=> true

partition -> Enumerator

partition {|item| ... } -> [[object], [object]]

各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。各要素に対してブロックを評価して、その値が真であった要素の配列と、偽であった要素の配列の 2 つを配列に入れて返します。

ブロックを省略した場合は、各要素に対しブロックを評価し、上のようにその値が真であった要素の配列と、偽であった要素の配列のペアを返すような Enumerator を返します。

例:

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0].partition {|i| i % 3 == 0 }
 #=> [[9, 6, 3, 0], [10, 8, 7, 5, 4, 2, 1]]

pid -> Integer | nil

自身が IO.popen で作られたIOポートなら、子プロセスのプロセス ID を返します。それ以外は nil を返します。

[EXCEPTION] IOError:: 既に close されている場合に発生します。

pos -> Integer

tell -> Integer

ファイルポインタの現在の位置を整数で返します。

[EXCEPTION] IOError:: 既に close されている場合に発生します。

pos=(n)

ファイルポインタを指定位置に移動します。 IO#seek(n, IO::SEEK_SET) と同じです。

[PARAM] n:: 先頭からのオフセットを整数で指定します。
[EXCEPTION] IOError:: 既に close されている場合に発生します。

print(*arg) -> nil

引数を IO ポートに順に出力します。引数を省略した場合は、$_ を出力します。

[PARAM] arg:: Kernel.#print と同じです。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

printf(format, *arg) -> nil

C 言語の printf と同じように、format に従い引数を文字列に変換して、self に出力します。

第一引数に IO を指定できないこと、引数を省略できないことを除けば Kernel.#printf と同じです。

[PARAM] format:: Kernel.#printf と同じです。sprintf フォーマットを参照してください。
[PARAM] arg:: Kernel.#printf と同じです。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

[SEE_ALSO] Kernel.#printf

putc(ch) -> object

文字 ch を self に出力します。引数の扱いは Kernel.#putc と同じです。詳細はこちらを参照してください。ch を返します。

[PARAM] ch:: 出力したい文字を、文字列か文字コード(整数)で与えます。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

[SEE_ALSO] Kernel.#putc

puts(*obj) -> nil

各 obj を self に出力し、それぞれの後に改行を出力します。引数の扱いは Kernel.#puts と同じです。詳細はこちらを参照してください。

[PARAM] obj:: 出力したいオブジェクトを指定します。Kernel.#puts と同じです。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

$stdout.puts("this", "is", "a", "test", [1, [nil, 3]])

#=>
this
is
a
test
1
nil
3

[SEE_ALSO] Kernel.#puts

read(length = nil, outbuf = "") -> String | nil

length バイト読み込んで、その文字列を返します。

引数 length が指定された場合はバイナリ読み込みメソッド、そうでない場合はテキスト読み込みメソッドとして動作します。既に EOF に達していれば nil を返します。ただし、length に nil か 0 が指定されている場合は、空文字列 "" を返します。例えば、open(空ファイル) {|f| f.read } は "" となります。

[PARAM] length:: 読み込むサイズを整数で指定します。 nil が指定された場合、EOF までの全てのデータを読み込んで、その文字列を返します。
[PARAM] outbuf:: 出力用のバッファを文字列で指定します。IO#read は読み込んだデータをその文字列オブジェクトに上書きして返します。指定した文字列オブジェクトがあらかじめ length 長の領域であれば、余計なメモリの割当てが行われません。指定した文字列の長さが length と異なる場合、その文字列は一旦 length 長に拡張(あるいは縮小)されたあと、実際に読み込んだデータのサイズになります。
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: データの読み込みに失敗した場合に発生します。
[EXCEPTION] ArgumentError:: length が負の場合に発生します。

第二引数を指定した read の呼び出しでデータが空であった場合 (read が nil を返す場合)、outbuf は空文字列になります。

outbuf = "x" * 20;
io = File.open("/dev/null")
p io.read(10,outbuf)
p outbuf
=> nil
   ""

read_nonblock(maxlen, outbuf = "") -> String

IO をノンブロッキングモードに設定し、その後で read(2) システムコールにより長さ maxlen を上限として読み込み、文字列として返します。 EAGAIN, EINTR などは Errno::EXXX 例外として呼出元に報告されます。

発生した例外がErrno::EAGAIN、 Errno::EWOULDBLOCK である場合は、その例外オブジェクトに IO::WaitReadable が Object#extend されます。

なお、バッファが空でない場合は、read_nonblock はバッファから読み込みます。この場合、read(2) システムコールは呼ばれません。

このメソッドはノンブロッキングモードにする点を除いて IO#readpartial と同じであることに注意してください。

バイナリ読み込みメソッドとして動作します。既に EOF に達していれば EOFError が発生します。ただし、maxlen に 0 が指定されている場合は、空文字列 "" を返します。

[PARAM] maxlen:: 読み込む長さの上限を整数で指定します。
[PARAM] outbuf:: 文字列で指定します。IO#read_nonblock は読み込んだデータを outbuf に破壊的に格納し、返り値は outbuf となります。outbuf は一旦 maxlen 長に拡張(あるいは縮小)されたあと、実際に読み込んだデータのサイズになります。read(2) システムコールが 0 を返した場合は、空文字列になります。
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: read(2) システムコールの結果としてエラーが起きた場合に発生します。
[EXCEPTION] EOFError:: read(2) システムコールが 0 を返した場合に発生します。これは、IO が既に EOF に達していることを意味します。

readbyte -> Integer

IO から1バイトを読み込み整数として返します。既に EOF に達していれば EOFError が発生します。

[EXCEPTION] EOFError:: 既に EOF に達している場合に発生します。

readchar -> String

IO ポートから 1 文字読み込んで返します。 EOF に到達した時には EOFError が発生します。

テキスト読み込みメソッドとして動作します。 IO#getc との違いは EOF での振る舞いのみです。

[EXCEPTION] EOFError:: EOF に到達した時に発生します。
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

f = File.new("testfile")
p f.readchar                   #=> "い"
p f.readchar                   #=> "ろ"
p f.readchar                   #=> "は"
f.read
f.readchar                   #=> EOFError

[SEE_ALSO] IO#getc

readline(rs = $/) -> String

readline(limit) -> String

readline(rs, limit) -> String

一行読み込んで、読み込みに成功した時にはその文字列を返します。 EOF に到達した時には EOFError が発生します。

テキスト読み込みメソッドとして動作します。読み込んだ文字列を変数 $_ にセットします。IO#gets との違いは EOF での振る舞いのみです。

limit で最大読み込みバイト数を指定します。ただしマルチバイト文字が途中で切れないように余分に読み込む場合があります。

[PARAM] rs:: 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。
[PARAM] limit:: 最大の読み込みバイト数
[EXCEPTION] EOFError:: EOF に到達した時に発生します。
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

f = File.new("oneline_file")
f.readline                      #=> "This is line one\n"
$_                              #=> "This is line one\n"
f.readline                      #=> EOFError
$_                              #=> nil

[SEE_ALSO] $/, IO#gets

readlines(rs = $/) -> [String]

readlines(limit) -> [String]

readlines(rs = $/, limit) -> [String]

データを全て読み込んで、その各行を要素としてもつ配列を返します。既に EOF に達していれば空配列 [] を返します。

テキスト読み込みメソッドとして動作します。

limit で最大読み込みバイト数を指定します。ただしマルチバイト文字が途中で切れないように余分に読み込む場合があります。

[PARAM] rs:: 行の区切りを文字列で指定します。rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします(パラグラフモード)。
[PARAM] limit:: 最大の読み込みバイト数
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。

[SEE_ALSO] $/, IO#gets

readpartial(maxlen, outbuf = "") -> String

IO から長さ maxlen を上限として読み込み、文字列として返します。即座に得られるデータが存在しないときにはブロックしてデータの到着を待ちます。即座に得られるデータが 1byte でも存在すればブロックしません。

readpartial はブロックを最小限に抑えることによって、パイプ、ソケット、端末などのストリームに対して適切に動作するよう設計されています。 readpartial がブロックするのは次の全ての条件が満たされたときだけです。

IO オブジェクト内のバッファが空
ストリームにデータが到着していない
ストリームが EOF になっていない

これらの条件が満たされる場合、何らかのデータが到着するか EOF になるまで readpartial はブロックします。

readpartial の結果は以下のようになります。

バッファが空でなければ、そのバッファのデータを読み込んで返します。
ストリームにデータがあれば、ストリームからデータを読み込んで返します。
ストリームが EOF になっていれば、例外 EOFError を発生させます。

例えば、パイプに対しては次のように動作します。

r, w = IO.pipe           #               buffer          pipe content
w << "abc"               #               ""              "abc".
r.readpartial(4096)      #=> "abc"       ""              ""
r.readpartial(4096)      # バッファにもパイプにもデータがないのでブロックする

r, w = IO.pipe           #               buffer          pipe content
w << "abc"               #               ""              "abc"
w.close                  #               ""              "abc" EOF
r.readpartial(4096)      #=> "abc"       ""              EOF
r.readpartial(4096)      # 例外 EOFError 発生

r, w = IO.pipe           #               buffer          pipe content
w << "abc\ndef\n"        #               ""              "abc\ndef\n"
r.gets                   #=> "abc\n"     "def\n"         ""
w << "ghi\n"             #               "def\n"         "ghi\n"
r.readpartial(4096)      #=> "def\n"     ""              "ghi\n"
r.readpartial(4096)      #=> "ghi\n"     ""              ""

なお、readpartial は nonblock フラグに影響されません。つまり、nonblock フラグが設定されていて sysread であれば Errno::EAGAIN になる場合でもブロックします。

また、readpartial の挙動は sysread によく似ています。とくに、バッファが空の場合には同じ挙動を示します。ただし、EAGAIN および EINTR エラーは内部で発生したとしても通知されず、データが到着するまでブロックし続けます。

[PARAM] maxlen:: 読み込む長さの上限を整数で指定します。
[PARAM] outbuf:: 文字列で指定します。IO#readpartial は読み込んだデータを outbuf に破壊的に格納し、返り値は outbuf となります。outbuf は一旦 maxlen 長に拡張(あるいは縮小)されたあと、実際に読み込んだデータのサイズになります。IO が既に EOF に達していれば、空文字列になります。
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。
[EXCEPTION] EOFError:: IO が既に EOF に達していれば発生します。

recv(maxlen, flags = 0) -> String

ソケットからデータを受け取り、文字列として返します。 maxlen は受け取る最大の長さを指定します。 flags については recv(2) を参照してください。flags のデフォルト値は 0 です。flags の指定に必要な定数は Socket クラスで定義されています。(例: Socket::MSG_PEEK)

内部で呼び出す recv(2) が 0 を返した場合、このメソッドは "" を返します。この意味はソケットによって異なります。たとえば TCP では EOF を意味しますし、 UDP では空のパケットを読み込んだことを意味します。

[PARAM] maxlen:: 受け取る文字列の最大の長さを指定します。
[PARAM] flags:: recv(2) を参照してください。
[EXCEPTION] IOError:
[EXCEPTION] Errno::EXXX:: recvfrom(2) がエラーになった場合などに発生します。

例:

s1, s2 = UNIXSocket.pair
s1.write "a"
s1.close
p s2.recv(10, Socket::MSG_PEEK)   #=> "a"
p s2.recv(10)                     #=> "a"
p s2.recv(10)                     #=> ""

recv_nonblock(maxlen, flags = 0) -> String

ソケットをノンブロッキングモードに設定した後、 recvfrom(2) でソケットからデータを受け取ります。

引数、返り値は BasicSocket#recv と同じです。

recvfrom(2) がエラーになった場合、 EAGAIN, EINTR を含め例外 Errno::EXXX が発生します。

[PARAM] maxlen:: 受け取る文字列の最大の長さを指定します。
[PARAM] flags:: recv(2) を参照してください。
[EXCEPTION] IOError:
[EXCEPTION] Errno::EXXX:: recvfrom(2) がエラーになった場合などに発生します。

recvfrom(maxlen, flags=0) -> [String, Addrinfo]

ソケットからデータを受け取ります。

Socket#recv と同様ですが、返り値としてデータ文字列と相手ソケットのアドレスのペアが返されます。

flags には Socket::MSG_* という定数の bitwise OR を渡します。詳しくは recvfrom(2) を参照してください。

[PARAM] maxlen:: ソケットから受けとるデータの最大値
[PARAM] flags:: フラグ
[EXCEPTION] Errno::EXXX:: recvfrom(2) がエラーを報告した場合に発生します。詳しくは Errno と man を見てください。

例:

s1 = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
s2 = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
s1.bind(Socket.sockaddr_in(0, "0.0.0.0"))
s2.send("foo", 0, s1.getsockname)
mesg, sockaddr = s1.recvfrom(10)
p mesg                                    #=> "foo"
p sockaddr                                #=> "\002\000\200r\177\000\000\001\000\000\000\000\000\000\000\000"
p Socket.unpack_sockaddr_in(sockaddr)     #=> [32882, "127.0.0.1"]

recvfrom_nonblock(maxlen, flags=0) -> [String, Addrinfo]

ソケットをノンブロッキングモードに設定した後、 recvfrom(2) を呼び出します。

引数、返り値は Socket#recvfrom と同じです。

recvfrom(2) がエラーになった場合、 EAGAIN, EINTR を含め例外 Errno::EXXX が発生します。 Errno::EWOULDBLOCK、Errno::EAGAIN のような待ってからリトライすることが可能であることを意味する例外には、IO::WaitReadable が extend されています。

[PARAM] maxlen:: ソケットから受けとるデータの最大値
[PARAM] flags:: フラグ
[EXCEPTION] Errno::EXXX:: recvfrom(2) がエラーを報告した場合に発生します。詳しくは man を参照してください

recvmsg(maxmesglen=nil, flags=0, maxcontrollen=nil, opts={}) -> [String, Addrinfo, Integer, *Socket::AncillaryData]

recvmsg(2) を用いてメッセージを受け取ります。

このメソッドはブロックします。ノンブロッキング方式で通信したい場合は BasicSocket#recvmsg_nonblock を用います。

maxmesglen, maxcontrollen で受け取るメッセージおよび補助データ (Socket::AncillaryData)の最大長をバイト単位で指定します。省略した場合は必要なだけ内部バッファを拡大してデータが切れないようにします。

flags では Socket::MSG_* という名前の定数の biwsise OR を取ったものを渡します。

opts にはその他のオプションを渡します。今のところ :scm_right => bool というオプションのみ利用できます。このオプションに真を渡すと、 SCM_RIGHTS 制御メッセージを受け取ったときに、メッセージに含まれる IO オブジェクトを生成します。詳しくは Socket::AncillaryData#unix_rights を参照してください。

返り値は配列で得られます。

返り値の配列の最初の要素は受け取ったメッセージを表す文字列です。

2番目の要素は connection-less socket の場合には送り元のアドレスが Addrinfo オブジェクトとして含まれています。 TCP のような connection-oriented socket の場合は何が含まれているかはプラットフォーム依存です。

3番目の要素は受け取ったメッセージに付加されているフラグで、 Socket::MSG_* 定数の bitwise OR で表現されています。

残りの要素は補助データ(Socket::AncillaryData オブジェクト)です。

# UnixSocket#recv_io を recvmsg で実装する例
mesg, sender_sockaddr, rflags, *controls = sock.recvmsg(:scm_rights=>true)
controls.each {|ancdata|
  if ancdata.cmsg_is?(:SOCKET, :RIGHTS)
    return ancdata.unix_rights[0]
  end
}

[PARAM] maxmesglen:: 受け取るメッセージの最大長
[PARAM] flags:: フラグ
[PARAM] maxcontrollen:: 受け取る補助データの最大長
[PARAM] opts:: ハッシュオプション

recvmsg_nonblock(maxmesglen=nil, flags=0, maxcontrollen=nil, opts={}) -> [String, Addrinfo, Integer, *Socket::AncillaryData]

recvmsg(2) を用いてノンブロッキング方式でメッセージを受け取ります。

ブロッキングの有無以外は BasicSocket#recvmsg と同じです。詳しくはそちらを参照してください。

[PARAM] maxmesglen:: 受け取るメッセージの最大長
[PARAM] flags:: フラグ
[PARAM] maxcontrollen:: 受け取る補助データの最大長
[PARAM] opts:: ハッシュオプション

reject -> Enumerator

reject {|item| ... } -> [object]

各要素に対してブロックを評価し、その値が偽であった要素を集めた新しい配列を返します。条件を反転させた select です。

ブロックを省略した場合は、各要素に対しブロックを評価し偽になった値の配列を返すような Enumerator を返します。

例:

# 偶数を除外する (奇数を集める)
[1, 2, 3, 4, 5, 6].reject {|i| i % 2 == 0 }  # => [1, 3, 5]

[SEE_ALSO] Enumerable#select

remote_address -> Addrinfo

getpeername(2) で得られたリモートアドレス情報を Addrinfo オブジェクトとして返します。

返されたオブジェクトの Addrinfo#protocol は 0 を返すことに注意してください。

TCPSocket.open("www.ruby-lang.org", 80) {|s|
  p s.remote_address #=> #<Addrinfo: 221.186.184.68:80 TCP>
}

TCPServer.open("127.0.0.1", 1728) {|serv|
  c = TCPSocket.new("127.0.0.1", 1728)
  s = serv.accept
  p s.remote_address #=> #<Addrinfo: 127.0.0.1:36504 TCP>
}

[SEE_ALSO] BasicSocket#getpeername

reopen(io) -> self

自身を指定された io に繋ぎ換えます。

クラスも io に等しくなることに注意してください。 IO#pos, IO#lineno などは指定された io と等しくなります。

[PARAM] io:: 自身を繋ぎ換えたい IO オブジェクトを指定します。
[EXCEPTION] IOError:: 指定された io が close されている場合に発生します。

reopen(path) -> self

reopen(path, mode) -> self

path で指定されたファイルにストリームを繋ぎ換えます。

第二引数を省略したとき self のモードをそのまま引き継ぎます。 IO#pos, IO#lineno などはリセットされます。

[PARAM] path:: パスを表す文字列を指定します。
[PARAM] mode:: パスを開く際のモードを文字列で指定します。
[EXCEPTION] Errno::EXXX:: 失敗した場合に発生します。

[SEE_ALSO] Kernel.#open

reverse_each -> Enumerator

reverse_each {|element| ... } -> self

逆順に各要素に対してブロックを評価します。

内部で各要素を保持した配列を作ります。

ブロックを省略した場合は、各要素を逆順に辿る Enumerator を返します。

rewind -> 0

ファイルポインタを先頭に移動します。IO#lineno は 0 になります。

[EXCEPTION] IOError:: 既に close されている場合に発生します。

f = File.new("testfile")
f.readline               #=> "This is line one\n"
f.rewind                 #=> 0
f.lineno                 #=> 0
f.readline               #=> "This is line one\n"

seek(offset, whence = IO::SEEK_SET) -> 0

ファイルポインタを whence の位置から offset だけ移動させます。 offset 位置への移動が成功すれば 0 を返します。

[PARAM] offset:: ファイルポインタを移動させるオフセットを整数で指定します。
[PARAM] whence:: 値は以下のいずれかです。

IO::SEEK_SET: ファイルの先頭から (デフォルト)
IO::SEEK_CUR: 現在のファイルポインタから
IO::SEEK_END: ファイルの末尾から

[EXCEPTION] Errno::EXXX:: ファイルポインタの移動に失敗した場合に発生します。
[EXCEPTION] IOError:: 既に close されていた場合に発生します。

f = File.new("testfile")
f.seek(-13, IO::SEEK_END)   #=> 0
f.readline                  #=> "And so on...\n"

[SEE_ALSO] IO#sysseek

send(mesg, flags, dest_sockaddr = nil) -> Fixnum

ソケットを介してデータを送ります。flags に関しては send(2) を参照してください。connect していないソケットに対しては送り先である dest_sockaddr を指定する必要があります。実際に送ったデータの長さを返します。

dest_sockaddr には「ソケットアドレス構造体を pack した文字列」を指定します。

データの送信に失敗した場合は例外 Errno::EXXX が発生します。

[PARAM] mesg:: 送信するデータを文字列で指定します。
[PARAM] flags:: send(2) の flags を参照してください。
[PARAM] dest_sockaddr:: 「ソケットアドレス構造体を pack した文字列」を指定します。
[EXCEPTION] Errno::EXXX:: データの送信に失敗した場合に発生します。

例:

s = UDPSocket.new
sockaddr = Socket.sockaddr_in("discard", "localhost")
s.send("The king has donkey ears!", 0, sockaddr)

sendmsg(mesg, flags=0, dest_sockaddr=nil, *controls) -> Integer

sendmsg(2) を用いてメッセージを送ります。

このメソッドはブロックします。ノンブロッキング方式で通信したい場合は BasicSocket#sendmsg_nonblock を用います。

ソケットが connection-less の場合は dest_sockaddr で通信先のアドレスを指定しなければなりません。Socket.sockaddr_in の返り値や Addrinfo オブジェクトを引数として渡すことができます。

controls には補助データ(ancillary data)を渡します。 Socket::AncillaryData のインスタンスや 3要素(cmsg_level, cmsg_type, cmsg_data) の配列を用いることができます。

送ったバイト数を返します。

# UnixSocket#send_io の実装例
# use Socket::AncillaryData.
ancdata = Socket::AncillaryData.int(:UNIX, :SOCKET, :RIGHTS, io.fileno)
sock.sendmsg("a", 0, nil, ancdata)

# use 3-element array.
ancdata = [:SOCKET, :RIGHTS, [io.fileno].pack("i!")]
sock.sendmsg("\0", 0, nil, ancdata)

[PARAM] mesg:: メッセージ文字列
[PARAM] flags:: フラグ(Socket::MSG_* という定数の bitwise OR を取ったもの)
[PARAM] dest_sockaddr:: 通信先のアドレス
[PARAM] controls:: 補助データの配列

[SEE_ALSO] BasicSocket#sendmsg_nonblock

sendmsg_nonblock(mesg, flags=0, dest_sockaddr=nil, *controls) -> Integer

sendmsg(2) を用いてノンブロッキング方式でメッセージを送ります。

詳しくは BasicSocket#sendmsg を見てください。

[RETURN]: 送ったバイト数
[PARAM] mesg:: メッセージ文字列
[PARAM] flags:: フラグ(Socket::MSG_* という定数の bitwise OR を取ったもの)
[PARAM] dest_sockaddr:: 通信先のアドレス
[PARAM] controls:: 補助データの配列

[SEE_ALSO] BasicSocket#sendmsg

set_encoding(enc_str, opt={}) -> self

set_encoding(ext_enc) -> self

set_encoding(ext_enc, int_enc, opt={}) -> self

IO のエンコーディングを設定します。

引数が "A:B" のようにコロンで区切られた文字列の場合は、 A を外部エンコーディング、 B を内部エンコーディングに指定します。

引数が一つで、上のような形式でない場合には、それが外部エンコーディングと見なされます。

引数が2つの場合はそのそれぞれを外部エンコーディング、内部エンコーディングに設定します。

opt のハッシュで外部エンコーディングを内部エンコーディングに変換する際のオプションを指定します。詳しくは String#encode を参照してください。

[PARAM] enc_str:: エンコーディングを表す文字列を指定します。"A:B" のようにコロンで区切られた文字列を指定した場合 A が外部エンコーディング、B が内部エンコーディングを表します。
[PARAM] ext_enc:: 外部エンコーディングを表す文字列か Encoding オブジェクトを指定します。
[PARAM] int_enc:: 内部エンコーディングを表す文字列か Encoding オブジェクトを指定します。
[PARAM] opt:: エンコーディング変換のオプション

例:

io = File.open(file)
io.set_encoding("ASCII-8BIT", "EUC-JP")

setsockopt(level, optname, optval) -> 0

setsockopt(socketoption) -> 0

ソケットのオプションを設定します。setsockopt(2) を参照してください。

optval には文字列、整数、真偽値(true or false)を渡すことができます。文字列の場合には setsockopt(2) にはその文字列と長さが渡されます。整数の場合はintへのポインタが渡されます。 true/falseの場合は0/1という整数と解釈され、そのメモリ領域の intポインタを渡します。

引数が1つの場合は Socket::Option で設定値を表現します。

# 真偽値の場合
#setsockopt could be called like this:
sock.setsockopt(:SOCKET, :REUSEADDR, true)
sock.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
sock.setsockopt(Socket::Option.bool(:INET, :SOCKET, :REUSEADDR, true))

# 整数値の場合
#setsockopt could be called like this:
sock.setsockopt(:IP, :TTL, 255)
sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, 255)
sock.setsockopt(Socket::Option.int(:INET, :IP, :TTL, 255))

# より複雑な場合
optval = IPAddr.new("224.0.0.251").hton +
         IPAddr.new(Socket::INADDR_ANY, Socket::AF_INET).hton
sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, optval)

[PARAM] level:: setsockopt(2) の level を参照してください。
[PARAM] optname:: setsockopt(2) の option_name を参照してください。
[PARAM] optval:: 設定値
[PARAM] socketoption:: 設定値を表す Socket::Option オブジェクト
[EXCEPTION] Errno::EXXX:: オプションの設定に失敗した場合発生します。

[SEE_ALSO] BasicSocket#getsockopt

shutdown(how = Socket::SHUT_RDWR) -> 0

ソケットの以降の接続を終了させます。

how の値によって以下のように接続が終了します。

Socket::SHUT_RD: それ以降の受信が拒否されます
Socket::SHUT_WR: それ以降の送信が拒否されます
Socket::SHUT_RDWR: それ以降の送信、受信ともに拒否されます

how を省略すると Socket::SHUT_RDWR を指定したことになります。 shutdown(2) を参照してください。

[PARAM] how:: 接続の終了の仕方を Socket::SHUT_RD, Socket::SHUT_WR, Socket::SHUT_RDWR などで指定します。
[EXCEPTION] Errno::EXXX:: ソケットの以降の接続を終了操作が失敗した場合に発生します。
[EXCEPTION] ArgumentError:: how に範囲外の整数を入力した場合に発生します。
[EXCEPTION] SecurityError:: セーフレベルが 4 以上で、ソケットに汚染マークがついていない場合発生します。

slice_before(pattern) -> Enumerator

slice_before {|elt| bool } -> Enumerator

slice_before(initial_state) {|elt, state| bool } -> Enumerator

パターンがマッチした要素、もしくはブロックが真を返した要素から次にマッチする手前までをチャンク化(グループ化)したものを繰り返す Enumerator を返します。

パターンを渡した場合は各要素に対し === が呼び出され、それが真になったところをチャンクの先頭と見なします。ブロックを渡した場合は、各要素に対しブロックを適用し返り値が真であった要素をチャンクの先頭と見なします。

より厳密にいうと、「先頭要素」の手前で分割していきます。最初の要素の評価は無視されます。

各チャンクは配列として表現されます。

Enumerable#map のようなメソッドを使うこともできます。

# 偶数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_before(&:even?).to_a
# => [[0], [2], [4, 1], [2], [4, 5, 3, 1], [4], [2]]

# 奇数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_before(&:odd?).to_a
# => [[0, 2, 4], [1, 2, 4], [5], [3], [1, 4, 2]]

# ChangeLog のエントリーを順に取る
open("ChangeLog") {|f|
  f.slice_before(/\A\S/).each {|e| pp e}
}

# 上と同じだが、パターンでなくブロックを使う
open("ChangeLog") {|f|
  f.slice_before {|line| /\A\S/ === line }.each {|e| pp e}
}

# "svn proplist -R" の結果を分割する
# これは一要素が複数行にまたがっている

IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) {|f|
  f.lines.slice_before(/\AProp/).each {|lines| p lines }
}
#=> ["Properties on '.':\n", "  svn:ignore\n", "  svk:merge\n"]
#   ["Properties on 'goruby.c':\n", "  svn:eol-style\n"]
#   ["Properties on 'complex.c':\n", "  svn:mime-type\n", "  svn:eol-style\n"]
#   ["Properties on 'regparse.c':\n", "  svn:eol-style\n"]
#   ...

複数要素にわたる状態遷移が必要な場合は、ローカル変数でこれを実現することができます。例えば、連続に増える数値が3つ以上ある場合、これをまとめる処理をするためには以下のようにします。

a = [0,2,3,4,6,7,9]
prev = a[0]
p a.slice_before {|e|
  prev, prev2 = e, prev
  prev2 + 1 != e
}.map {|es|
  es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
}.join(",")
#=> "0,2-4,6,7,9"

しかし、ローカル変数を使うのが不適切な場合もあります。その場合、引数 initial_state に状態を保持するオブジェクトを渡すと、そのオブジェクトを Object#dup したオブジェクトを各要素ごとのブロック呼び出しの第2引数として渡します。

# word wrapping.
# this assumes all characters have same width.
def wordwrap(words, maxwidth)
  # if cols is a local variable, 2nd "each" may start with non-zero cols.
  words.slice_before(cols: 0) {|w, h|
    h[:cols] += 1 if h[:cols] != 0
    h[:cols] += w.length
    if maxwidth < h[:cols]
      h[:cols] = w.length
      true
    else
      false
    end
  }
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each {|ws| puts ws.join(" ") }
puts "-"*10
#=> ----------
#   1 2 3 4 5
#   6 7 8 9 10
#   11 12 13
#   14 15 16
#   17 18 19
#   20
#   ----------

以下は mbox を分割する例です。mbox 内の各メールは Unix From line で始まっています。そこで slice_before を用います。

# parse mbox
open("mbox") {|f|
  f.slice_before {|line|
    line.start_with? "From "
  }.each {|mail|
    unix_from = mail.shift
    i = mail.index("\n")
    header = mail[0...i]
    body = mail[(i+1)..-1]
    body.pop if body.last == "\n"
    fields = header.slice_before {|line| !" \t".include?(line[0]) }.to_a
    p unix_from
    pp fields
    pp body
  }
}

# split mails in mbox (slice before Unix From line after an empty line)
open("mbox") {|f|
  f.slice_before(emp: true) {|line,h|
    prevemp = h[:emp]
    h[:emp] = line == "\n"
    prevemp && line.start_with?("From ")
  }.each {|mail|
    mail.pop if mail.last == "\n"
    pp mail
  }
}

[PARAM] initial_state:: 状態を保持するオブジェクト

[SEE_ALSO] Enumerable#chunk

sort -> [object]

sort {|a, b| ... } -> [object]

全ての要素を昇順にソートした配列を生成して返します。

ブロックなしのときは <=> メソッドを要素に対して呼び、その結果をもとにソートします。

<=> 以外でソートしたい場合は、ブロックを指定します。この場合、ブロックの評価結果を元にソートします。ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。ブロックが整数以外を返したときは例外 TypeError が発生します。

Enumerable#sort は安定ではありません (unstable sort)。安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。詳しくは Enumerable#sort_by の項目を参照してください。

※ 比較結果が同じ要素は元の順序通りに並ぶソートを「安定なソート (stable sort)」と言います。

[SEE_ALSO] Enumerable#sort_by

sort_by -> Enumerator

sort_by {|item| ... } -> [object]

ブロックの評価結果を <=> メソッドで比較することで、self を昇順にソートします。ソートされた配列を新たに生成して返します。

つまり、以下とほぼ同じ動作をします。

class Array
  def sort_by
    self.map {|i| [yield(i), i] }.
       sort {|a, b| a[0] <=> b[0] }.
       map {|i| i[1]}
  end
end

Enumerable#sort と比較して sort_by が優れている点として、比較条件が複雑な場合の速度が挙げられます。 sort_by を使わない以下の例では比較を行う度に downcase が実行されます。従って downcase の実行速度が遅ければ sort の速度が致命的に低下します。

p ["BAR", "FOO", "bar", "foo"].sort {|a, b| a.downcase <=> b.downcase }

一方、次のように sort_by を使うと downcase の実行回数は要素数と同じです。つまり、その部分の実行時間は O(n) のオーダーです。

p ["BAR", "FOO", "bar", "foo"].sort_by {|v| v.downcase }

以下の、実行回数の検証結果を参照してみてください。

class Integer
  def count
    $n += 1
    self
  end
end

ary = []
1.upto(1000) {|v| ary << rand(v) }

$n = 0
ary.sort {|a,b| a.count <=> b.count }
p $n          # => 18200

$n = 0
ary.sort_by {|v| v.count }
p $n          # => 1000

Enumerable#sort_by は安定ではありません (unstable sort)。ただし、sort_by を以下のように使うと安定なソートを実装できます。

i = 0
ary.sort_by {|v| [v, i += 1] }

※ 比較結果が同じ要素は元の順序通りに並ぶソートを「安定なソート (stable sort)」と言います。

ブロックを省略した場合は、各要素をブロックで評価した値でソートした配列を返すような Enumerator を返します。

[SEE_ALSO] Enumerable#sort

stat -> File::Stat

ファイルのステータスを含む File::Stat オブジェクトを生成して返します。

[EXCEPTION] Errno::EXXX:: ステータスの読み込みに失敗した場合に発生します。
[EXCEPTION] IOError:: 既に close されていた場合に発生します。

[SEE_ALSO] File#lstat, File.stat, File.lstat

sync -> bool

現在の出力が同期モードならば true を返します。そうでない場合は false を返します。

[EXCEPTION] IOError:: 既に close されていた場合に発生します。

sync=(newstate)

自身を同期モードに設定すると、出力関数の呼出毎にバッファがフラッシュされます。

[PARAM] newstate:: 自身を同期モードに設定するかを boolean で指定します。
[EXCEPTION] IOError:: 既に close されていた場合に発生します。

sysaccept -> Array

接続したクライアントのファイル記述子とアドレスのペアを返すことを除けば Socket#accept と同じです。

sysread(maxlen, outbuf = "") -> String

read(2) を用いて入力を行ない、入力されたデータを含む文字列を返します。stdio を経由しないので gets や getc や eof? などと混用すると思わぬ動作をすることがあります。

[PARAM] maxlen:: 入力のサイズを整数で指定します。
[PARAM] outbuf:: 出力用のバッファを文字列で指定します。IO#sysread は読み込んだデータをその文字列オブジェクトに上書きして返します。指定した文字列オブジェクトがあらかじめ maxlen 長の領域であれば、余計なメモリの割当てが行われません。指定した文字列の長さが maxlen と異なる場合、その文字列は一旦 maxlen 長に拡張(あるいは縮小)されたあと、実際に読み込んだデータのサイズになります。
[EXCEPTION] IOError:: 自身が読み込み用にオープンされていなければ発生します。
[EXCEPTION] EOFError:: IO が既に EOF に達していれば発生します。
[EXCEPTION] Errno::EXXX:: データの読み込みに失敗した場合に発生します。

第二引数を指定した sysread の呼び出しでデータが空であった場合(sysread が例外 EOFError を発生させる場合)、 outbuf は空文字列になります。

outbuf = "x" * 20;
io = File.open("/dev/null")
p((io.sysread(10,outbuf) rescue nil))
p outbuf
=> nil
   ""

sysseek(offset, whence = IO::SEEK_SET) -> Integer

lseek(2) と同じです。IO#seek では、 IO#sysread, IO#syswrite と併用すると正しく動作しないので代わりにこのメソッドを使います。位置 offset への移動が成功すれば移動した位置(ファイル先頭からのオフセット)を返します。

書き込み用にバッファリングされた IO に対して実行すると警告が出ます。

File.open("/dev/zero") {|f|
  buf = f.read(3)
  f.sysseek(0)
}
# => -:3:in `sysseek': sysseek for buffered IO (IOError)

File.open("/dev/null", "w") {|f|
  f.print "foo"
  f.sysseek(0)
}
# => -:3: warning: sysseek for buffered IO

[PARAM] offset:: ファイルポインタを移動させるオフセットを整数で指定します。
[PARAM] whence:: 値は以下のいずれかです。

IO::SEEK_SET: ファイルの先頭から (デフォルト)
IO::SEEK_CUR: 現在のファイルポインタから
IO::SEEK_END: ファイルの末尾から

[EXCEPTION] IOError:: 読み込み用にバッファリングされた IO に対して実行すると発生します。既に close されていた場合にも発生します。
[EXCEPTION] Errno::EXXX:: 移動に失敗した場合に発生します。

[SEE_ALSO] IO#seek

syswrite(string) -> Integer

write(2) を用いて string を出力します。 string が文字列でなければ to_s による文字列化を試みます。実際に出力できたバイト数を返します。

stdio を経由しないので他の出力メソッドと混用すると思わぬ動作をすることがあります。

[PARAM] string:: 自身に書き込みたい文字列を指定します。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

take(n) -> Array

Enumerable オブジェクトの先頭から n 要素を配列として返します。

[PARAM] n:: 要素数を指定します。

a = [1, 2, 3, 4, 5, 0]
a.take(3)             # => [1, 2, 3]

take_while -> Enumerator

take_while {|element| ... } -> Array

Enumerable オブジェクトの要素を順に偽になるまでブロックで評価します。最初に偽になった要素の手前の要素までを配列として返します。

a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 }   # => [1, 2]

ブロックを省略した場合は、Enumerator オブジェクトを返します。

to_io -> self

self を返します。

ungetbyte(c) -> nil

指定したバイト列を書き戻します。

2バイト以上の書き戻しは仕様として保証しません。

このメソッドはバッファを経由しない読み出し(IO#sysread など) には影響しません。

[PARAM] c:: バイト列(文字列)、もしくは0から255までの整数

例:

f = File.new("testfile")   #=> #<File:testfile>
b = f.getbyte              #=> 0x38
f.ungetbyte(b)             #=> nil
f.getbyte                  #=> 0x38

ungetc(char) -> nil

指定された char を読み戻します。

[PARAM] char:: 読み戻したい1文字かそのコードポイントを指定します。
[EXCEPTION] IOError:: 読み戻しに失敗した場合に発生します。また、自身が読み込み用にオープンされていない時、自身がまだ一度も read されていない時に発生します。

write(str) -> Integer

IOポートに対して str を出力します。str が文字列でなければ to_s による文字列化を試みます。実際に出力できたバイト数を返します。

IO#syswrite を除く全ての出力メソッドは、最終的に "write" という名のメソッドを呼び出すので、このメソッドを置き換えることで出力関数の挙動を変更することができます。

[PARAM] str:: 自身に書き込みたい文字列を指定します。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: 出力に失敗した場合に発生します。

write_nonblock(string) -> Integer

IO をノンブロッキングモードに設定し、string を write(2) システムコールで書き出します。

write(2) が成功した場合、書き込んだ長さを返します。 EAGAIN, EINTR などは例外 Errno::EXXX として呼出元に報告されます。書き込んだバイト数(つまり返り値)は String#bytesize の値より小さい可能性があります。

発生した例外がErrno::EAGAIN、 Errno::EWOULDBLOCK である場合は、その例外オブジェクトに IO::WaitWritable が Object#extend されます。よって IO::WaitWritable を write_nonblock のリトライが必要かの判定に用いることができます。

[PARAM] string:: 自身に書き込みたい文字列を指定します。
[EXCEPTION] IOError:: 自身が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:: write(2) が失敗した場合に発生します。

zip(*lists) -> [[object]]

zip(*lists) {|v1, v2, ...| ...} -> nil

self と引数に渡した配列の各要素からなる配列の配列を生成して返します。生成される配列の要素数は self の要素数と同じです。

ブロック付きで呼び出した場合は、 self と引数に渡した配列の各要素を順番にブロックに渡します。

[PARAM] lists:: 配列を指定します。配列でない場合は to_ary メソッドにより配列に変換します。 to_ary メソッドが無い場合は each を試します。

例:

p (1..3).zip([4,5,6], [7,8,9])
    # => [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

p (1..2).zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B]]

p (1..5).zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B],
    #     [3, :c, :C], [4, nil, :D], [5, nil, nil]]

例:

p [1,2,3].zip([4,5,6], [7,8,9]) {|ary|
  p ary
}
    # => [1, 4, 7]
    #    [2, 5, 8]
    #    [3, 6, 9]
    #    nil

定数

AF_APPLETALK -> Integer

PF_APPLETALK -> Integer

Apple talk。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2linux), socket(2freebsd), ddp(7linux)

AF_ATM -> Integer

PF_ATM -> Integer

ATM。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2freebsd)

AF_AX25 -> Integer

PF_AX25 -> Integer

ITU-T X.25 / ISO-8208。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2linux)

AF_CCITT -> Integer

PF_CCITT -> Integer

[TODO]

CCITT プロトコル。 Socket.open の第一引数 domain に使用します。

AF_CHAOS -> Integer

PF_CHAOS -> Integer

[TODO]

MIT CHAOS プロトコル。 Socket.open の第一引数 domain に使用します。

AF_CNT -> Integer

PF_CNT -> Integer

[TODO]

Computer Network Technology。 Socket.open の第一引数 domain に使用します。

AF_COIP -> Integer

PF_COIP -> Integer

[TODO]

connection-oriented IP。 Socket.open の第一引数 domain に使用します。

AF_DATAKIT -> Integer

PF_DATAKIT -> Integer

[TODO]

datakit protocol。 Socket.open の第一引数 domain に使用します。

AF_DEC -> Integer

PF_DEC -> Integer

[TODO]

DECnet protocol。 Socket.open の第一引数 domain に使用します。

AF_DLI -> Integer

PF_DLI -> Integer

[TODO]

DEC Direct data link interface。 Socket.open の第一引数 domain に使用します。

AF_E164 -> Integer

[TODO]

CCITT E.164 recommendation。 Socket.open の第一引数 domain に使用します。

AF_ECMA -> Integer

PF_ECMA -> Integer

[TODO]

European computer manufacturers。 Socket.open の第一引数 domain に使用します。

AF_HYLINK -> Integer

PF_HYLINK -> Integer

[TODO]

NSC Hyperchannel。 Socket.open の第一引数 domain に使用します。

AF_IMPLINK -> Integer

PF_IMPLINK -> Integer

[TODO]

ARPANET IMP。 Socket.open の第一引数 domain に使用します。

AF_INET -> Integer

PF_INET -> Integer

IPv4。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] sys/socket.h(header), socket(2freebsd), ip(7linux)

AF_INET6 -> Integer

PF_INET6 -> Integer

IPv6。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] sys/socket.h(header), socket(2freebsd), ipv6(7linux)

AF_IPX -> Integer

PF_IPX -> Integer

IPX(Novell Internet Packet eXchange protocol)。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(3linux)

AF_ISDN -> Integer

PF_ISDN -> Integer

[TODO]

Integrated Services Digital Network。 Socket.open の第一引数 domain に使用します。

AF_ISO -> Integer

AF_OSI -> Integer

PF_ISO -> Integer

PF_OSI -> Integer

[TODO]

ISO Open Systems Interconnection protocols。 Socket.open の第一引数 domain に使用します。

AF_LAT -> Integer

PF_LAT -> Integer

[TODO]

Local Area Transport protocol。 Socket.open の第一引数 domain に使用します。

AF_LINK -> Integer

PF_LINK -> Integer

[TODO]

Link layer interface。 Socket.open の第一引数 domain に使用します。

AF_LOCAL -> Integer

AF_UNIX -> Integer

PF_LOCAL -> Integer

PF_UNIX -> Integer

Unix domain socket。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] sys/socket.h(header), unix(7linux)

AF_MAX -> Integer

対象のプラットフォーム上でのアドレスファミリーの最大の数値。

[SEE_ALSO] Socket::Constants::PF_MAX

AF_NATM -> Integer

PF_NATM -> Integer

[TODO]

Native ATM access。 Socket.open の第一引数 domain に使用します。

AF_NDRV -> Integer

PF_NDRV -> Integer

[TODO]

Network driver raw access。 Socket.open の第一引数 domain に使用します。

AF_NETBIOS -> Integer

PF_NETBIOS -> Integer

[TODO]

NetBIOS。 Socket.open の第一引数 domain に使用します。

AF_NETGRAPH -> Integer

PF_NETGRAPH -> Integer

Netgraph sockets。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2freebsd)

AF_NS -> Integer

PF_NS -> Integer

[TODO]

XEROX NS protocol。 Socket.open の第一引数 domain に使用します。

AF_PACKET -> Integer

PF_PACKET -> Integer

デバイスレベルインターフェース。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2linux), packet(7linux)

AF_PPP -> Integer

PF_PPP -> Integer

[TODO]

Point-to-Point Protocol。 Socket.open の第一引数 domain に使用します。

AF_PUP -> Integer

PF_PUP -> Integer

PUP(PARC Universal Packet)。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2freebsd)

AF_ROUTE -> Integer

PF_ROUTE -> Integer

[TODO]

Internal Routing protocol。 Socket.open の第一引数 domain に使用します。

[TODO]

AF_SIP -> Integer

PF_SIP -> Integer

[TODO]

Simple Internet Protocol。 Socket.open の第一引数 domain に使用します。

AF_SNA -> Integer

PF_SNA -> Integer

[TODO]

IBM SNA protocol。 Socket.open の第一引数 domain に使用します。

AF_SYSTEM -> Integer

PF_SYSTEM -> Integer

[TODO]

Socket.open の第一引数 domain に使用します。

AF_UNSPEC -> Integer

アドレスファミリー不定。

[SEE_ALSO] Socket.open, sys/socket.h(header)

AI_ADDRCONFIG -> Integer

Accept only if any address is assigned。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_ALL -> Integer

Allow all addresses。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_CANONNAME -> Integer

Fill in the canonical name。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_DEFAULT -> Integer

Default flags for getaddrinfo。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getipnodebyname(3freebsd)

AI_MASK -> Integer

[TODO]

AI_NUMERICHOST -> Integer

Prevent host name resolution。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_NUMERICSERV -> Integer

Prevent server name resolution。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_PASSIVE -> Integer

Get address to use with bind。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_V4MAPPED -> Integer

Accept IPv4-mapped IPv6 addresses。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getaddrinfo(3)

AI_V4MAPPED_CFG -> Integer

Accept IPv4 mapped addresses if the kernel supports it。

Socket.getaddrinfo, Addrinfo.getaddrinfo の引数 flags に渡す定数です。

[SEE_ALSO] getipnodebyname(3freebsd)

APPEND -> Integer

追記モードでファイルを開くときに指定します。 File.openで使用します。

BINARY -> Integer

ファイルをバイナリとして開きます。 open(2) で O_BINARYが指定できる場合に使えます。 File.openで使用します。

CREAT -> Integer

ファイルがなければ作成するよう指定します。 File.openで使用します。

DIRECT -> Integer

このファイルに対する I/O のキャッシュの効果を最小化しようとする。

このフラグを使うと、一般的に性能が低下する。しかしアプリケーションが独自にキャッシングを行っているような特別な場合には役に立つ。ファイルの I/O はユーザー空間バッファに対して直接行われる。 File::Constants::DIRECT フラグ自身はデータを同期で転送しようとはするが、 File::Constants::SYNC のようにデータと必要なメタデータの転送が保証されるわけではない。同期 I/O を保証するためには、 File::Constants::DIRECT に加えて File::Constants::SYNC を使用しなければならない。

File.openで使用します。

DSYNC -> Integer

ファイルをデータ同期モードで開きます。 open(2) で O_DSYNC が指定できる場合に使えます。 File.openで使用します。

EAI_ADDRFAMILY -> Integer

Address family for hostname not supported

getaddrinfo(3), getnameinfo(3) などのエラーコードです。対応する Socket.getaddrinfo, Addrinfo.getaddrinfo などはエラーを SocketError に変換するため、この定数は直接は利用しません。

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_AGAIN -> Integer

Temporary failure in name resolution

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_BADFLAGS -> Integer

Invalid flags

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_BADHINTS -> Integer

Invalid value for hints

EAI_FAIL -> Integer

Non-recoverable failure in name resolution

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_FAMILY -> Integer

Address family not supported

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_MAX -> Integer

EAI_* 定数の最大値。

EAI_MEMORY -> Integer

Memory allocation failure

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_NODATA -> Integer

No address associated with hostname

[SEE_ALSO] getaddrinfo(3linux)

EAI_NONAME -> Integer

Hostname nor servname, or not known

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_OVERFLOW -> Integer

Argument buffer overflow

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_PROTOCOL -> Integer

Resolved protocol is unknown

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_SERVICE -> Integer

Servname not supported for socket type

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_SOCKTYPE -> Integer

Socket type not supported

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EAI_SYSTEM -> Integer

System error returned in errno

getaddrinfo(3), getnameinfo(3) などのエラーコードです。対応する Socket.getaddrinfo, Addrinfo.getaddrinfo などはエラーを適当な例外に変換するため、この定数は直接は利用しません。

[SEE_ALSO] getaddrinfo(3linux), gai_strerror(3freebsd)

EXCL -> Integer

CREATと併用し、もしファイルが既にある場合には失敗します。 File.openで使用します。

FNM_CASEFOLD -> Integer

アルファベットの大小文字を区別せずにパターンマッチを行います。 File.fnmatch, Dir.globで使用します。

FNM_DOTMATCH -> Integer

ワイルドカード `*', `?', `[]' が先頭の `.' にマッチするようになります。 File.fnmatch, Dir.globで使用します。

1.8.0以前では、FNM_DOTMATCHという名前でした。

FNM_NOESCAPE -> Integer

エスケープ文字 `\' を普通の文字とみなします。 File.fnmatch, Dir.globで使用します。

FNM_PATHNAME -> Integer

ワイルドカード `*', `?', `[]' が `/' にマッチしなくなります。シェルのパターンマッチにはこのフラグが使用されています。 File.fnmatch, Dir.globで使用します。

FNM_SYSCASE -> Integer

case hold なファイルシステムの場合、FNM_CASEFOLD の値になり、そうでなければゼロの値になります。 File.fnmatch, Dir.globで使用します。

IFNAMSIZ -> Integer

IF_NAMESIZE -> Integer

インターフェース名文字列の最大長さ。

[SEE_ALSO] net/if.h(header)

INADDR_ALLHOSTS_GROUP -> Integer

Multicast group for all systems on this subset。 IPv4の 244.0.0.1 に対応する整数です。

[SEE_ALSO] http://www.iana.org/assignments/multicast-addresses/multicast-addresses.xml, [RFC5771]

INADDR_ANY -> Integer

A socket bound to INADDR_ANY receives packets from all interfaces and sends from the default IP address。 IPv4アドレスの 0.0.0.0 に対応する整数です。

[SEE_ALSO] netinet/in.h(header), ip(7linux), ip(4freebsd)

INADDR_BROADCAST -> Integer

The network broadcast address。 IPv4のブロードキャストアドレス 255.255.255.255 に対応する整数です。

[SEE_ALSO] netinet/in.h(header), ip(7linux), ip(4freebsd)

INADDR_LOOPBACK -> Integer

The loopback address。 IPv4のループバックアドレス 127.0.0.1 に対応する整数です。

[SEE_ALSO] ip(7linux), ip(4freebsd)

INADDR_MAX_LOCAL_GROUP -> Integer

The last local network multicast group。 IPv4の 244.0.0.255 に対応する整数です。

[SEE_ALSO] http://www.iana.org/assignments/multicast-addresses/multicast-addresses.xml, [RFC5771]

INADDR_NONE -> Integer

A bitmask for matching no valid IP address。エラーを表すアドレス値です。

INADDR_UNSPEC_GROUP -> Integer

The reserved multicast group。 IPv4の 244.0.0.0 に対応する整数です。

[SEE_ALSO] http://www.iana.org/assignments/multicast-addresses/multicast-addresses.xml, [RFC5771]

INET6_ADDRSTRLEN -> Integer

IPv6アドレス文字列の最大長。

[SEE_ALSO] netinet/in.h(header)

INET_ADDRSTRLEN -> Integer

IPv4アドレス文字列の最大長。

[SEE_ALSO] netinet/in.h(header)

IPPORT_RESERVED -> Integer

利用法が予約されているポート番号の最大値。

IPPORT_USERRESERVED -> Integer

ユーザが自由に利用して良いポート番号の最小値。

IPPROTO_AH -> Integer

IPv6 auth header。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_BIP -> Integer

[TODO]

BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_DSTOPTS -> Integer

IPv6 destination option。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_EGP -> Integer

[TODO]

Exterior Gateway Protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_EON -> Integer

[TODO]

ISO cnlp。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_ESP -> Integer

IPv6 Encapsulated Security Payload。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_FRAGMENT -> Integer

IPv6 fragmentation header。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_GGP -> Integer

[TODO]

Gateway to Gateway Protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_HELLO -> Integer

[TODO]

"hello" routing protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_HOPOPTS -> Integer

IPv6 hop-by-hop options。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_ICMP -> Integer

Control message protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] netinet/in.h(header) icmp(4freebsd), icmp(7linux)

IPPROTO_ICMPV6 -> Integer

Internet Control Message Protocol for IPv6。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] icmp6(4freebsd), [RFC2292]

IPPROTO_IDP -> Integer

[TODO]

XNS IDP。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_IGMP -> Integer

[TODO]

Group Management Protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_IP -> Integer

Internet protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] netinet/in.h(header) ip(4freebsd), ip(7linux)

IPPROTO_IPV6 -> Integer

Internet Protocol Version 6。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] netinet/in.h(header) ip6(4freebsd), ipv6(7linux) [RFC2292]

IPPROTO_MAX -> Integer

IPPROTO 定数の最大値。

IPPROTO_ND -> Integer

[TODO]

Sun net disk protocol BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_NONE -> Integer

IP6 no next header。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_PUP -> Integer

[TODO]

PARC Universal Packet protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_RAW -> Integer

Raw IP packets protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] netinet/in.h(header) ip(4freebsd), raw(7linux)

IPPROTO_ROUTING -> Integer

BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] [RFC2292]

IPPROTO_TCP -> Integer

Transmission control protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] netinet/in.h(header) tcp(4freebsd), tcp(7linux)

IPPROTO_TP -> Integer

[TODO]

ISO transport protocol class 4。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPPROTO_UDP -> Integer

User Datagram Protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

[SEE_ALSO] netinet/in.h(header) udp(4freebsd), udp(7linux)

IPPROTO_XTP -> Integer

[TODO]

Xpress Transport Protocol。 BasicSocket#getsockopt, BasicSocket#setsockopt の level 引数に使用します。

また、Socket.open の protocol 引数に渡す利用法もあります。

IPV6_CHECKSUM -> Integer

Byte offset into a packet where the checksum is located. BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, ip6(4freebsd), [RFC3542]

IPV6_DONTFRAG -> Integer

Don't fragment packets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_DSTOPTS -> Integer

Destination options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, ip6(4freebsd), ipv6(7linux), [RFC3542]

IPV6_HOPLIMIT -> Integer

Hop limit。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, ip6(4freebsd), ipv6(7linux), [RFC3542]

IPV6_HOPOPTS -> Integer

Hop-by-hop options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, ip6(4freebsd), ipv6(7linux), [RFC3542]

IPV6_JOIN_GROUP -> Integer

Join a multicast group。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPV6_LEAVE_GROUP -> Integer

Leave a multicast group。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPV6_MULTICAST_HOPS -> Integer

IPv6 multicast hop limit。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPV6_MULTICAST_IF -> Integer

IP6 multicast interface。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPV6_MULTICAST_LOOP -> Integer

IP6 multicast loopback。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPV6_NEXTHOP -> Integer

Next hop address。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_PATHMTU -> Integer

Retrieve current path MTU。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_PKTINFO -> Integer

Receive packet information with datagram。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, ip6(4freebsd), ipv6(7linux), [RFC3542]

IPV6_RECVDSTOPTS -> Integer

Receive all IP6 options for response。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RECVHOPLIMIT -> Integer

Receive hop limit with datagram。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RECVHOPOPTS -> Integer

Receive hop-by-hop options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RECVPATHMTU -> Integer

Receive current path MTU with datagram。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RECVPKTINFO -> Integer

Receive destination IP address and incoming interface。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RECVRTHDR -> Integer

Receive routing header。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RECVTCLASS -> Integer

Receive traffic class。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RTHDR -> Integer

Allows removal of sticky routing headers。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RTHDRDSTOPTS -> Integer

Allows removal of sticky destination options header。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_RTHDR_TYPE_0 -> Integer

Routing header type 0。

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_TCLASS -> Integer

Specify the traffic class。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_UNICAST_HOPS -> Integer

IPv6 unicast hop limit。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPV6_USE_MIN_MTU -> Integer

Use the minimum MTU size。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, [RFC3542]

IPV6_V6ONLY -> Integer

Only bind IPv6。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IPV6, netinet/in.h(header), ip6(4freebsd), ipv6(7linux), [RFC3493]

IPX_TYPE -> Integer

[TODO]

IP_ADD_MEMBERSHIP -> Integer

Add a multicast group membership

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_ADD_SOURCE_MEMBERSHIP -> Integer

Add a multicast group membership。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_BLOCK_SOURCE -> Integer

Block IPv4 multicast packets with a give source address。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_DEFAULT_MULTICAST_LOOP -> Integer

[TODO]

Default multicast loopback

IP_DEFAULT_MULTICAST_TTL -> Integer

[TODO]

Default multicast TTL

IP_DONTFRAG -> Integer

Don't fragment packets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_DROP_MEMBERSHIP -> Integer

Drop a multicast group membership。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_DROP_SOURCE_MEMBERSHIP -> Integer

Drop a multicast group membership。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_FREEBIND -> Integer

Allow binding to nonexistent IP addresses。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_HDRINCL -> Integer

Header is included with data。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_IPSEC_POLICY -> Integer

IPsec security policy。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, http://netbsd.gw.com/cgi-bin/man-cgi?ip++NetBSD-current

IP_MAX_MEMBERSHIPS -> Integer

Maximum number multicast groups a socket can join。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_MINTTL -> Integer

Minimum TTL allowed for received packets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_MSFILTER -> Integer

[TODO]

Multicast source filtering

IP_MTU -> Integer

The Maximum Transmission Unit of the socket。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_MTU_DISCOVER -> Integer

Path MTU discovery。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_MULTICAST_IF -> Integer

IP multicast interface。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_MULTICAST_LOOP -> Integer

IP multicast loopback。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_MULTICAST_TTL -> Integer

IP multicast TTL。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_ONESBCAST -> Integer

Force outgoing broadcast datagrams to have the undirected broadcast address。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_OPTIONS -> Integer

IP options to be included in packets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_PASSSEC -> Integer

[TODO]

Retrieve security context with datagram。

IP_PKTINFO -> Integer

Receive packet information with datagrams。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_PKTOPTIONS -> Integer

[TODO]

Receive packet options with datagrams

IP_PMTUDISC_DO -> Integer

Always send DF frames。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_PMTUDISC_DONT -> Integer

Never send DF frames。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_PMTUDISC_WANT -> Integer

Use per-route hints。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_PORTRANGE -> Integer

Set the port range for sockets with unspecified port numbers。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_RECVDSTADDR -> Integer

Receive IP destination address with datagram。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_RECVERR -> Integer

Enable extended reliable error message passing。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_RECVIF -> Integer

Receive interface information with datagrams。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_RECVOPTS -> Integer

Receive IP destination address with datagram。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_RECVRETOPTS -> Integer

[TODO]

Receive all IP options for response

IP_RECVSLLA -> Integer

[TODO]

Receive link-layer address with datagrams

IP_RECVTOS -> Integer

Receive TOS with incoming packets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_RECVTTL -> Integer

Receive IP TTL with datagrams。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux), ip(4freebsd)

IP_RETOPTS -> Integer

IP options to be included in datagrams。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_ROUTER_ALERT -> Integer

Notify transit routers to more closely examine the contents of an IP packet。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(7linux)

IP_SENDSRCADDR -> Integer

ource address for outgoing UDP datagrams。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_TOS -> Integer

IP type-of-service。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_TTL -> Integer

IP time-to-live。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd), ip(7linux)

IP_UNBLOCK_SOURCE -> Integer

Unblock IPv4 multicast packets with a give source address。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, ip(4freebsd)

IP_XFRM_POLICY -> Integer

[TODO]

LOCAL_CONNWAIT -> Integer

Retrieve peer credentials。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] ip(4freebsd)

LOCAL_CREDS -> Integer

Pass credentials to receiver。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] ip(4freebsd)

LOCAL_PEERCRED -> Integer

Pass credentials to receiver。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] ip(4freebsd)

LOCK_EX -> Integer

排他ロック。同時にはただひとつのプロセスだけがロックを保持できます。 File#flock で使用します。

LOCK_NB -> Integer

ロックの際にブロックしない。他の指定と or することで指定します。 File#flock で使用します。

LOCK_SH -> Integer

共有ロック。複数のプロセスが同時にロックを共有できます。 File#flock で使用します。

LOCK_UN -> Integer

アンロック。File#flock で使用します。

MCAST_BLOCK_SOURCE -> Integer

Block multicast packets from this source

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_EXCLUDE -> Integer

Exclusive multicast source filter

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_INCLUDE -> Integer

Inclusive multicast source filter

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_JOIN_GROUP -> Integer

Join a multicast group

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_JOIN_SOURCE_GROUP -> Integer

Join a multicast source group

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_LEAVE_GROUP -> Integer

Leave a multicast group

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_LEAVE_SOURCE_GROUP -> Integer

Leave a multicast source group

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_MSFILTER -> Integer

[TODO]

Multicast source filtering

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MCAST_UNBLOCK_SOURCE -> Integer

Unblock multicast packets from this source

BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_IP, Socket::Constants::IPPROTO_IPV6, [RFC3678]

MSG_COMPAT -> Integer

[TODO]

End of record

MSG_CONFIRM -> Integer

Confirm path validity

BasicSocket#send, BasicSocket#sendmsg の flags 引数に用います。

[SEE_ALSO] send(2linux)

MSG_CTRUNC -> Integer

Control data lost before delivery。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), send(2linux), recv(2linux), send(2freebsd), recv(2freebsd),

MSG_DONTROUTE -> Integer

Send without using the routing tables。

BasicSocket#send, BasicSocket#sendmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), send(2linux) send(2freebsd)

MSG_DONTWAIT -> Integer

This message should be non-blocking。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] send(2linux), recv(2linux), recv(2freebsd),

MSG_EOF -> Integer

Data completes connection。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] send(2freebsd)

MSG_EOR -> Integer

Data completes record。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), send(2), sendto(2), sendmsg(2), recv(2), recvfrom(2), recvmsg(2), send(2linux), recv(2linux), send(2freebsd), recv(2freebsd),

MSG_ERRQUEUE -> Integer

Fetch message from error queue

BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] recv(2linux)

MSG_FIN -> Integer

[TODO]

MSG_FLUSH -> Integer

[TODO]

Start of a hold sequence. Dumps to so_temp

MSG_HAVEMORE -> Integer

[TODO]

Data ready to be read

MSG_HOLD -> Integer

[TODO]

Hold fragment in so_temp

MSG_MORE -> Integer

Sender will send more

BasicSocket#send, BasicSocket#sendmsg の flags 引数に用います。

[SEE_ALSO] send(2linux)

MSG_NOSIGNAL -> Integer

Do not generate SIGPIPE

BasicSocket#send, BasicSocket#sendmsg の flags 引数に用います。

[SEE_ALSO] send(2linux), send(2freebsd)

MSG_OOB -> Integer

Process out-of-band data。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), send(2), sendto(2), sendmsg(2), recv(2), recvfrom(2), recvmsg(2), send(2linux), recv(2linux), send(2freebsd), recv(2freebsd),

MSG_PEEK -> Integer

Peek at incoming message。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), send(2), sendto(2), sendmsg(2), recv(2), recvfrom(2), recvmsg(2), send(2linux), recv(2linux), send(2freebsd), recv(2freebsd),

MSG_PROXY -> Integer

[TODO]

Wait for full request

MSG_RCVMORE -> Integer

[TODO]

Data remains in the current packet

MSG_RST -> Integer

[TODO]

MSG_SEND -> Integer

[TODO]

Send the packet in so_temp

MSG_SYN -> Integer

[TODO]

MSG_TRUNC -> Integer

Data discarded before delivery。

BasicSocket#send, BasicSocket#sendmsg, BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), send(2linux), recv(2linux), send(2freebsd), recv(2freebsd),

MSG_WAITALL -> Integer

Wait for full request or error

BasicSocket#recv, BasicSocket#recvmsg の flags 引数に用います。

[SEE_ALSO] sys/socket.h(header), recv(2), recvfrom(2), recvmsg(2), recv(2linux), recv(2freebsd),

NI_DGRAM -> Integer

The service specified is a datagram service (looks up UDP ports)。

Socket.getnameinfo, Addrinfo#getnameinfo の引数 flags に渡す定数です。

Socket.getnameinfo([ Socket::AF_INET, 514, "127.0.0.1"], Socket::NI_DGRAM)
# => ["localhost", "syslog"]
Socket.getnameinfo([ Socket::AF_INET, 514, "127.0.0.1"])
# => ["localhost", "shell"]

[SEE_ALSO] getnameinfo(3)

NI_MAXHOST -> Integer

getnameinfo(3) で用いるホスト名文字列の最大長さ。

[SEE_ALSO] getnameinfo(3linux)

NI_MAXSERV -> Integer

getnameinfo(3) で用いるサービス名文字列の最大長さ。

[SEE_ALSO] getnameinfo(3linux)

NI_NAMEREQD -> Integer

A name is required。名前解決できなかった場合にエラーを返すことを意味します。

Socket.getnameinfo, Addrinfo#getnameinfo の引数 flags に渡す定数です。

# ここでは 192.0.2.18 は名前解決できないアドレス
Addrinfo.tcp("192.0.2.18", 514).getnameinfo()
# =>["192.0.2.18", "shell"]
Addrinfo.tcp("192.0.2.18", 514).getnameinfo(Socket::NI_NAMEREQD)
# SocketError が発生する

[SEE_ALSO] getnameinfo(3)

NI_NOFQDN -> Integer

An FQDN is not required for local hosts, return only the local part.

Socket.getnameinfo, Addrinfo#getnameinfo の引数 flags に渡す定数です。

[SEE_ALSO] getnameinfo(3)

NI_NUMERICHOST -> Integer

Return a numeric address.

Socket.getnameinfo, Addrinfo#getnameinfo の引数 flags に渡す定数です。

[SEE_ALSO] getnameinfo(3)

NI_NUMERICSERV -> Integer

Return the service name as a digit string

Socket.getnameinfo, Addrinfo#getnameinfo の引数 flags に渡す定数です。

[SEE_ALSO] getnameinfo(3)

NOATIME -> Integer

ファイル読み込み時に atime を更新しません。 open(2) で O_ATIME が指定できる場合に使えます。 File.openで使用します。

atime が更新されないのは確実ではないということに注意してください。これは性能のためのオプションです。

NOCTTY -> Integer

自身がTTY制御しないようにTTYを開きます。 File.openで使用します。

NOFOLLOW -> Integer

ファイルがシンボリックリンクであった場合に例外を発生させます。 open(2) で O_NOFOLLOW が指定できる場合に使えます。 File.openで使用します。

NONBLOCK -> Integer

ファイルが利用可能じゃなくてもブロックしません。 File.openで使用します。

NULL -> String

NULLデバイスのファイル名です。

PF_KEY -> Integer

Internal key-management function。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2freebsd)

PF_MAX -> Integer

プロトコルファミリーの最大数。

[SEE_ALSO] Socket::Constants::AF_MAX

PF_PIP -> Integer

Help Identify PIP packets。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2freebsd)

PF_RTIP -> Integer

Help Identify RTIP packets。 Socket.open の第一引数 domain に使用します。

[SEE_ALSO] socket(2freebsd)

PF_UNSPEC -> Integer

プロトコルファミリー不定。

[SEE_ALSO] Socket::Constants::AF_UNSPEC, Socket.open

PF_XTP -> Integer

[TODO]

eXpress Transfer Protocol。

RDONLY -> Integer

読み込みのみのモードでファイルを開くときに指定します。 File.openで使用します。

RDWR -> Integer

読み書き両方のモードでファイルを開くときに指定します。 File.openで使用します。

RSYNC -> Integer

ファイルを読み込み時同期モードで開きます。 open(2) で O_RSYNC が指定できる場合に使えます。 File.openで使用します。

SCM_BINTIME -> Integer

Timestamp (bintime).

Socket::AncillaryData の type として利用します。

[SEE_ALSO] Socket::AncillaryData, Socket::AncillaryData#timestamp BasicSocket#sendmsg, BasicSocket#recvmsg

SCM_CREDENTIALS -> Integer

The sender's credentials

Socket::AncillaryData の type として利用します。

[SEE_ALSO] Socket::AncillaryData, BasicSocket#sendmsg, BasicSocket#recvmsg, unix(7linux)

SCM_CREDS -> Integer

Process credentials

Socket::AncillaryData の type として利用します。

[SEE_ALSO] Socket::AncillaryData, BasicSocket#sendmsg, BasicSocket#recvmsg, unix(4freebsd)

SCM_RIGHTS -> Integer

Access rights.

Socket::AncillaryData の type として利用します。

[SEE_ALSO] Socket::AncillaryData, Socket::AncillaryData#unix_rights BasicSocket#sendmsg, BasicSocket#recvmsg, unix(7linux), unix(4freebsd), sys/socket.h(header)

SCM_TIMESTAMP -> Integer

Timestamp (timeval).

Socket::AncillaryData の type として利用します。

[SEE_ALSO] Socket::AncillaryData, Socket::AncillaryData#timestamp BasicSocket#sendmsg, BasicSocket#recvmsg

SCM_TIMESTAMPNS -> Integer

Timestamp (timespec).

Socket::AncillaryData の type として利用します。

[SEE_ALSO] Socket::AncillaryData, Socket::AncillaryData#timestamp BasicSocket#sendmsg, BasicSocket#recvmsg

SCM_UCRED -> Integer

[TODO]

User credentials。

SEEK_CUR -> Fixnum

IO#seek を参照してください。

SEEK_END -> Fixnum

IO#seek を参照してください。

SEEK_SET -> Fixnum

IO#seek を参照してください。

SHUT_RD -> Integer

BasicSocket#shutdown の how 引数に使用します。

SHUT_RDWR -> Integer

BasicSocket#shutdown の how 引数に使用します。

SHUT_WR -> Integer

BasicSocket#shutdown の how 引数に使用します。

SOCK_DGRAM -> Integer

データグラム通信。 Socket.open の第二引数 type に使用します。

[SEE_ALSO] socket(2), Socket.open

SOCK_PACKET -> Integer

デバイスレベルインターフェース。Obsoleteであり使うべきではない。 Socket.open の第二引数 type に使用します。

[SEE_ALSO] packet(7linux), Socket.open

SOCK_RAW -> Integer

RAW ソケット。 Socket.open の第二引数 type に使用します。

[SEE_ALSO] sys/socket.h(header), socket(2linux), raw(7linux), Socket.open

SOCK_RDM -> Integer

信頼性のあるデータグラム通信。 Socket.open の第二引数 type に使用します。

[SEE_ALSO] socket(2linux), Socket.open

SOCK_SEQPACKET -> Integer

固定最大長を持つストリーム通信。 Socket.open の第二引数 type に使用します。

[SEE_ALSO] Socket.open, socket(2), socket(2linux), socket(2freebsd)

SOCK_STREAM -> Integer

ストリーム通信。 Socket.open の第二引数 type に使用します。

[SEE_ALSO] Socket.open, socket(2), socket(2linux), socket(2freebsd)

SOL_ATALK -> Integer

[TODO]

AppleTalk socket options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

SOL_AX25 -> Integer

[TODO]

AX.25 socket options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

SOL_IP -> Integer

IP socket options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

SOL_IP はポータブルではありません。 IPPROTO_IP のほうがよりポータブルです。

[SEE_ALSO] getsockopt(2), setsockopt(2), ip(7linux) Socket::Constants::IPPROTO_IP

SOL_IPX -> Integer

[TODO]

IPX socket options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

SOL_SOCKET -> Integer

Socket level options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

[SEE_ALSO] getsockopt(2), setsockopt(2), sys/socket.h(header), socket(7linux) getsockopt(2freebsd)

SOL_TCP -> Integer

TCP socket options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_TCP

SOL_UDP -> Integer

UDP socket options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第一引数(level)に使用します。

[SEE_ALSO] Socket::Constants::IPPROTO_UDP

SOMAXCONN -> Integer

Socket#listen の backlog の最大長。

[SEE_ALSO] sys/socket.h(header), listen(2)

SOPRI_BACKGROUND -> Integer

[TODO]

Background socket priority

SOPRI_INTERACTIVE -> Integer

[TODO]

Interactive socket priority

SOPRI_NORMAL -> Integer

Normal socket priority

[TODO]

SO_ACCEPTCONN -> Integer

Socket has had listen() called on it。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_ACCEPTFILTER -> Integer

set accept filter on listening socket。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] getsockopt(2freebsd), Socket::Constants::SOL_SOCKET

SO_ALLZONES -> Integer

[TODO]

Bypass zone boundaries。

SO_ATTACH_FILTER -> Integer

Attach socket filter。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] socket(7linux), http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob;f=Documentation/networking/filter.txt;hb=HEAD, Socket::Constants::SOL_SOCKET

SO_BINDTODEVICE -> Integer

Bind this socket to a particular device。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] socket(7linux), Socket::Constants::SOL_SOCKET

SO_BINTIME -> Integer

Timestamp (bintime)。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] getsockopt(2freebsd), Socket::Constants::SOL_SOCKET Socket::Constants::SO_TIMESTAMP, Socket::AncillaryData#timestamp

SO_BROADCAST -> Integer

Permit sending of broadcast messages。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_DEBUG -> Integer

Debug info recording。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_DETACH_FILTER -> Integer

Detach socket filter。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] socket(7linux), http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob;f=Documentation/networking/filter.txt;hb=HEAD, Socket::Constants::SOL_SOCKET

SO_DONTROUTE -> Integer

Send without using the routing tables。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_DONTTRUNC -> Integer

[TODO]

Retain unread data

SO_ERROR -> Integer

Get socket error status。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_KEEPALIVE -> Integer

Keep connections alive。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_LINGER -> Integer

Linger on close if data is present。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux),Socket::Constants::SOL_SOCKET

SO_MAC_EXEMPT -> Integer

[TODO]

Mandatory Access Control exemption for unlabeled peers。

SO_NKE -> Integer

[TODO]

socket-level Network Kernel Extension。

SO_NOSIGPIPE -> Integer

Don't SIGPIPE on EPIPE。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] getsockopt(2freebsd), Socket::Constants::SOL_SOCKET

SO_NO_CHECK -> Integer

[TODO]

Disable checksums。

SO_NREAD -> Integer

[TODO]

Get first packet byte count。

SO_OOBINLINE -> Integer

Leave received out-of-band data in-line。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_PASSCRED -> Integer

Receive SCM_CREDENTIALS messages。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] socket(7linux), unix(7linux), Socket::Constants::SOL_SOCKET

SO_PEERCRED -> Integer

The credentials of the foreign process connected to this socket。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] socket(7linux), unix(7linux), socketpair(2linux), Socket::Constants::SOL_SOCKET

SO_PEERNAME -> Integer

[TODO]

Name of the connecting user。

SO_PRIORITY -> Integer

The protocol-defined priority for all packets on this socket。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] socket(7linux), ip(7linux)

SO_RCVBUF -> Integer

Receive buffer size。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_RCVLOWAT -> Integer

Receive low-water mark。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_RCVTIMEO -> Integer

Receive timeout。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux)

SO_RECVUCRED -> Integer

[TODO]

Receive user credentials with datagram。

SO_REUSEADDR -> Integer

Allow local address reuse。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), bind(2), Socket::Constants::SOL_SOCKET

SO_REUSEPORT -> Integer

Allow local address and port reuse。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] getsockopt(2freebsd), Socket::Constants::SOL_SOCKET

SO_SECURITY_AUTHENTICATION -> Integer

[TODO]

SO_SECURITY_ENCRYPTION_NETWORK -> Integer

[TODO]

SO_SECURITY_ENCRYPTION_TRANSPORT -> Integer

[TODO]

SO_SNDBUF -> Integer

Send buffer size。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_SNDLOWAT -> Integer

Receive low-water mark。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_SNDTIMEO -> Integer

Send timeout。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_TIMESTAMP -> Integer

Receive timestamp with datagrams (timeval)。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET Socket::AncillaryData#timestamp

SO_TIMESTAMPNS -> Integer

[TODO]

Receive nanosecond timestamp with datagrams (timespec)。

[SEE_ALSO] Socket::Constants::SO_TIMESTAMP, Socket::AncillaryData#timestamp

SO_TYPE -> Integer

Get the socket type。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] sys/socket.h(header), getsockopt(2freebsd), socket(7linux), Socket::Constants::SOL_SOCKET

SO_USELOOPBACK -> Integer

[TODO]

Bypass hardware when possible。

SO_WANTMORE -> Integer

[TODO]

Give a hint when more data is ready。

SO_WANTOOBFLAG -> Integer

[TODO]

OOB data is wanted in MSG_FLAG on receive。

SYNC -> Integer

ファイルを同期モードで開きます。 open(2) で O_SYNCが指定できる場合に使えます。 File.openで使用します。

TCP_CORK -> Integer

Don't send partial frames。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_DEFER_ACCEPT -> Integer

Don't notify a listening socket until data is ready。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_INFO -> Integer

Retrieve information about this socket。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(4freebsd), tcp(7linux)

TCP_KEEPCNT -> Integer

Maximum number of keepalive probes allowed before dropping a connection。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_KEEPIDLE -> Integer

Idle time before keepalive probes are sent。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_KEEPINTVL -> Integer

Time between keepalive probes。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_LINGER2 -> Integer

Lifetime of orphaned FIN_WAIT2 sockets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_MAXSEG -> Integer

Set maximum segment size。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(4freebsd), tcp(7linux)

TCP_MD5SIG -> Integer

Use MD5 digests (RFC2385)。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(4freebsd), [RFC2385]

TCP_NODELAY -> Integer

Don't delay sending to coalesce packets。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(4freebsd), tcp(7linux), netinet/tcp.h(header)

TCP_NOOPT -> Integer

Don't use TCP options。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(4freebsd), tcp(7linux)

TCP_NOPUSH -> Integer

Don't push the last block of write。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(4freebsd), tcp(7linux)

TCP_QUICKACK -> Integer

Enable quickack mode。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_SYNCNT -> Integer

Number of SYN retransmits before a connection is dropped。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TCP_WINDOW_CLAMP -> Integer

Clamp the size of the advertised window。 BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] tcp(7linux)

TRUNC -> Integer

もしファイルが存在するなら、中身を抹消してサイズをゼロにします。 File.openで使用します。

UDP_CORK -> Integer

Don't send partial frames BasicSocket#getsockopt, BasicSocket#setsockopt の第2引数(optname)に使用します。

[SEE_ALSO] udp(7linux)

WRONLY -> Integer

書き込みのみのモードでファイルを開くときに指定します。 File.openで使用します。

class Socket