Prototype กับ Legacy javascript project

อ่านเจอประเด็น Prototype conflict กับ Legacy project
แต่ก็ไม่ได้สนใจอะไร เพราะนึกไม่ออกว่ามันจะ conflict กันตรงไหน
(ตอนแรกนึกว่าเป็นเรื่อง name conflict)

วันนี้อ่านเจอ case ตัวอย่างใน How Prototype Can Break Your Site
ของ code_poet
เขายกตัวอย่างง่ายๆว่า

var a = new Array();
a[0] = 1;
a[1] = 2;
for (var i in a) {
  print(i + " = "+ a[i]);
}

code ข้างบนก็ดูเรียบๆตรงไปตรงมา ไม่น่าผิดปกติตรงไหน
แต่ถ้าเมื่อไรก็ตามที่เรา include Prototype เข้ามา
code ข้างบนจะทำงานผิดไปจากเดิม
โดยผลลัพท์ที่ได้จะหน้าตาแบบนี้แทน

0 = 1 
1 = 2 
each = function() { }
iterate = function() { }

สาเหตุเป็นเพราะ

• Prototype มีการ extends Array class ของ javascript
  เพื่อเพิ่ม feature เกี่ยวกับการ iterate
  
• loop code ใช้วิธี loop array แบบพิสดารไปหน่อย
  คือแทนที่จะใช้ for (var i = 0; i < a.length; i++)
  กลับไปใช้ for (var i in a) แทน
  

He ni zai yi qi

เมื่อวันก่อน ก่อนออกไปทำงาน เผลอไปเปิด cable tv ดูเข้า
ได้เรื่องเลย เจอเรื่องแนวที่ชอบ
ผลก็คือไปทำงานสาย กับ เสียน้ำตาไปหลาย cc.

กลับมาจากที่ทำงาน ก็เลยนั่งค้นชื่อเรื่อง
กะว่าจะให้แฟนดูสักหน่อย
ชื่อเรื่องภาษาอังกฤษคือ Together

A 13-year-old violin prodigy has his life changed when his father takes him to Beijing to audition for a prestigious music school.

หนังเรื่องนี้เพลงเพราะมาก



ดูแล้วก็นึกในใจว่า นี่ถ้ายังไม่มีลูก
เราจะรู้สึกซาบซื้งได้อย่างนี้หรือเปล่า

เสียภาษีที่ดิน

แฟนผมได้มรดกที่ดินมาแปลงหนึ่ง
ด้วยความที่เป็นพลเมืองดี ก็เลยต้องไปเสียภาษี
ก่อนไปก็วิตกนิดหน่อยว่า
ไม่ได้เสียภาษีมา 10 ปีแล้ว
ค่าภาษีจะโดนไปเท่าไร

ตอนยื่นเสียภาษี เจ้าหน้าที่ถามว่า
ที่ดินมีการทำอะไรบ้างหรือเปล่า
เพราะถ้าไม่ได้ทำอะไร จะแพงกว่านะ

แฟนก็ยืนยันว่า ไม่ได้ทำอะไร
หลังจากเคาะเครื่องคิดเลขอยู่ครู่หนึ่ง
ก็ได้ข้อสรุปออกมาว่า
แปลงที่หนึ่ง 95 ตารางวา เสีย 7 บาท ค่าปรับ 5 บาท
แปลงที่สอง 13 ตารางวา เสีย 0.91 บาท ค่าปรับ 5 บาท

รวมทั้งสิ้น 18 บาท

javascript, new function(..)

สงสัยมานานแล้ว ว่าประโยค new แบบนี้ จริงๆแล้วมันหมายความว่าอะไร

function foo(x) {
  ...
}

var test = new foo(2);

Paul Crowley เขาอธิบายไว้ใน "Subclassing in JavaScript, part 1" ว่า
step ที่เกิดใน new foo(2) จริงๆแล้วก็คือ

• create new blank object (call it "res")
  
• res.__proto__ = foo.prototype
  
• foo.apply(res, [2])
  res จะกลายเป็น this ภายใน function foo
  
• return res
  

เห็นอย่างนี้ ก็ไม่งงแล้ว

function foo(x) {
  this.x = x;
}
var test = new foo(2);
test.x; // -> 2

แต่ตอนนี้ไปงงต่อตรง
__proto__ คืออะไร และต่างกับ prototype ต่างกันอย่างไร
ใน blog ของ Paul เขาอธิบายว่า
เวลาเราหาค่า property ใน object กรณีที่ object นั้นไม่มี key นั้นอยู่
และ __proto__ ใน object นั้นถูก set ไว้
javascript ก็จะมองหา key จาก object ที่ __proto__ ชี้อยู่

