【Ruby】( ,,`･ω･´)ﾝﾝﾝ？ってなった書き方を抜粋

# <font color="#009F8C">**まえがき**</font>

どうも、デブです。

たまーにRubyを触っては忘却を繰り返していたのですが
ようやくまともに覚えようと奮起しました。(といってもまだ奮起して二日目なのでまた忘れるかも)

さてさて、ある程度プログラマーしてれば
初めて見る言語でも高級言語ならそこそこ読めると思います、が

Rubyという言語は同じことをやるにしても違う書き方が沢山あるようで
書き方によっては、ん？なにこれってなりました。
また単純に特異なシンタックスもあります。
(2000円札的なあっても滅多に使わないよ機能が多い感もある)

ここには初めてRuby触った時に
ん？なんだこれ、どう解釈すればええのん？
ってなったRubyの書き方を抜粋してみました。

# <font color="#009F8C">**基本のキ**</font>

## **セミコロン、引数の()は省略可**

それくらい見ればわかるって気もしていたが
そこそこの規模になると、割と混乱する。

```ruby:code
print "Hello World" # 文字
puts "Hello World" # 文字 + 改行
p "Hello World" # デバッグ用
```

```text:出力結果
Hello WorldHello World
"Hello World"
```

# <font color="#009F8C">**リテラルだってオブジェクト**</font>

これ結構な曲者じゃないですかね？
ぱっと見ですごく**( ,,`･ω･´)ﾝﾝﾝ？**ってなる。


## **小数リテラルだってオブジェクトだ**

`1.2`はFloatクラスのインスタンスなのでメソッド使える。

```ruby:code
p 1.2.class
p 1.2.round
```

```text:出力結果
Float
1
```

## **Range(範囲)リテラルだって書けるのだ**

```ruby:code
p (10..15).class # 10～15の範囲

# rangeを使って10から15までループとか
(10..15).each do |i|
  p i 
end
```

```text:出力結果
Range
10
11
12
13
14
15
```

`(10...15)`と`.`を３個にすると、10から15の一個前(10~14)になる。

# <font color="#009F8C">**シンボルというニュータイプ**</font>

ここ最近の言語でちょくちょく見かけるようになったシンボル。
見た目は文字列だけど文字より高速に扱える型のようなイメージ。
正直こういうの凄くほしかったです。

文字の前に`コロン`をつけるとシンボルになる。


```ruby:code
symbol = :name # これがシンボル
p symbol
```

```text:出力結果
:name
```

とこれだけなら別にふーんなのだが

# **Hashやら短縮形やらとまざってくると戸惑い学んで汗を流して～**

Hash配列のkeyにシンボルを使う場合、`:`が左にいたり右にいたり
うろちょろするな！ってなる。

```ruby:code
prices = {:tomato => 100, :onion => 150} # Hash(連想配列)
p prices
prices = {tomato: 100, onion: 150} # 短縮系
p prices
```

```text:出力結果
{:tomato=>100, :onion=>150}
{:tomato=>100, :onion=>150}
```

## **メソッドの引数の指定時とかも戸惑う**

```ruby:code
func :name, {:tomato => 100, onion: 200}
```

ちょっと変な書き方だけど、これもシンタックス的には合法なわけで
引数の()も省略されてると**( ,,`･ω･´)ﾝﾝﾝ？**ってなる。


# <font color="#009F8C">**なんだこれって思ったら分数が書けるのね**</font>

```ruby:code
p Rational(1/2) + Rational(1/3) # 冗長な書き方
p 1/2r + 1/3r # 短縮系
```
```text:出力結果
(5/6)
(5/6)
```

# <font color="#009F8C">**おしりがびっくりしてる**</font>

`str.upcase!`みたいにお尻に`!`がついているとこうなる。

```ruby:code
name = 'nekonecode'
p name.upcase
p name
p name.upcase!
p name
```
```text:出力結果
"NEKONECODE"
"nekonecode"
"NEKONECODE"
"NEKONECODE
```

メソッド実行時にオブジェクトの中身も変化する。

# <font color="#009F8C">**おしりが疑問を抱いている**</font>

真偽値(true or false)が得られる。
これはなんとなく予想つくけれど、`!`に合わせて載せておきます。

```ruby:code
name = 'nekonecode'
p name.include?('n') # 文字'n'が含まれる？
```
```text:出力結果
true
```


# <font color="#009F8C">**だいたいこのくらい**</font>

とりあえず一番( ,,`･ω･´)ﾝﾝﾝ？ってなったのはここらへんです。

この先はなんとなく脳内補間出来そうな内容ですが
古い言語中心でやってるとちょっと戸惑うと思ったあたりを書いておきます。


# <font color="#009F8C">**大文字から始まるのは定数**</font>

constとかdefineとかはない

```ruby
VERSION = 1.0
Version = 1.1
```

ただRubyの定数は上書き可能、実行時に<font color="red">Warning</font>出るだけ。

# <font color="#009F8C">**配列の添え字いろいろ**</font>

基本的には他言語と同じだけどこんなのもある。

```ruby:code
animals = ["cat", "dog", "bird"]
p arr[-1] # 配列の末尾
p arr[0..2] # 0～2まで
p arr[0...2] # 0～2の直前まで
```

```text:出力結果
"bird"
["cat", "dog", "bird"]
["cat", "dog"]
```

Rubyはリテラルもオブジェクトというわけでありまして
添え字にはオブジェクトを指定できるわけですね。


# <font color="#009F8C">**Hashと配列のキャストもできるのね**</font>

