[Ruby]Class毎のよく使う操作をまとめたので見てくれ！！

Class一覧

Numeric

数値クラス(Integer等)のトップクラスです。

# ゼロかどうか
0.zero? #=> true

# ゼロの場合はnil、それ以外はselfを返す
0.nonzero? #=> nil
3.nonzero? #=> 3

# 数値クラスの確認
100.integer? #=> true
3.real? #=> false

# 四則演算
1 + 1 #=> 2
2-1 #=> 1
2 * 2 #=> 4
10 / 2 #=> 5

# 余り
10 % 3 #=> 1

# べき乗
10 ** 2 #=> 100

# 比較演算
1 == 1 #=> true(等しい)
1 != 1 #=> false(等しくない)
10 > 1 #=> true(右辺より左辺が大きい)
10 >= 1 #=> true(右辺より左辺が大きい、または等しい)
10 < 1 #=> false(右辺より左辺が小さい)
10 <= 1 #=> false(右辺より左辺が小さい、または等しい)

# スペースシップ(左辺が右辺よりも小さければ負の値、大きければ正の値、等しければ0)
1 <=> 2 #=> -1
1 <=> 1 #=> 0
2 <=> 1 #=> 1

# 四捨五入
1.4.round #=> 1

# 切り捨て
1.4.floor #=> 1

# 切り上げ
1.4.ceil #=> 2

# 繰り返し
## ○〜×まで繰り返す
1.step 3 do |num|
  puts num
end #=> 1,2,3

## n回繰り返す
1.upto 3 do |num|
  puts num
end #=> 1,2,3

3.time do |num|
  puts num
end #=> 0,1,2,3

# 奇数か
1.odd? #=> true

# 偶数か
2.even? #=> true

# 次の値
1.next #=> 2
1.succ #=> 2

# 前の値
3.pred #=> 2

# 整数を文字列に変換
100.to_s #=> '100'

# 有理数の表現(分数)
r = Rational(1, 3) #=> (1/3)

## 分母を取得
r.denominator #=> 3

## 分子を取得
r.numerator #=> 1

# 有理数に変換
100.to_r #=> (100/1)

# 複素数(2乗したら0未満になる数)
c = Complex(2, 3)

## 実部を取得
c.real #=> 2

## 虚部を取得
c.imaginary #=> 3

String

文字列を表すクラス。

# 空文字か
''.empty? #=> true

# 長さを測定
'あいうえお'.length #=> 5
'あいうえお'.size #=> 5

# バイト数を測定
'ほげほげ'.bytesize #=> 12

# 指定した文字列を含んでいるか
'あいうえお'.include?('あ') #=> true

# 指定した文字列から始まるか
'あいうえお'.start_with?('あ') #=> true

# 文字列の連結
'おは' + 'よう' #=> 'おはよう'

# 文字列をn回繰り返し
'おはよう' * 3 #=> 'おはようおはようおはよう'

# 任意の位置の文字列を取得
## 位置を指定
'あいうえお'.slice(0) #=> 'あ'

## 取得位置からn文字数分取得
'あいうえお'.slice(0, 2) #=> 'あいう'

## 範囲を指定
'あいうえお'.slice(0..2) #=> 'あいう'

# 空白文字を削除
'あいうえお '.strip #=> 'あいうえお'

# 末尾を削除
'あいうえお '.chop #=> 'あいうえ'

# 重複部分を削除
'あああああいうえお'.squeeze #=> 'あいうえお'

# 小文字に変換
'ABC'.downcase #=> 'abc'

# 大文字に変換
'abc'.upcase #=> 'ABC'

# 大文字、小文字を入れ替える
'AbC'.swapcase #=>'aBc'

# 先頭のみ大文字にする
'nAme'.capitalize #=> 'Title'

# 最初にマッチした文字列を置換
'24-1-365'.sub(/[0-9]+/, 'x') #=> 'x4-1-365'

# マッチした文字列全てを置換
'24-1-365'.gsub(/[0-9]+/, 'x') #=> 'x-x-x'

# マッチした文字列全てを処理してから置換
'24-1-365'.sub(/[0-9]+/) { |str| str.to_i.next } #=> '25-2-366'