แล้วถ้าลองพิมพ์ค่า foo.__proto__ หล่ะ จะได้อะไร

foo.__proto__; // => function foo(x) { this.x = x; }
foo;           // => function foo(x) { this.x = x; }

? ชี้เข้าหาตัวเองเหรอ ชีวิตสับสน
แล้วถ้าอย่างนี้หล่ะ

foo.__proto__.__proto__ // => function() {}

งงต่อไป

Custom Dojo Package

โดยปกติ เมื่อเราสั่งคำสั่ง

dojo.require("dojo.lang");

สิ่งที่เกิดขึ้น ก็คือ dojo จะค้นหาว่า package dojo.lang
ถูก include ไว้ใน file dojo.js แล้วหรือยัง
ถ้ามีแล้ว ก็จะไม่ทำอะไร แต่ถ้ายังไม่มี
ก็จะทำการ load มาให้

ประเด็นคำถามก็คือ แล้วมันจะ load package dojo.lang จาก file อะไร
คำตอบก็คือ dojo จะลอง load file ตามลำดับนี้ (relative จาก dojo root directory)

 - src/lang.js
 - src.js
 - __package__.js

ถ้าเจอใน file ไหนก่อน ก็จะหยุดที่ตรงนั้น
แต่ถ้าไม่เจอเลย ก็จะ raise error

ที่นี้ถ้าเรามี custom component ของเราเอง
แต่ไม่อยากเก็บไว้ใต้ path เดียวกับ dojo
เราจะต้องทำอย่างไร

ทดลองสร้าง package pok.test ขึ้นมา
กำหนดว่า source code ของ package นี้จะเก็บอยู่ใต้ directory pok
ที่อยู่ระดับเดียวกับ directory src ของ dojo
จากนั้น สร้าง file test.js ไว้ใต้ directory pok

 + src
 + pok
   - test.js

คำสั่งที่สำคัญที่ต้องมีใน file test.js ก็คือ

dojo.provide("pok.test");

ซึ่งเป็นการบอกให้กลไกการ load ของ dojo หยุดการค้นหา package

เวลาจะใช้งาน custom package
เราก็ต้องมีการระบุ path ในการ search โดยใช้คำสั่ง

dojo.setModulePrefix("pok", "pok");

parameter ตัวแรก คือชื่อ prefix ของ package
ส่วน parameter ตัวที่ 2 ก็คือ relative path ของ package
ซึ่ง relative กับ root directory ของ dojo

เมื่อเราสั่ง dojo.require("pok.test");
dojo ก็จะดูว่า prefix ของ package ที่ชื่อ pok
จะต้องไปหาที่ directory ไหน
กลไกการหา ก็เป็นตามปกติ นั่นคือ

  - pok/test.js
  - pok.js
  - __package__.js

กอริลลา

ลองอ่าน "นักวิจัย เหมือน กอริลลา ในหมอก มืดมิด"
blog ของ คนไร้กรอบ

) ให้ดูพฤติกรรมสัตว์ ดังเช่น ที่ บริษัท Royal Dutch /shell ศึกษาวิชา เกี่ยวกับสัตว์ เพื่อมาดูองค์กรมีชีวิต
ผมก็เลย อุปมา นักวิจัย ก็เหมือน กอริลลา ในกรงที่ สวนสัตว์ (อย่าโกรธ นะ ที่อุปมาแบบสัตว์)
ธรรมชาติ ของลิงเขาต้องอยู่ในป่า มีอิสระเสรี มีที่อยู่เป็นอาณาเขต ฯลฯ พอเรา เอาพวกเขามาขัง เขาเขย่ากรง ก็เพื่อ คลายเครียด แสดงความเป็นใหญ่ ฯลฯ มันเป็นธรรมชาติ อย่าไปโกรธเขา
ในทำนองเดียวกับนักวิจัย ที่ได้ทุนไปเรียนเอกกลับมา โทกลับมา เราเอาเขา ที่อัตตาเยอะ(ประมาณ กอริลลา) มาขัง เงินเดือนนิดเดียว พวกเขา ก็เลย เอา อัตตามาชนกัน เขย่ากรง ตีอกใส่กัน ฯลฯ
ผู้บริหาร บริหารนักวิจัยแบบผิดธรรมชาติ เอา นักวิจัยมาใส่กรง