13日目(2)：Ruby認定試験

恐ろしく長いのですが、自分用ですので

#クラスの継承
```rb:
# エラーにならないものを選べ
class Hoge < Object ; end
class Hoge << Object ; end
class Hoge < Kernel ; end
class Hoge << Kernel ; end

# A  １のみ
```
クラスの継承は`<`
なお、Kernelはモジュールなので不可
## module Kernel
```:irb
Kernel.call
=>Module
```
全てのクラスから参照できるメソッドを定義しているモジュール。 
Objectクラスはこのモジュールをインクルードしています。
Objectクラスのメソッドは実際にはこのモジュールで定義されています。

#to_i(n)
to_iメソッドは、文字列をn進数の表現と見なして整数に変換。
文字列の先頭から10進数と見なせる部分を切り取って変換し、見なせる部分がなければ0を返す。

```rb:
p "12abc".to_i =>123
p "abc12".to_i =>0
p "ab12c".to_i =>0
p "1abc2".to_i =>`1
```
#予約語のエスケープ？
正規表現ではあるのだろう

```rb:
s = "a;b:c;d:e;f"
p s.split (/:|;/)
=>["a", "b", "c", "d", "e", "f"]
```
#配列と範囲オブジェクト
いつも、ごちゃごちゃになる。

```rb:
a=[1,2,3,4]

a[1,3]    => [2,3,4]
a[1..3]   => [2,3,4]
a[1...3]  => [2,3]
a[1....3] => error
a[2..-1]  => [3,4]

## `範囲オブジェクトは文字列にも使える`
```rb:
a="abcdefghijk"
a[1,3] = "x"
p a =>  "axefghijk"
a[1..3] = "x"
p a =>  "axefghijk"
a[1...3] = "x"
p a =>  "axdefghijl"
```

#&と&&、|と||
```rb:
a = [1,2,3,4]
b = [1,3,5,7]

p a & b =>[1, 3]
p a && b =>[1, 3, 5, 7]
p a | b =>[1, 2, 3, 4, 5, 7]
p a || b =>[1, 2, 3, 4]
```
| 1 | 作用 |
|:-:|:-:|
| &  | 日本語の”且つ”と同じ。  |
| &&  |  左辺が真なら、右辺を評価して、右辺を返す |
| パイプ1本 |  日本語の”又は”と同じ |
| パイプ2本 | 左辺が真なら、右辺を評価せずに、左辺を返す  |

※パイプ＝『|』。エスケープできなかった

#可変長引数
```rb:
def sum (##AAA##)
  total = 0
  a.each {|i| total += i }
  return total
end
puts sum(1, 2, 3, 4, 5)
=>15
```
#delete_if = reject!　`破壊的メソッド`  
ブロックの戻り値が真になった要素を削除。
なお、rejectは非破壊的

```rb:
a= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a.delete_if{|v| v % 2 == 0 }
=>[1, 3, 5, 7, 9]
p a => [1, 3, 5, 7, 9]
```

#enum.each_with_index {|item, idx| block }
繰り返しごとにブロック引数itemには各要素が入り、idxには0，1，2と番号が入る

```rb:
a = ["apple", "orange", "grape", "pine"]
a.each_with_index{ |item, i| print i, ":", item, "\n" }
=> 
0:apple
1:orange
2:grape
3:pine
```

##array.each_index {|index| block }
『ほぼ』each_with_indexと同じ
繰り返しごとにブロック引数には各要素のインデックス（位置）の整数が入ります。戻り値はレシーバ自身

##hash.each_pair {|key, val| block }
eachと同じ

##hash.each_key {|key| block }
繰り返しごとにブロック引数keyにはキーが入る。
##hash.each_value {|val| block }
繰り返しごとにブロック引数valにはキーの値が入る。

each_何たらが他にも結構あるので、見ておこう

#shift とunshift `破壊的メソッド`
shiftメソッドは、配列の最初の要素を削除し、その要素を返します。
レシーバ自身を変更するメソッドです。配列が空のときはnilを返します。

```rb:
s = ["one","two","three"]

s.shift         => "one" ※先頭のoneを削除
s.shift         => "two"　※先頭のtwoを削除
s.unshift       => ["three"]　※引数が無いので、何もしてない
s.push "four"   => ["three", "four"]
p s             =>["three", "four"]
```
#compactとuniq
```rb:
a = [:a,:a,:b,:c]
a[5] = :e
a.concat([:a,:b,:c])
a.compact
a.uniq
p a
=> [:a, :a, :b, :c, nil, :e, :a, :b, :c]
```
concat, compact, uniqのうち、破壊的メソッドはconcatのみなので、
結果、元の配列aに影響を及ぼすのはconcatのみ

##concat `破壊的`　= push = <<
配列の末尾に引数を結合。感嘆符が無い破壊的メソッド
##conpact `非破壊的`
配列からnilを取り除いた、新しい配列を作成
感嘆符がついたconpact!が破壊的。
##uniq `非破壊的`
配列から重複した要素を取り除いて、新しい配列を作成
感嘆符が付くと破壊的に。

