[RB] Ruby中的Proc及Block

Block：

在寫ROR時，大家或多或少會碰到這樣的語法：

posts.each do |post|
  puts post.tiltle
end

或

posts.each {|post| puts post.tiltle}

上面兩段程式碼中用do-end和大括號{}包起來的就是block，但用{}包裹程式碼的方法只適用於程式碼是一行的情況。
學ROR以來有好長一段時間我都不太清楚他的妙用，只覺得這麼普通的東西為什麼要寫的那麼拐彎抹角，但是在看了code school的教學影片後發現他跟javascript的callback機制有異曲同工之妙，這樣的設計讓我們在做一些enumeration操作的時候能將block中的code傳入，之前之所以對這個概念一直搞不清楚就是因為很難具體的想像在each中視怎麼call這段code，現在我們就用這個demo來剖開這個黑盒子：

class Child
  def initialize
    @toys=['gun','hammer','puzzle']
  end
  def each_toy
    for toy in @toys 
      yield toy
    end
  end
end

mark = Child.new
mark.each_toy do |toy|
  puts "I'm playing #{toy}~"
end

在這個範例中block像參數一樣被傳入each_toy這個method，並在裡面的loop內被多次呼叫。這樣的設計除了使用起來很靈活、有彈性以外，也能減少重複的程式碼。如果你對javascript比較了解的話可以看這一段程式碼來幫助了解：

function Child() {
    var toys = ['gun','hammer','puzzle'];
    this.eachToy = function (cb) {
        for (var _i in toys) {
            cb(toys[_i]);
        }
    }
}

mark = new Child();
mark.eachToy( function (toy) {
  console.log("I'm playing " + toy + "~");
});

但是上面的程式碼中，block看起來一點都不像是物件，也不能被重複使用。如果要像是javascript一樣能將函數像物件一樣被宣告、保存起來，並傳入其他函數作為callback function，我們還少學了一些東西，那就是接下來要介紹的Proc物件。

Proc：

proc物件可以將ruby的程式碼保存起來，在需要的時候再執行他，或當做block傳入其他函數。proc有兩種實作方法：

By Proc.new

routine = Proc.new {|variable| Do something... }

或

routine = Proc.new do |variable| 
  Do something...
end

By lambda

routine = lamda {|variable| Do something... }

或

routine = -> {|variable| Do something... }

直接執行

routine.call value

把proc轉成block

要把proc物件轉為block時，我們要在這個物件的前面加上"＆"，例如：

posts.each &routine

在method中判斷是否有block傳入

要知道有沒有傳入block，我們可以使用block_given?來判斷：

if block_given?
  yield
else
  puts "No block past in"
end

小結

現在我們就來改寫一下一開始的範例：

class Child
  def initialize
    @toys=['gun','hammer','puzzle']
  end
  def each_toy
    if block_given?
      for toy in @toys 
        yield toy
      end
    else
      puts "No block past in"
    end
  end
end

mark = Child.new
routine = lambda { |toy| puts "I'm playing #{toy}~" }
mark.each_toy &routine

[JS] javascript OO設計 - 繼承

接觸javascript有一定的人應該都知道在js中，你所看到的幾乎都是物件。
函數是物件的第一型，Function和Object都是物件，也是函數的實例，而所有的function都是Function的instance。

關於原形(prototype)

prototype是函數物件特有的屬性，使用函數建構出來的物件會藉由原型鏈(prototype chain)而存取得到建構函數的prototype的屬性，用文字說清楚很難，不如我們直接看範例：

function Person(name, age) {
    this.name = name;
    this.age = age;
}
Person.prototype.nation = "Taiwan";
var kevin = new Person("Kevin", "18");
var laura = new Person("Laura", "17");
alert(kevin.nation); // "Taiwan"
alert(laura.nation); // "Taiwan"

雖然kevin和laura本身並沒有被定義"nation"這個屬性，但是當使用這些不存在的屬性時，會找他們的建構函數中的prototype，再沒有的話還會看這個prototype物件的建構函數中有沒有這個屬性，直到最高層，也就是Object建構函數的prototype，這就是所謂的prototype chain。為了證明這點，我們再次修改一下上面這個例子：