# 特定の文字をセパレータとして配列へ変換
'あいうえお, アイウエオ, aiueo'.split(',') #=> ['あいうえお', 'アイウエオ', 'aiueo']

# 文字列の反転
'あいうえお'.reverse #=> 'おえういあ'

# 文字ごとの繰り返し
'あいうえお'.each_char { |c| print "#{c}ー" } #=> 'あーいーうーえーおー'

# エンコーディング
'あいうえお'.encoding #=> #<Encoding:UTF-8>

Enumerable

オブジェクトの集まりを自在に操るクラス。

# 繰り返し処理
## インクリメントされる値と一緒に繰り返す
%w(ABC abc).each_with_index do |name, index|
  puts "#{index}: #{name}"
end #=> '0: ABC', '1: abc'

## 末尾から逆に繰り返す
(1..3).reverse_each do |val|
  puts val
end #=> '3', '2', '1'

## 要素をn個ずつ区切って繰り返す
(1..5).each_slice(2) do |a, b|
  p [a, b]
end #=> '[1, 2]', '[3. 4]', '[5, nil]'

## n個の連続した要素を1つずつずらしながら繰り返す
(1..4).each_cons(2) do |a, b|
  p [1, b]
end #=> '[1, 2]', '[2, 3]', '[3, 4]'

## 要素を先頭から末尾まで永遠に繰り返す
(1..3).cycle do |n|
  puts n
end #=> '1', '2', '3'....

# 各要素に処理してから配列を作成
['ruby', 'rails'].map {|str| str.upcase } #=> ['RUBY', 'RAILS']

# 全ての要素が真ならtrue、偽ならfalse
[true, true].all? #=> true

# 全ての要素が偽ならtrue、真ならfalse
[false, false].none? #=> true

# 1つでも真があればtrueを返す
[true, false].any? #=> true

# 1つだけ真があればtrueを返す
[true, false, false].any? #=> true
[true, true, false].any? #=> false

# 正規表現にマッチする要素を取得
%w(Rails ruby php).grep(/r/i) #=> ['Rails', 'ruby']
['a', 'b', 1, 2].grep(String) #=> ['a', 'b']

# 戻り値が最初に真になった値を返す
[4, 2, 3].detect {|v| v.even? } #=> 4
[4, 2, 3].find {|v| v.even? } #=> 4

# 戻り値が真となる全ての値を返す
[4, 2, 3].select {|v| v.even? } #=> [4, 2]
[4, 2, 3].find_all {|v| v.even? } #=> [4, 2]

# 戻り値が偽となる全ての値を返す
[4, 2, 3].reject {|v| v.even? } #=> [3]

# 先頭から任意の数の要素を返す
[1, 2, 3, 4].take(2) #=> [1, 2]

# 先頭から任意の数をスキップした残りの要素を返す
[1, 2, 3, 4].drop(2) #=> [3, 4]

# 最初に偽を返すまでの要素を返す
[1, 2, 3, 4].take_while {|n| n < 3 } #=> [1, 2]

# 最初に偽を返した後の要素を返す
[1, 2, 3, 4].drop_while {|n| n < 3 } #=> [3, 4]

# 畳み込み演算
[4, 4, 2, 3].inject(1) do |result, num|
  result + num
end #=> 14

# 要素を繰り返しながら1つのオブジェクトを更新する
%w('rails', 'ruby', 'php').each_with_index({}) do |name, result|
  result[name] = name.length
end #=> { rails: 5, ruby: 4, php: 3 }

# 要素のグルーピング
[1, 2.0, 3.0, 4].group_by {|n| n.class } #=> { Fixnum: [1, 4], Float: [2.0, 3.0] }

# 真偽に応じて2つのグループに分ける
[1, 2, 3, 4].partition {|n| n.even? } #=> [[2, 4], [1, 3]]

# 最大値の取得
(1..10).max #=> 10

# 最小値の取得
(1..10).min #=> 1

# 最小値と最大値の取得
(1..10).minmax #=> [1, 10]

# 条件値の最大値の取得
%w(Rails ruby php).max_by {|s| s.size } #=> 'Rails'

