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

# Class一覧

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

```ruby
# ゼロかどうか
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
文字列を表すクラス。

```ruby
# 空文字か
''.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
オブジェクトの集まりを自在に操るクラス。

```ruby
# 繰り返し処理
## インクリメントされる値と一緒に繰り返す
%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`で生成出来る

```ruby
# 要素数を調べる
[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
任意のオブジェクトをキーとして、他のオブジェクトを対応付けた、オブジェクトの集まり。

```ruby
# 繰り返し処理
{ 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から使用するためのクラスです。

```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
ファイルシステム上のファイルを扱うためのクラス。

```ruby
# ファイルを開く
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
ディレクトリ操作するためのクラス。

```ruby
# 現在のディレクトリ
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文字にマッチ  |
| []  | 括弧内のいずれかの文字とマッチ  |
| {}  | 括弧内のカンマで区切られた文字列いずれかにマッチ  |