function Person(name, age) {
    this.name = name;
    this.age = age;
}
Person.prototype.nation = "Taiwan";
Function.prototype.whatTypeAmI = "Funciton";
Object.prototype.whatTypeAmI = "Object";
var kevin = new Person("Kevin", "18");
alert(kevin.nation); // "Taiwan"
alert(kevin.whatTypeAmI); // "Object"
alert(Person.whatTypeAmI); // "Function"

從上面可以看出雖然kevin這個物件沒有whatTypeAmI這個屬性，但是他會往上找Person.prototype物件有沒有這個屬性，再找不到就會找Person.prototype的建構函式，也就是預設的Object函式，這時我們會在他的prototype中找到whatTypeAmI這個屬性是"Object"。
而我們在呼叫Person的whatTypeAmI時也會發生找不到的情形，這時就會往上找到他的建構函數也就是Funciton的prototype，如範例所示，這時回傳的是"Function"。

利用prototype來實踐javascript繼承模式

我們可以利用上面所提到的prototype chain來實踐多層祖孫繼承的模式，我們用範例來解釋一下這點：

// 哺乳綱
function Mammals() {
    this.blood = "warm";
}

// 靈長目
function Primate() {
    this.tail = true;
    this.skin = "hairy";
}
Primate.prototype = new Mammals();

// 人科
function Homo() {
    this.skin = "smooth";
}
Homo.prototype = new Primate();

var human = new Homo();
human.name = "Kevin";

alert(human.name); // "Kevin", from self
alert(human.skin); // "smooth", from Homo
alert(human.tail); // "true", from Primate
alert(human.blood); // "warm", from Mammals

上例應該很清楚的顯示出以原型實踐繼承模式的原理了。

原型設計模式的漏洞

雖然原型設計模式能夠很方便的實踐物件間的共用屬性及繼承模式，但是在操作上要對prototype chain有一定的了解，再加上細心的邏輯驗證，才不會出現如下的錯誤：

function Human() {}
Human.prototype.blood = "red";
Human.prototype.body = ["foot","hand"];

var john = new Human();
var kevin = new Human();

john.blood = "purple";
john.body.push("wing");

alert(kevin.blood); // "red"
alert(john.blood); // "purple"

alert(kevin.body.toString()); // "foot, hand, wing"
alert(kevin.body.toString()); // "foot, hand, wing"

從上面的例子可以看到，john因為不明原因而突變以後，不只血變成紫色的，也長出翅膀來了！但是在john突變之後，kevin的血雖然沒有變色，但是卻莫名其妙長出了翅膀。很明顯的，我們不小心改動到了Human的prototype。
原來在我們為john的blood指定顏色時，javascript會為john這個物件增加一個屬於自己的"blood"屬性，這種情況就跟為物件增加屬性的方式一樣。於是在後來的呼叫時，會先找到john自己的blood屬性。但要john的body屬性執行push函式時，會發生在john中找不到body的狀況，於是就往上找到了Human.prototype的body屬性，並由他來執行push函式，此時改動到的便是Human.prototype.body了，也就連帶的影響到了無辜的kevin。

其他繼承模式設計

javascript是個很活的語言，除了prototype的實踐方式以外，我們也可以使用別的方式來實現繼承：

// 哺乳綱
function Mammals() {
    this.blood = "warm";
}

// 靈長目
function Primate() {
    Mammals.call(this); // 記得放前面，不然會蓋掉重複的屬性
    this.tail = true;
    this.skin = "hairy";
}
Primate.prototype = new Mammals();

// 人科
function Homo() {
    Primate.call(this); // 記得放前面，不然會蓋掉重複的屬性
    this.skin = "smooth";
}

var human = new Homo();
human.name = "Kevin";

alert(human.name); // "Kevin", from self
alert(human.skin); // "smooth", from Homo
alert(human.tail); // "true", from Primate
alert(human.blood); // "warm", from Mammals

這種方式是將父類別的建構函式放在子類別的建構函式中以「this」的身分來執行，為自己建置父類別的屬性。這樣的作法有個好處，就是不會因為不當的操作，改動到別的物件的屬性，但是相對的也失去了共用屬性的便利性。

這種方式也能讓我們很方便的實作多重繼承，只要在子類別的建構函數中呼叫多個父類別的建構函式即可。