# 条件値の最小値の取得
%w(Rails ruby php).min_by {|s| s.size } #=> 'php'

# 条件値の最小値と最大値の取得
%w(Rails ruby php).minmax_by {|s| s.size } #=> ['Rails', 'php']

# ソート
%w(ruby php C++).sort #=> ['C++', 'php', 'ruby']

# 条件付きソート
%w(Rails ruby php).sort_by {|name| name.size } #=> [ 'php', 'ruby', 'Rails']

Array

配列のこと。[]や%記法、Array.newで生成出来る

# 要素数を調べる
[4, 2, 3, 5].length #=> 4
[4, 2, 3, 5].size #=> 4

# 空かどうか調べる
[4, 2, 3, 5].empty? #=> false

# 引数に与えたオブジェクトが含まれているか
[4, 2, 3, 5].include?(4) #=> true

# 配列の連結
[1, 3] + [4, 2] #=> [1, 3, 4, 2]

# 要素を取り除く
[1, 3, 5, 4, 2] - [4, 2] #=> [1, 3, 5]

# 共通の要素を取得する
[1, 2, 3] + [1, 4, 2] #=> [1, 2]

# n回繰り返す
[1, 2, 3] * 2 #=> [1, 2, 3, 1, 2, 3]

# 添字参照
[1, 2, 3][0] #=> 1
[1, 2, 3][0, 1] #=> [1, 2]

# 複数の添字の要素を配列で返す
[1, 2, 3].values_at(1, 2) #=> [2, 3]

# 先頭の要素を取得
[1, 2, 3].first #=> 1

## 先頭からn個の要素を取得
[1, 2, 3].first(2) #=> [1, 2]

# 末尾の要素を取得
[1, 2, 3].last #=> 3

## 先頭からn個の要素を取得
[1, 2, 3].last(2) #=> [2, 3]

# 要素をランダムに返す
[1, 2, 3].sample #=> 2

## 要素をn個ランダムに返す
[1, 2, 3].sample(2) #=> [2, 3]

# 特定のキーを持つ要素を返す
[[:foo, 3], [:bar, 4], [:baz, 5]].assoc(:bar) #=> [:bar, 4]

# 要素を追加
[1, 2, 3] << 4 #=> [1, 2, 3, 4]
[1, 2, 3].push(4) #=> [1, 2, 3, 4]

# 末尾の要素を取得
[1, 2, 3].pop #=> 3

# 先頭に要素を追加
[1, 2, 3].unshift(9) #=> [9, 1, 2, 3]

# 先頭の要素を取得
[1, 2, 3].shift #=> 1

# 結果が真になった要素以外を取り除く
[1, 2, 3, 4].select! {|v| v.even? } #=> [2, 4]

# 結果が偽になった要素以外を取り除く
[1, 2, 3, 4].reject! {|v| v.even? } #=> [1, 3]

# レシーバが更新されなかった場合にレシーバを返す
[1, 2, 3, 4].select! {|v| false } #=> nil
[1, 2, 3, 4].delete_if {|v| false } #=> [1, 2, 3, 4]

[1, 2, 3, 4].reject! {|v| true } #=> nil
[1, 2, 3, 4].keep_if {|v| true } #=> [1, 2, 3, 4]

# 指定した値を削除
[1, 2, 3, 4].delete(4) #=> [1, 2, 3]

# 指定した添字の要素を削除
[1, 2, 3, 4].delete_at(2) #=> [1, 2, 4]

# nilを取り除く
[1, nil, 2, 4, ''].compact #=> [1, 2, 4, '']
[1, nil, 2, 4, ''].compact! #=> [1, 2, 4, '']

# 重複をした値を削除
[1, 1, 2, 4, 1.0].uniq #=> [1, 2, 4, 1.0]
[1, 1, 2, 4, 1.0].uniq! #=> [1, 2, 4, 1.0]

# 順序を逆にする
[1, 2, 4].reverse #=> [4, 2, 1]
[1, 2, 4].reverse! #=> [4, 2, 1]

# 配列の配列を平らにして新しい配列を返す
[2, 3, [5, 6]].flatten #=> [2, 3, 5, 6]
[2, 3, [5, 6]].flatten! #=> [2, 3, 5, 6]