```rb:
arr = [1, 2, 5, 5, 1, 3, 1, 2, 4, 3]
p arr.uniq
[1, 2, 5, 3, 4]
```
#map = collect
```rb:
a = [1, 2, 3, 4, 5, 6]

a.collect {|v| v * 2}
=> [2, 4, 6, 8, 10, 12]
a.inject {|v| v * 2}
=> 32
a.each {|v| v * 2}
=> [1, 2, 3, 4, 5, 6]
a.map {|v| v * 2}
=>[2, 4, 6, 8, 10, 12]
a.select {|v| v * 2}
=> [1, 2, 3, 4, 5, 6]
a.execute {|v| v * 2}
=> error  undefined method
```
`どうしたらinjectが32になるか、リファレンス見ても理解できない`

#%w記法
配列を作る

```rb:
sarray = %w(Apple Orange Grape)
sarray.each {|v| print v, " "}
#
Apple Orange Grape
```

#zip
実行結果になるように、##AAA##に記述するコードを選んで下さい

```rb:
a = ["a", "b", "c"]
b = [1, 2, 3]
##AAA##

#実行結果
["a", 1]
["b", 2]
["c", 3]

#選択肢
a.zip(b).each{|x| p x }
a.zip(b){|x| p x }
[a, b].zip{|x, y| p [x, y] }
[a, b].transpose.each{|x, y| p [x, y] }

#答え　1，2，4
```
##zip
行と列を入れ替える。足りない要素はnilを返す
##transpose
zipと同様、行と列を入れ替える。要素が足りない場合、例外IndexErrorを発生。

#EOB
以下のコードは正しく動きません。修正案を。

```rb:
s = <<EOB
Hello, Ruby World.
Hi, Ruby World.
Goodbye, Ruby World.
  EOB

#解答
5行目のEOBの前の空白を削除する。
```

#encoding
```rb:
puts "hello".encoding.name
UTF-8
=> nil
```

#chop　`非破壊的`
文字列の末尾から1文字を取り除いた新しい文字列を返す
!が付くと、破壊的
##chomp `非破壊的`
文字列の末尾の改行文字を取り除いた新しい文字列を返す
！が付くと、破壊的

#キャレット^
名をキャレット、否定をする

```rb:
puts "0123456789-".delete("^13-56-")
=> 13456-
```
13456-に該当『しない』ものを削除している

#正規表現
```rb:
p "abc def 123 ghi 456".scan(/\d+/).length
=> 2
```
\dは10進数なので、10進数から始まる部分を配列で返し(scan)、その要素の数lengthを返してる
##scan(string)
指定した正規表現のパターンとマッチする部分を文字列からすべて取り出し、配列にして返す。

```rb:
p "HogeHOGEhoge"[/[A-Z][^A-Z]+/]
=> "Hoge"
```
大文字と小文字のアルファベットで構成される文字列を返している

#invert(hash)
hashのキーと値を入れ替える

```rb:
h = {1 => "Hoge", 2=> "Piyo", 3=>"fuga"}
p h.invert
#
{“Hoge”=>1, “Piyo”=>2,“fuga”=>3 }
```
#update と　sortメソッド
```rb:
a = {"Foo" => "Hoge", "Bar" => "Piyo", "Baz" => "Fuga"}
b = {"Foo" => "hoge", "Bar" => "piyo", "Baz" => "fuga"}
p a.update(b).sort{ |a, b| a[1] <=> b[1] }

[["Baz", "fuga"], ["Foo", "hoge"], ["Bar", "piyo"]]
```
##update
[わかりづらい](https://ref.xaio.jp/ruby/classes/hash/update)
##sort
配列の要素をソートした新しい配列を返します。
「要素1 <=> 要素2」の結果が-1なら要素1が先、0なら同じ、1なら要素2が先となります。

#ルート
以下のコードは、ファイル test . txt を読み、文字を逆順に書き込む処理です。
「##AAA##」に入る適切な記述を選びなさい。

```rb:
open("test.txt","##AAA##") do |f|
  data = f.read.chomp
  data.reverse!
  f.rewind
  f.write data
end
#選択肢
a　　w　　r　　a+　　r+　　w+
```
組み込み関数openの第2引数には、ファイルのオープン モードを指定します。
r、w、a に + を付けると、読み書き 両用でオープンします。
w+ を指定すると元ファイルの内 容を空にします。
a+ を指定すると、追記モードとなり、 元のファイルを書き換えることができません。

#chr　と　ord　は対義語的な
```rb:
puts 65.chr   => "A"
puts "a".ord  => 97
```
コードポイントの話。
n.chrは,nで登録されている文字を返す
string.ordはstringのコードポイントを返す
メソッドの意味は覚えてるけど、もう『65を見たらA』と覚えるしか。

#securerandom `Module`
安全な乱数発生器のためのインターフェースを提供するモジュール

```rb:
require 'securerandom'

SecureRandom.urlsafe_base64
```
##urlsafe_base64
ランダムで URL-safe な base64 文字列を生成して返します。

どこをみても、『url-safeな』『url-safeな』と書いてあるけど、
『url-safeな』とは。