```ruby:code
prices = {tomato: 100, onion: 150}
p prices.to_a # to_array
p prices.to_a.to_h # to_hash
```

```text:出力結果
[[:tomato, 100], [:onion, 150]]
{:tomato=>100, :onion=>150}
```

# <font color="#009F8C">**%記法**</font>

下記はどれも`"""`という文字列を表示しているだけ

```ruby:code
puts "\"\"\"" # エスケープ文字は可読性が悪い
puts %!"""! # %記法だと見やすい
puts %Q(""") # 上に同じ
```

```text:出力結果
"""
"""
"""
```

[%記法はいろいろあるのでマニュアル参照のこと](https://docs.ruby-lang.org/ja/2.5.0/doc/spec=2fliteral.html#percent)



## **たとえば%記法で文字列配列を定義**

```ruby:code
p %w(cat dog bird)
p %W(cat\ dog bird#{1+2}) # 大文字のWは式展開、バックスラッシュ記法が使える
```

```text:出力結果
["cat", "dog", "bird"]
["cat dog", "bird3"]
```

# <font color="#009F8C">**文字列への埋め込み**</font>

%は余り求めたり、文字列の埋め込みだったり用途が広いですね。

```ruby:code
p "数値：%03d, 少数：%10.2f" % [10, 3.1415]
```

```text:出力結果
"数値：010, 少数：      3.14"
```

# <font color="#009F8C">**条件を後から書く、後置if**</font>

後ろの条件が`true`ならその前の部分が実行される。

```ruby:code
cond = false
p "print!" if cond
cond = true
p "print!" if cond
```

```text:出力結果
"print!
```

# <font color="#009F8C">**timesを使ったループ処理**</font>

ループの回数が決まっている場合はこうかける。

```ruby:code
10.times do |i|
  puts "#{i}"
end

# またこれはdo ~ end は {}を使ってこう書くこともできる
10.times { |i| puts "#{i}" }
```

`times`は`Integerクラス`のメソッド、戻り値は`Enumerator`オブジェクト。

```text:出力結果
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
```

# <font color="#009F8C">**メソッド(関数)**</font>

## **戻り値のreturn は省略可**

`return`を省略すると最後に評価された値が戻り値になる。

```ruby:code
def sum (a, b)
  a + b
end

p sum 1, 2
```

```text:出力結果
3
```
# <font color="#009F8C">**クラス**</font>

## **インスタンス作るときは`ClassName.new`**

```ruby
class Hoge 
 なんか処理
end

hoge = Hoge.new
```

## **コンストラクタもあるよ**

```ruby
class Hoge
  def initialize
    # newされたときに呼ばれるぞ
  end
end
hoge = Hoge.new
```

## **メンバ変数(インスタンス変数)は`@`を付けましょう**

```ruby
class Hoge
  def initialize
    @foo = "hello"
  end
end
```

## **setterとgetter**

attr_accessorでsetter,getterを定義

```ruby:code
class Hoge
  attr_accessor :foo, :bar

  def initialize
    @foo = "hello"
    @bar = "bey"
  end
end

hoge = Hoge.new
p hoge.foo
p hoge.bar
hoge.foo = "foo!"
hoge.bar = "bar!"
```

```text:出力結果
"hello"
"bey"
```

## **setterはいらないからgetterだけ！**

`attr_accessor`を`attr_reader`にするとgetterだけになる。

```diff:code
class Hoge
-  attr_accessor :foo, :bar
+  attr_reader :foo, :bar

  def initialize
    @foo = "hello"
    @bar = "bey"
  end
end
```

逆にsetterだけでいいんだって時は`attr_writer`を使えばいいぞ。


## **`self.`がついてたらstaticメソッド(クラスメソッド)**

```ruby:code
class Hoge
  def self.hello
    puts "Hello!!"
  end
end

Hoge.hello
```

```text:出力結果
Hello!!
```

## **`@@`がついてたらstatic変数(クラス変数)**
```ruby:code
class Hoge
  @@foo = 0
end

Hoge.foo # こんな風に外部から参照はできないよ。
```

## **クラス直下に大文字で定義したらクラス定数**

```ruby:code
class Hoge
  NAME = "Nekonecode" # これはクラス定数、外からアクセスできるよ。
end

p Hoge::NAME
```

```text:出力
"Nekonecode"
```

## **privateメソッドは派生先でも呼べるし上書きもできちゃう。**

これ他の言語と同じ感覚でいるとパニックでしょう。

```ruby:code
class Foo
  private
    def private_method
      p "hello"
    end
end

class Bar < Foo
  def say
    private_method # 親のprivate呼べるぞ
  end
end

bar = Bar.new
bar.say
```

```text:出力
"hello"
```

```ruby:code
class Bar < Foo
  def say
    private_method # 親のprivate呼べるぞ
  end

  private
    def private_method # 親のprivate上書きもいけるぞ
      p "override"
    end
end

bar = Bar.new
bar.say
```

```text:出力
"override"
```

## **protectedがわかりにくい**

一般的なprotectedとは根本的に違う。
やや'friend'に近い。

普通の`friend`は関係ないクラスにも秘匿メンバを公開できてしまうが
Rubyの`protected`は同じクラスから生まれた者にだけ公開される。

# <font color="#009F8C">**まとめ**</font>

他にもあるとは思いますがざざっと書いてみました。

個人的に一番押さえておきたいなと思ったのは**リテラル**と**シンボル**でした。
他についてはなんとなく脳内で解釈できるものも多い気はしますが
リテラルとシンボルは知らないとどう読めばいいの？ってなりやすい(気がする)