# ソート
[4, 2, 3, 9].sort! #=> [2, 3, 4, 9]

# 条件付きソート
['abc', 'ruby', '12'].sort_by! {|v| v.size } #=> ['12', 'abc', 'ruby']

# それぞれの要素に処理して配列を更新する
['abc', 'ruby', 'rails'].map! {|v| v.upcase } #=> ['ABC', 'RUBY', 'RAILS']

# 配列を行列に見立てて、行と列を入れ替える
[['a', 'b', 'c'], [1, 2, 3]].transpose #=> [[a: 1], [b: 2], [c: 3]]

# 引数に渡された配列から配列の配列を作成
[1, 'a'].zip([2, 'b']) #=> [[1, 2], ['a', 'b']]

# 検索対象範囲を指定して最初の値を取得(二分探索)
[1, 3, 5, 7, 9].bsearch {|n| n > 6 } #=> 7

# 要素の連結
[22, 33, 44].join #=> '223344'
[22, 33, 44].join('-') #=> '22-33-44'

Hash

任意のオブジェクトをキーとして、他のオブジェクトを対応付けた、オブジェクトの集まり。

# 繰り返し処理
{ one: 1, two: 2 }.each do |key, val|
  puts "#{key}: #{val}"
end #=> 'one: 1', 'two: 2'

## キーのみ繰り返す
{ one: 1, two: 2 }.each_key do |key|
  puts "#{key}"
end #=> 'one', 'two'

## バリューのみ繰り返す
{ one: 1, two: 2 }.each_value do |val|
  puts "#{val}"
end #=> '1', '2'

# 値の追加
hash = {}
hash[:foo] = 'bar'
hash #=> { foo: 'bar' }

# 値の削除
hash = { foo: 'bar' }
hash.delete[:foo] #=> 'bar'
hash #=> {}

# 条件に合うもののみ残す
hash = { foo: 1, bar: 2, baz: 3 }
hash.select! {|key, val| val.odd? }
hash #=> { foo: 1, baz: 3 }

# 条件に合うものを除外する
hash = { foo: 1, bar: 2, baz: 3 }
hash.select! {|key, val| val.odd? }
hash #=> { bar: 2 }

# ハッシュをまとめて新しいハッシュを返す
hash = { a: 1, b: nil }
hash.merge({ b: 2, c: 3 })
hash #=> { a:1, b:2, c:3 }

hash = { a: 1, b: nil }
hash.merge!({ b: 2, c: 3 }) #=> { a:1, b:2, c:3 }

# キーとバリュー入れ替える
hash = { foo: 1, bar: 2, baz: 3 }
hash.invert #=> { 1: foo, 2: bar, baz: 3 }

# 指定したキーが存在しているか
hash = { foo: 1, bar: 2, baz: 3 }
hash.has_key?(:foo) #=> true
hash.key?(:foo) #=> true
hash.member?(:foo) #=> true
hash.include?(:foo) #=> true

# 指定したバリューが存在しているか
hash = { foo: 1, bar: 2, baz: 3 }
hash.has_value?(1) #=> true
hash.value?(1) #=> true

# すべてのキーの取得
hash = { foo: 1, bar: 2, baz: 3 }
hash.keys #=> [:foo, :bar, :baz]

# 特定のキーを取得
hash = { foo: 1, bar: 2, baz: 3 }
hash.key(1) #=> :foo

# すべてのバリューの取得
hash = { foo: 1, bar: 2, baz: 3 }
hash.values #=> [1, 2, 3]

# 特定のキーを取得
hash = { foo: 1, bar: 2, baz: 3 }
hash.values_at(:foo) #=> 1

# ハッシュの値を参照
hash = { foo: 1, bar: 2, baz: 3 }
hash.fetch(:foo) #=> 1

# ハッシュの値を参照し、無い場合は第2引数を返す
hash = { foo: 1, bar: 2, baz: 3 }
hash.fetch(:test, '該当なし') #=> '該当なし'

# ハッシュを配列に変換
hash = { foo: 1, bar: 2, baz: 3 }
hash.to_a #=> [[:foo, 1], [:bar, 2], [:baz, 3]]

