class Zlib::GzipReader + Enumerable + Zlib::GzipFile
クラスの継承リスト: Zlib::GzipReader < Enumerable < Zlib::GzipFile < Object < Kernel < BasicObject
要約
gzip 形式の圧縮ファイルを読み込むラッパークラスです。 IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを 持つオブジェクト) と関連付けて使用します。
require 'zlib' =begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } =end Zlib::GzipReader.open('hoge.gz') {|gz| print gz.read } f = File.open('hoge.gz') gz = Zlib::GzipReader.new(f) print gz.read gz.close
特異メソッド
new(io) -> Zlib::GzipReader
-
io と関連付けられた GzipReader オブジェクトを作成します。
GzipReader オブジェクトは io からデータを逐次リードして 解析/展開を行います。io には少なくとも、IO#read と 同じ動作をする read メソッドが定義されている必要があります。
- [PARAM] io:
- IO オブジェクト、もしくは少なくとも IO#read と同じ動作を する read メソッドが定義されているオブジェクト
- [EXCEPTION] Zlib::GzipFile::Error:
- ヘッダーの解析に失敗した場合発生します。
File.open('hoge.txt', "w") { |fp| fp.puts 'hoge' } f = File.open('hoge.txt') begin Zlib::GzipReader.new(f) rescue Zlib::GzipFile::Error => err puts "error", err #=> error #=> not in gzip format end
new(*args) -> ()
-
直接使用しません。 通常、具体的な読み書きをおこなうためには、 Zlib::GzipReader.new もしくは、 Zlib::GzipWriter.new を使用します。
[SEE_ALSO] Zlib::GzipReader.new, Zlib::GzipWriter.new
open(filename) -> Zlib::GzipReader
open(filename) {|gz| ... } -> object
-
filename で指定されるファイルを gzip ファイルとして オープンします。GzipReader オブジェクトを返します。 その他詳細は Zlib::GzipReader.new や Zlib::GzipReader.wrap と 同じです。
- [PARAM] filename:
- gzip ファイル名を文字列で指定します。
require 'zlib' =begin # hoge.gz がない場合はこれで作成する。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } =end Zlib::GzipReader.open('hoge.gz'){|gz| print gz.read }
open(*args) {|gz| ... } -> ()
-
直接使用しません。 通常、具体的な読み書きをおこなうためには、 Zlib::GzipReader.open もしくは、Zlib::GzipWriter.open を使用します。
[SEE_ALSO] Zlib::GzipReader.open, Zlib::GzipWriter.open
wrap(io) -> Zlib::GzipReader
wrap(io) {|gz| ... } -> object
-
io と関連付けられた GzipReader オブジェクトを作成します。
ブロックが与えられた場合は、それを引数としてブロックを実行します。 ブロックの実行が終了すると、GzipReader オブジェクトは自動的に クローズされます。関連付けられている IO オブジェクトまで クローズしたくない時は、ブロック中で Zlib::GzipFile#finish メソッドを呼び出して下さい。
- [PARAM] io:
- IO オブジェクトを指定します。
require 'zlib' =begin # hoge.gz がない場合はこれで作成する。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } =end f = File.open('hoge.gz') Zlib::GzipReader.wrap(f){|gz| print gz.read } p f.closed? #=> true f = File.open('hoge.gz') Zlib::GzipReader.wrap(f){|gz| print gz.read gz.finish } p f.closed? #=> false
wrap(*args) {|gz| ... } -> ()
-
直接使用しません。 通常、具体的な読み書きをおこなうためには、 Zlib::GzipReader.wrap もしくは、Zlib::GzipWriter.wrap を使用します。
[SEE_ALSO] Zlib::GzipReader.wrap,Zlib::GzipWriter.wrap
インスタンスメソッド
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
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:
- 予約されている値を用いた場合に発生します
close -> IO
-
GzipFile オブジェクトをクローズします。このメソッドは 関連付けられている IO オブジェクトの close メソッドを呼び出します。 関連付けられている IO オブジェクトを返します。
closed? -> bool
to_io -> IO
-
IO クラスの同名メソッドと同じ。
[SEE_ALSO] IO#to_io, IO#closed?
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]
comment -> String | nil
-
gzip ファイルのヘッダーに記録されているコメントを返します。 コメントが存在しない場合は nil を返します。
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
crc -> Integer
-
圧縮されていないデータの CRC 値を返します。
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
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(rs = $/) {|line| ... } -> self
each_line(rs = $/) {|line| ... } -> self
each(rs = $/) -> Enumerator
each_line(rs = $/) -> Enumerator
-
IO クラスの同名メソッドIO#each, IO#each_lineと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] rs:
- 行の区切りを文字列で指定します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' gz.puts 'fuga' } =end Zlib::GzipReader.open('hoge.gz') { |gz| gz.each { |line| puts line } }
[SEE_ALSO] IO#each, IO#each_line
each_byte {|byte| ... } -> nil
each_byte -> Enumerator
-
IO クラスの同名メソッドIO#each_byteと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } =end Zlib::GzipReader.open('hoge.gz') { |gz| gz.each_byte { |b| printf "%d -> %c\n", b, b } } #=> 104 -> h #=> 111 -> o #=> 103 -> g #=> 101 -> e #=> 10 ->
[SEE_ALSO] IO#each_byte
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_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
-
圧縮データの終端に達した場合真を返します。 フッターが読み込まれていなくても真を返すことに注意して下さい。
=begin # hoge.gz がない場合はこれで作成する。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' gz.puts 'fuga' gz.puts 'foga' } =end Zlib::GzipReader.open('hoge.gz'){|gz| gz.each_line{|line| puts line } p gz.eof? #=> true }
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 を返します。
finish -> IO
-
GzipFile オブジェクトをクローズします。Zlib::GzipFile#closeと違い、 このメソッドは関連付けられている IO オブジェクトの close メソッドを 呼び出しません。関連付けられている IO オブジェクトを返します。
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) #=> []
getc -> Fixnum | nil
-
IO クラスの同名メソッドIO#getcと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } =end Zlib::GzipReader.open('hoge.gz') { |gz| while c = gz.getc puts c end } #=> 104 #=> 111 #=> 103 #=> 101 #=> 10
[SEE_ALSO] IO#getc
gets(rs = $/) -> String | nil
-
IO クラスの同名メソッドIO#getsと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] rs:
- 行の区切りを文字列で指定します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' gz.puts 'fuga' } =end Zlib::GzipReader.open('hoge.gz') { |gz| while l = gz.gets puts l end } #=> hoge #=> fuga
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"
level -> Integer
-
圧縮レベルを返します。
lineno -> Fixnum | Bignum
-
IO クラスの同名メソッドIO#linenoと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'h' gz.puts 'o' gz.puts 'g' gz.puts 'e' } =end Zlib::GzipReader.open('hoge.gz') { |gz| while l = gz.gets l.chomp! printf "%s %d\n", l, gz.lineno end } #=> h 1 #=> o 2 #=> g 3 #=> e 4
[SEE_ALSO] IO#lineno
lineno=(num)
-
IO クラスの同名メソッドIO#lineno=と同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] num:
- 新たな行番号を整数で指定します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'h' gz.puts 'o' gz.puts 'g' gz.puts 'e' } =end Zlib::GzipReader.open('hoge.gz') { |gz| while l = gz.gets l.chomp! gz.lineno = 1000 if l == "o" printf "%s %d\n", l, gz.lineno end } #=> h 1 #=> o 1001 #=> g 1002 #=> e 1003
[SEE_ALSO] IO#lineno=
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
mtime -> Time
-
gzip ファイルのヘッダーに記録されている最終更新時間を返します。
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
orig_name -> String | nil
-
gzip ファイルのヘッダーに記録されている元ファイル名を返します。 ファイル名が記録されていない場合は nil を返します。
os_code -> Integer
-
gzip ファイルのヘッダーに記録されている OS コード番号を返します。
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]]
path -> String
-
関連付けられている IO オブジェクトのパスを返します。 このメソッドは IO オブジェクトが path というメソッドを持つ場合のみ定義されます。
pos -> Fixnum
tell -> Fixnum
-
現在までに展開したデータの長さの合計を返します。 ファイルポインタの位置ではないことに注意して下さい。
Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } Zlib::GzipReader.open('hoge.gz'){|gz| while c = gz.getc printf "%c, %d\n", c, gz.pos end } # 実行例 #=> h, 1 #=> o, 2 #=> g, 3 #=> e, 4 #=> #=> , 5
read(length = nil) -> String | nil
-
IO クラスの同名メソッドIO#readと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] length:
- 読み込む文字列の文字数を整数で指定します。 省略した場合は、全てのデータを読み込みます。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge_fuga' } =end Zlib::GzipReader.open('hoge.gz') { |gz| p gz.read(4) #=> "hoge" p gz.read #=> "_fuga\n" p gz.read(1) #=> nil }
[SEE_ALSO] IO#read
readchar -> Fixnum
-
IO クラスの同名メソッドIO#readcharと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [EXCEPTION] EOFError:
- EOF に到達したとき発生します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' } =end Zlib::GzipReader.open('hoge.gz') { |gz| begin puts gz.readchar rescue EOFError => err puts err break end while true } #=> 104 #=> 111 #=> 103 #=> 101 #=> 10 #=> end of file reached
readline(rs = $/) -> String
-
IO クラスの同名メソッドIO#readlineと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] rs:
- 行の区切りを文字列で指定します。
- [EXCEPTION] EOFError:
- EOF に到達したとき発生します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' gz.puts 'fuga' } =end Zlib::GzipReader.open('hoge.gz') { |gz| begin puts gz.readline rescue EOFError => err puts err break end while true } #=> hoge #=> fuga #=> end of file reached
[SEE_ALSO] IO#readline
readlines(rs = $/) -> Array
-
IO クラスの同名メソッドIO#readlinesと同じです。
但し、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] rs:
- 行の区切りを文字列で指定します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合は下記で作成できる。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' gz.puts 'fuga' } =end Zlib::GzipReader.open('hoge.gz') { |gz| p gz.readlines #=> ["hoge\n", "fuga\n"] }
[SEE_ALSO] IO#readlines
readpartial(maxlen, outbuf = nil) -> String
-
IO クラスの同名メソッド IO#readpartial と同じです。
- [PARAM] maxlen:
- 読み込む長さの上限を整数で指定します。
- [PARAM] outbuf:
- 文字列で指定します。読み込んだデータを outbuf に破壊的に格納し、 返り値は outbuf となります。outbuf は一旦 maxlen 長に拡張(あるいは縮小)されたあと、 実際に読み込んだデータのサイズになります。
- [EXCEPTION] ArgumentError:
- maxlen に負の値が入力された場合発生します。
[SEE_ALSO] IO#readpartial
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
reverse_each -> Enumerator
reverse_each {|element| ... } -> self
-
逆順に各要素に対してブロックを評価します。
内部で各要素を保持した配列を作ります。
ブロックを省略した場合は、各要素を逆順に辿る Enumerator を返します。
rewind -> 0
-
ファイルポインタを Zlib::GzipReader.new を呼び出した直後の 時点に戻します。関連付けられている IO オブジェクトに seek メソッドが定義されている必要があります。
=begin # hoge.gz がない場合はこれで作成する。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.puts 'hoge' gz.puts 'fuga' } =end gz = Zlib::GzipReader.open('hoge.gz') puts gz.gets #=> hoge puts gz.gets #=> fuga gz.rewind #=> 0 puts gz.gets #=> hoge gz.close
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
sync -> bool
sync=(flag)
-
IO クラスと同じ。flag が真の時、関連付けられている IO オブジェクトが flush メソッドを持っていなければなりません。 また、true にすると圧縮率が著しく低下します。
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 オブジェクトを 返します。
ungetc(char) -> nil
-
IO クラスの同名メソッド IO#ungetc と同じです。
IO クラスの同名メソッドと同じですが、gzip ファイル中に エラーがあった場合 Zlib::Error 例外や Zlib::GzipFile::Error 例外が発生します。
gzip ファイルのフッターの処理に注意して下さい。 gzip ファイルのフッターには圧縮前データのチェックサムが 記録されています。GzipReader オブジェクトは、次の時に展開した データとフッターの照合を行い、エラーがあった場合は Zlib::GzipFile::NoFooter, Zlib::GzipFile::CRCError, Zlib::GzipFile::LengthError 例外を発生させます。
- EOF (圧縮データの最後) を越えて読み込み要求を受けた時。 すなわち Zlib::GzipReader#read, Zlib::GzipReader#gets メソッド等が nil を返す時。
- EOF まで読み込んだ後、Zlib::GzipFile#close メソッドが 呼び出された時。
- EOF まで読み込んだ後、Zlib::GzipReader#unused メソッドが 呼び出された時。
- [PARAM] char:
- 読み戻したい1文字かそのコードポイントを指定します。
- [EXCEPTION] Zlib::Error:
- Zlib::Error を参照
- [EXCEPTION] Zlib::GzipFile::Error:
- Zlib::GzipFile::Errorを参照
- [EXCEPTION] Zlib::GzipFile::NoFooter:
- Zlib::GzipFile::NoFooterを参照
- [EXCEPTION] Zlib::GzipFile::CRCError:
- Zlib::GzipFile::CRCErrorを参照
- [EXCEPTION] Zlib::GzipFile::LengthError:
- Zlib::GzipFile::LengthErrorを参照
=begin # hoge.gz がない場合はこれで作成する。 Zlib::GzipWriter.open('hoge.gz') { |gz| gz.print 'hogefuga' } =end Zlib::GzipReader.open('hoge.gz') { |gz| begin c1 = gz.getc c2 = gz.getc break if c2.nil? printf "%c -> %c\n", c1, c2 gz.ungetc(c2) end while true } #=> h -> o #=> o -> g #=> g -> e #=> e -> f #=> f -> u #=> u -> g #=> g -> a
[SEE_ALSO] IO#ungetc
unused -> String | nil
-
gzip フォーマットの解析のために読み込んだ余剰のデータを返します。 gzip ファイルが最後まで解析されていない場合は nil を返します。
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