Ruby メソッドとは

puts "##########メソッド########1"     


str = "abcd<efgh>ijkl mnop"

esca_str = str.gsub(/&/, '&amp;').gsub(/</, '&lt;').gsub(/>/, '&gt;').gsub(/ /, '&ensp;')

puts esca_str

puts "##########レシーバの省略########1"

class Laputa
    def hover
        puts "vibrateを呼び出します。"
        vibrate
        puts "vibrateをselfで呼び出します。"
        p self
        self.vibrate
      
        puts "名前の衝突開始"
        vibrate = 1  #名前の衝突
        p vibrate
      
        puts "selfを使い自分自身のメソッドの呼び出し"
        self.vibrate #selfを使い自分自身のメソッドの呼び出し
    end
  
    def vibrate
        p self
        puts "vibrateが呼ばれた"
        #何かの処理
    end
end

def vibrate
    puts "Laputa外の関数"
end

takalamakhan = Laputa.new #コンストラクタの呼び出し。インスタンスの生成。
taka1 = takalamakhan.hover

takalamakhan2 = Laputa.new
takalamakhan2.hover
p takalamakhan.equal? takalamakhan2   #オブジェクトが同じものか？
vibrate   #Laputa外の関数を呼び出し

puts "########## 関数的 メソッド ########1"

def functional_method(a, b)
    return [a, b, a+b]
end
p functional_method(1, 2) #=>[1, 2, 3]



puts "##########　引数展開　########1"

def some_method(a, b)  #仮引数
    p [a, b]
end

params = [1, 2]
x, y = params    #多重代入の場合は暗黙変換される
some_method(x, y)     #=>[1, 2]
#some_method(params) #配列から実引数リストへの自動的な展開は行われない。

puts "##########　メソッドの定義　########1"
puts "メソッド定義がdefを使う"

def sum(x, y)
    puts x + y
end

def diff x, y #括弧を省略スタイル
    puts x - y
end

def prod(x, y) puts x * y end #１行にマトメルスタイル
def quo x, y ; puts x / y end #括弧省略の１行マトメスタイル　セミコロンは引数渡しの終わり

sum(1, 2)     #=>3
diff(1, 2)    #=>-1
prod(1, 2)    #=>2
quo(1, 2)     #=>0


puts "##########　メソッドの定義　return　########"

def fact(n)
    return 1 if n == 0
    product = 1
    (1 .. n).each do |i|
        product *= i
        puts product
    end
    return product  #returnは必須ではありません。returnがない場合はメソッド末尾に到達すると最後の式が戻り値になります。
end

puts fact(10)   #=>3628800


puts "一行で記述した場合 メソッドの最後の式が戻り"
def fact2(n); (1 .. n).inject(1){|fe,i|fe*i} end  #fe,iはfeにiを代入している
puts fact2(10)   #=>3628800


puts "##########　メソッドの定義　多値の返却　########"

def some_method(a)
    return a, 1, 2 ,3
end
 a , b , *c = *some_method(0)
p a
p b
p c


puts "##########　メソッドの定義　引数展開　########"

def some_method(a , b , c)
    return a , b  , *c
end


array = [3 , 4 , 5]
te = some_method(1 , 2 , array)
p te


puts "##########　メソッドの定義　デフォルト値　########"

def some_method(a, b, c = 3)
    p a, b, c
end
some_method(1,2,4)  #デフォルト値を変更
some_method(1,2)    #デフォルト値がある仮引数は省略可能

puts "##########　メソッドの定義　デフォルト値の評価コンテキスト　########"

def print_time(time = Time.now)
    return time
end

(0 .. 3).each do |i|
    p print_time
    sleep 0.1
end

puts "##########　メソッドの定義　可変長引数　########"


def some_method2(a, b, *c) #残りは配列で渡し
     return a, b, *c #ｃは展開渡し
end
some = some_method2(1,2,3,4,5,6,7,8,9,0)
p some  #=>[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]


puts "##########　メソッドの定義　ブロックつきメソッド　########"


verse = "点士気喪　字時字時字時\nTESR　TETTTTT\n"

count = 0 #

verse.each_line do |line|
    print line
  
    count += 1 #=>点士気喪　字時字時字時 改行されてTESR　TETTTT
    p count
end

p count


puts "##########　メソッドの定義　クローじゃ　########"


def some_method
    3.times {p self}  #=>main
end

some_method

puts "##########　メソッドの定義　クローじゃ　########"

def create_count
    count = 1
    return Proc.new do
        count += 1
        p count
    end
end

counter = create_count #メソッドの呼び出し
p counter.class        #Procクラスの表示
counter.call  #=>2
counter.call  #=>3


counter2 = create_count
p counter2.class  
counter2.call  #=>2
counter2.call  #=>3


puts "##########　メソッドの定義　クローじゃ　########"
count = 0
[[1,2],[3,4]].each do |num , nums|
    p [num , nums]
    p count += 1
end

#p [num , nums]     #ブロック変数へはブロックローカル変数外部よりできません


puts "##########　メソッドの定義　ブロックつきメソッドの定義　########"

def foo_bar_baz
 yield "foao"
 yield "barsss"
 yield "bazsss"
end

g = 0
foo_bar_baz do |item|
    p g+=1
    puts item
end


puts "##########　メソッドの定義　イテレータの中のyield　########"


def foos_bars_bars2
    %w[foos bars1 bars2].each do |items|
        yield items
    end
end
g = 0
foos_bars_bars2 do |items|
    p g+=1
    puts items
end
puts "##########　メソッドの定義　Enumeratorとyield　########"


def foos_bars_bars3
    p block_given? #trueかfalseを返す
    return enum_for(:foo_bar_baz3) unless block_given?  #メソッドにブロックが渡されたかで動きを変える
    %w[foo bar baz].each do |item|
        yield item
    end
end


p foos_bars_bars3   #ブロック無し

foos_bars_bars3 do |item|            #ブロックあり
     p item
end

puts "##########　メソッドの定義　Enumeratorとyield　########"
def my_map
    [yield(1),yield(2),yield(3)]
end
p my_map {|i| i+1}

my_map do |i|
     p i+1
end