# ハッシュから配列を作成
array = ['key1', 'val1', 'key2', 'val2']
Hash[*array] #=> { key1: 'val1', key2: 'val2' }

Time

オペレーティングシステムが提供するシステムの時刻機能をRubyから使用するためのクラスです。

# 現在時刻を取得
Time.now #=> 2021-05-10 18:09:10.651842 +0900

# 自身のタイムゾーンの現在時刻を取得
Time.zone.now #=> Mon, 10 May 2021 18:09:47 JST +09:00

# 年月日、時分秒を取得
time = TIme.zone.now #=> Mon, 10 May 2021 18:09:47 JST +09:00
time.year #=> 2021
time.month #=> 5
time.day #=> 10
time.hour #=> 18
time.min #=> 9
time.sec #=> 47

# 曜日を日曜(0)から土曜(6)までの整数で返す
Time.zone.now.wday #=> 1

# 年を通して経過日数を返す
Time.zone.now.yday

# 夏時間かどうか返す
Time.zone.now.dst? #=> false

# 任意の曜日かどうかを返す
Time.zone.now.sunday? #=> true
Time.zone.now.monday? #=> false
Time.zone.now.tuesday? #=> false
Time.zone.now.wednesday? #=> false
Time.zone.now.thursday? #=> false
Time.zone.now.friday? #=> false
Time.zone.now.saturday? #=> false

# 任意のフォーマットで返す
Time.zone.now.strftime('%Y/%m/%d') #=> '2021/05/10'

Time#strftimeに使用できるフォーマット文字列

文字列	意味
%A	曜日の名前(Sunday, Monday...)
%a	曜日の略称(Sun, Mon...)
%B	月の名前(January, February)
%b	月の略称(Jan, Feb)
%C	世紀(年の上2桁)
%c	日付と時刻(Mon, 10 May 2021 18:09:47 JST +09:00の形式)
%D	日付(%Y/%m/%dの形式)
%d	日、1桁の場合は0埋めされる
%e	日、1桁の場合は半角スペース埋めされる
%F	'%Y-%m-%d'と同じ
%H	時、24時間表示で1桁の場合は0埋めされる
%I	時、12時間表示で1桁の場合は0埋めされる
%j	その年の通算日数、1,2桁の場合は0埋めされる
%k	時、24時間表示で1桁の場合は半角スペース埋めされる
%L	ミリ秒(000-999)
%l	時、12時間表示で1桁の場合は半角スペース埋めされる
%M	分、1桁の場合は0埋めされる
%m	月、1桁の場合は0埋めされる
%N	秒の小数点以下
%P	amまたはpm
%p	AMまたはPM
%R	'%H:%M'と同じ
%r	'%I:%M:%S %p'と同じ
%S	秒、1桁の場合は0埋めされる
%s	UNIXエポックからの経過秒数
%T	'%H:%M:%S'と同じ
%U	週、1桁の場合は0埋めされる
%u	曜日、月曜日(1)〜日曜日(7)
%v	VMS形式の日付
%V	週、1桁の場合は0埋めされる、ISO8601形式の暦週
%W	週、1桁の場合は0埋めされる、最初の月曜日が第1週の始まり
%w	曜日、日曜日(0)〜土曜日(6)
%X	'%H:%M:%S'と同じ
%x	'%m/%d/%y'と同じ
%Y	年、西暦を表す4桁の数字
%y	年、西暦を表す下2桁の数字
%Z	タイムゾーン(UTC, JSTなど)
%z	タイムゾーン(+0000, +0900など)
%n	改行文字
%t	タブ文字
%%	%自身

IO・File

ファイルシステム上のファイルを扱うためのクラス。

# ファイルを開く
File.open('sample.txt')

# ファイルの内容を読み込んで出力する
file = File.open('sample.txt')
file.read

# ファイルを閉じる
file = File.open('sample.txt')
file.close

# 1行ずつ読み取る
File.open('sample.txt') do |f|
  while line = f.gets
    puts line
  end
end

## 最後まで1行ずつ読み取る
File.open('sample.txt') do |f|
  f.each_line do |line|
    puts line
  end
end

# ファイルへの書き込み
File.open('sample.txt', 'w') do |f|
  f.write('Hello')
end

# アクセス位置を先頭に戻す
File.open('sample.txt', 'a+') do |f|
  f.rewind
end

# アクセス位置を任意の位置に移動させる
File.open('sample.txt', 'a+') do |f|
  f.seek(10) # 先頭から10進んだ位置に移動

  f.seek(-10, IO::SEEK_CUR) # 現在の位置から10戻った位置に移動

  f.seek(-10) # 末尾から10戻った位置に移動

  f.pos = 30 # 任意の位置に移動
  f.pos #=> 30
end

# エンコーディングの扱い
File.open('sample.txt') do |f|
  f.set_encoding('UTF-8') # 外部エンコーディングをUTF-8に設定

  f.set_encoding('EUC-JP', 'UTF-8') # 外部エンコーディングをEUC-JP、内部エンコーディングをUTF-8に設定
  f.set_encoding('EUC-JP::UTF-8')
end

# ファイルをロックする
File.open('sample.txt', FILE::RDWR | File::CREAT) do |f|
  f.flock(File::LOCK_EX)
end

# 最後にアクセスした日時を取得
File.open('sample.txt') do |f|
 f.atime #=> 2021-05-11 22:12:34 +0900
end

# 最後に状態を変更した日時を取得
File.open('sample.txt') do |f|
 f.ctime #=> 2021-05-11 22:12:34 +0900
end

# 最後に更新した日時を取得
File.open('sample.txt') do |f|
 f.mtime #=> 2021-05-11 22:12:34 +0900
end

# ファイルサイズ
File.open('sample.txt') do |f|
 f.size #=> 40
end

# ファイルタイプの確認
stat = File.open('sample.txt', &:stat)
stat.ftype? #=> 'file'
stat.file? #=> true
stat.derectory? #=> false
stat.symlink? #=> false
stat.pipe? #=> false
stat.socket? #=> false

# ファイルの状態の確認
stat = File.open('sample.txt', &:stat)
stat.writable? #=> true
stat.readable? #=> true
stat.executable? #=> false

# 自身がオーナーか
stat = File.open('sample.txt', &:stat)
stat.owned? #=> true

# ファイルオーナーの情報
stat = File.open('sample.txt', &:stat)
stat.gid #=> 20
stat.uid #=> 500

# icode番号
stat = File.open('sample.txt', &:stat)
stat.ino #=> 13334536

# デバイス番号
stat = File.open('sample.txt', &:stat)
stat.dev #=> 254568373

# ファイル名の変更
File.rename('src', 'dest')

# ファイルの移動
File.rename('src', 'dir/dest')

# ファイルの削除
File.unlink('fname')

# シンボリックリンクの作成
File.symlink('origin', 'sym')

# ハードリンクの作成
File.link('origin', 'link')

# ファイルモードの変更
File.chmod(0600, 'fname')

# オーナー、グループの変更
File.chown(216, 216, 'fname')

# Fileのクラスメソッドからの属性や状態の確認
fname = '/etc/hosts'
## ファイルの最終アクセス日時を取得
File.atime(fname) #=> 2021-05-11 22:12:34 +0900

## ファイルの最後状態を変更した日時を取得
File.ctime(fname) #=> 2021-05-11 22:12:34 +0900

## ファイルの最終更新日時を取得
File.mtime(fname) #=> 2021-05-11 22:12:34 +0900

## ファイルの存在確認
File.exist?(fname) #=> true

## ファイルの状態確認
File.ownerd?(fname) #=> true
File.executable?(fname) #=> true
File.readable?(fname) #=> true
File.writable?(fname) #=> false

## ファイルタイプの確認
File.ftype?(fname) #=> 'file'
File.file?(fname) #=> true
File.derectory?(fname) #=> true
File.pipe?(fname) #=> true
File.socket?(fname) #=> true
File.symlink?(fname) #=> true

## ファイルサイズの確認
File.size(fname) #=> 40
File.zero?(fname) #=> false

## 詳しい情報を見る
File.stat(fname) #=> #<File::Stat ...>

# ファイルのあるディレクトリのパスを取得
fname = '/etc/resolv.conf'
File.dirname(fname) #=> '/etc'

# ファイル名を取得
fname = '/etc/resolv.conf'
File.basename(fname) #=> 'resolv.conf'

# 拡張子を除いたファイル名を取得
fname = '/etc/resolv.conf'
File.basename(fname, '.+') #=> 'resolv'

# ファイルの拡張子を取得
fname = '/etc/resolv.conf'
File.extname(fname) #=> 'conf'

# ファイルパス同士を連結
File.join('usr/local', 'bin/ruby') #=> 'usr/local/bin/ruby'

# dirnameとbasenameの配列
File.split('usr/local/bin/ruby') #=> ['usr/local/bin', 'ruby']

# ディレクトリを指定して絶対パスを取得
File.expend_path('fname', 'path/to/there') #=> '/path/to/there/fname'

# 現在実行しているファイルのディレクトリパスを取得
File.expend_path('..', _FILE_) #=> /Users/hibariya

ファイルを開く際のモード

モード	意味
r	読み込みモード
r+	読み書きモード
w	新規作成して書き込みモード
w+	新規作成して読み書きモード
a	追記書き込みモード
a+	読み込み、追記書き込みモード

ファイルを開く際のモード(定数ver.)

定数	意味
File::APPEND	追記モード
File::BYNARY	バイナリモード
File::CREAT	ファイルが存在しなければ作成
File::DSYNC	データ同期モード
File::EXCL	ファイル作成の際に、同名ファイルがあれば例外を発生させる
File::NOATIME	ファイルアクセス時に　最終アクセス日時を更新しない
File::NOCTTY	TTYを制御しないようにTTYを開く
File::NOAFOLLOW	対象がシンボリックリンクだった場合に例外発生
File::NONBLOCK	ファイルが利用可能でなくともブロックしない
File::RDONLY	読み込み専用モード
File::RDWR	読み書きモード
File::RSYNC	読み込み時同期モード
File::SYNC	同期モード
File::TRUNC	すでにファイルが存在する場合にファイルサイズを0にして開く
File::WRONLY	書き込み専用モード

flockで可能な操作を表す定数

定数	意味
File::LOCK_EX	排他ロック
File::LOCK_NB	ノンブロックモードの指定
File::LOCK_SH	共有ロック
File::LOCK_UN	アンロック

Dir

ディレクトリ操作するためのクラス。

# 現在のディレクトリ
Dir.pwd #=> '/Users/hibariya/tmp'

# 実行しているユーザーのホームディレクトリ
Dir.home #=> '/Users/hibariya'

# ディレクトリに含まれるファイルの一覧を取得
Dir.entries('usr') #=> ['.', '..', 'bin', ......]

# マッチするファイルパス一覧を取得
Dir.glob('usr/lib*') #=> ['/usr/lib', 'usr/libexec']
Dir['usr/lib*'] #=> ['/usr/lib', 'usr/libexec']

# 自身の開いているディレクトリ名
dir = Dir.open('usr')
dir.path #=> '/usr'

# ファイル一覧を繰り返す
dir = Dir.open('usr')
dir.each do |file|
   puts file
end

# 読み込み位置を先頭に巻き戻す
dir = Dir.open('usr')
dir.rewind #=> #<Dir:/usr>

# 現在の読み込み位置を返す
dir = Dir.open('usr')
dir.pos #=> 0

# 現在の位置のファイル名を返し、読み込み位置を１つ進める
dir = Dir.open('usr')
dir.read #=> '.'

# 読み込み位置を任意の場所に移動する
dir = Dir.open('usr')
dir.pos = 0

# ディレクトリを閉じる
dir = Dir.open('usr')
dir.close

# ディレクトリの作成
Dir.mkdir('foo')
Dir.mkdir('foo', 0755)

# ディレクトリの移動
Dir.rename('foo', 'bar')

# ディレクトリの削除
Dir.rmdir('bar')

Dir.globで使用できる記号

記号	意味
*	空文字を含む任意の文字列とマッチ
**/	*/の0回以上の繰り返し
?	任意の1文字にマッチ
[]	括弧内のいずれかの文字とマッチ
{}	括弧内のカンマで区切られた文字列いずれかにマッチ