function firstDayOfMonth($monthstamp) {
    // $monthstamp มีหน้าตาเป็น mmyyyy ครับ
    // เช่น เราต้องการทราบว่าเดือนมกราคม ปี 2012 เป็นวันอะไร ก็ใช้ firstDayOfMonth('012012')
    // ปีที่ใช้ก็ใช้เป็นปี ค.ศ. นะครับ
    $mm = substr($monthstamp,0,2);
    $yyyy = substr($monthstamp,-4);
    return date('w',strtotime("{$mm}/01/{$yyyy} 00:00:00"));
}

ส่วนวิธีหาวันสุดท้ายของเดือนก็ทำแบบเดียวกันครับ ซับซ้อนขึ้นอีกแค่นิดเดียวเอง

function lastDayOfMonth($monthstamp) {
    $mm = substr($monthstamp,0,2);
    $yyyy = substr($monthstamp,-4);
    return date('w',strtotime('-1 second', strtotime('+1 month', strtotime("{$mm}/01/{$yyyy} 00:00:00"))));
}

ค่าที่ได้จะมีค่าตั้งแต่ 0 ถึง 6 มีความหมายตั้งแต่วันอาทิตย์ (0) ถึงเสาร์ (6) ครับ

ไม่ว่าจะเป็นการทำ Uppercase, Lowercase หรือ Capitalize จริง ๆ แล้วไม่ใช่เรื่องยุ่งยากอะไร หลาย ๆ คนแก้ปัญหานี้ด้วยวิธีการเขียน Javascript มาดักตอนที่พิมพ์ แล้วปรับแก้เป็นตัวที่ต้องการ ในความจริงแล้ว เรายังสามารถทำได้อีกหลายวิธี มีวิธีหนึ่งที่ผมคิดว่าโคตรง่าย นั่นคือการใช้ CSS มาช่วยนั่นเอง

การใช้ CSS มาเปลี่ยนตัวอักษรนั้น ทำได้โดยการใช้ style ที่ชื่อว่า text-transform โดยกำหนดค่าเป็นแบบนี้

• กำหนดเป็น uppercase เพื่อให้ตัวอักษรที่เราต้องการเป็นตัวใหญ่ทั้งหมด
• กำหนดเป็น lowercase เพื่อให้ตัวอักษรที่เราต้องการเป็นตัวเล็กทั้งหมด
• กำหนดเป็น capitalize เพื่อให้ตัวอักษรตัวแรกของคำที่เราต้องการเป็นตัวใหญ่ (ที่เหลือเป็นตัวเล็ก)

วิธีนี้ใช้ได้กับทุก ๆ element รวมถึง input และ textarea ด้วย นั่นหมายถึงเราจะสามารถพิมพ์ไปเรื่อย ๆ ได้ โดยไม่ต้องคอยกด Shift เพื่อทำเป็นตัวใหญ่เลย

สะดวกและสบายแบบนี้… เจ๋งเนอะ

ใครนึกภาพไม่ออก ลองไปดู LIVE DEMO ที่ http://sandbox.chonla.com/capitalize ได้ครับ

ท้ายสุดนี้สวัสดีปีใหม่ 2555 ครับ

Magic method เป็น method ใน class ทั่วไปที่จะถูกเรียกก็ต่อเมื่อเกิดเงื่อนไขอย่างใดอย่างหนึ่งที่ตรงกับ method นั้น ๆ ในความเป็นจริงแล้ว magic methods นั้น ไม่ได้มีอะไรวิเศษไปกว่า method ธรรมดาเลย เรียกให้ง่ายก็คือจริง ๆ แล้ว ตัว magic method ก็คือ method ธรรมดานี่แหละ เพียงแค่ว่า มันไม่ได้ถูกเรียกตรง ๆ เหมือนกับการเรียกใช้งาน method อื่น ๆ แต่อย่างที่บอกตอนต้น คือเมื่อเกิดเหตุการณ์ที่มีเงื่อนไขตรงแล้ว method นี้จะถูกเรียกโดยอัตโนมัติ

ตัว magic methods เองจะขึ้นต้นด้วยตัว underscore สองตัวติดกัน ( __ ) ดังนั้นเราควรหลีกเลี่ยงการตั้งชื่อ method ที่ขึ้นต้นด้วย __ นะครับ

เรามารู้จัก magic methods ที่ php เตรียมไว้ให้เรากัน

__sleep() และ __wakeup()

จะถูกเรียกเมื่อมีการเรียกใช้งานคำสั่ง serialize() และ unserialize() โดยเมื่อเราเรียก serialize() กับ object ของ class ที่มี method __sleep() มันจะทำการเรียกใช้งาน method __sleep() ก่อนที่จะทำการ serialize object ของเรา และจะเอาค่าที่ return จาก __sleep() ไป serialize() (ถ้าไม่มีการคืนค่าอะไรกลับไป คำสั่ง serialize จะทำการ serialize ค่า NULL)

ในทำนองเดียวกัน คำสั่ง unserialize() จะไปเรียกคำสั่ง __wakeup() ก่อนที่จะทำการ unserialize(); นั่นเอง

__tostring()

ชื่อ method ค่อนข้างชัดเจน method นี้เอาไว้ใช้สำหรับการประมวลผล object แบบ string เช่น เรามี object ตัวหนึ่ง คือ $obj เราสามารถใช้คำสั่ง echo $obj ได้เลย โดยที่มันจะไปเรียก magic method __tostring อัตโนมัติ ค่าที่ส่งกลับจาก method นี้จะถูกส่งต่อให้ echo อีกทีหนึ่งนั่นเอง

__invoke()

magic method __invoke() นี้จะถูกเรียกเมื่อมีการเรียกใช้งาน object ของเราเป็น function เช่น เรามี object ชื่อ $obj เราสามารถเรียกใช้เป็น $obj(‘test’) ได้เลย โดยที่ค่า ‘test’ จะถูกส่งผ่านไปให้ __invoke() นั่นเอง

__set_state()

เป็น method ที่ถูกเรียกเมื่อมีการเรียกใช้งานคำสั่ง var_export กับ object ของ class ค่าที่ถูกส่งคืนกลับมาจะถูกส่งไปให้ var_export อีกทีหนึ่ง

__construct()

สำหรับคนที่เขียน object oriented น่าจะรู้จัก method นี้ดี method นี้จะถูกเรียกเมื่อ class ของเราถูก instantiate เป็น object ครับ

__destruct()

จะถูกเรียกเมื่อ object ของเราถูกทำลาย (ทำลายแบบทั้ง implicit คือ ถูกทำลายไปเอง ไม่ได้สั่งทำลาย เช่น ออกจาก variable scope และทำลายแบบ explicit คือ ทำลายด้วยคำสั่ง unset)

__call()

จะถูกเรียกเมื่อมีการเรียกใช้ method ที่ใช้งานไม่ได้ (ไม่มี method นั้นใน class หรือ method นั้นเข้าถึงไม่ได้ เช่น private method)

__callStatic()

เหมือน __call() เพียงแค่ใช้กับ static method ครับ

__get()

ถูกเรียกเมื่อมีการอ้างถึง property ที่เข้าถึงไม่ได้ของ class (ไม่มี property นั้น หรือเข้าถึงไม่ได้จากสาเหตุอื่น เช่น private property)

__set()

ถูกเรียกเมื่อมีการกำหนดค่าให้กับ property ที่เข้าถึงไม่ได้ของ class

__isset()

ถูกเรียกเมื่อมีการเช็คค่า property ที่เข้าถึงไม่ได้ ของ class ว่าถูกกำหนดค่าไว้หรือไม่ผ่านคำสั่ง isset()

__unset()

ถูกเรียกเมื่อมีการทำลาย property ที่เข้าถึงไม่ได้ ของ class ผ่านคำสั่ง unset()

__clone()

ถูกเรียกเมื่อมีการสั่ง clone object ผ่าน คำสั่ง clone

ตัวอย่างการนำ magic methods มาประยุกต์ใช้คือการทำ data binding แบบง่าย ๆ ครับ

<?php
class DataBind {
	public $buffer;

	public function __construct() {
		$buffer = array();
	}

	public function __call($fn, $args) {
		if (preg_match('/^Get([A-Z][a-zA-Z0-9]*)$/', $fn, $m)) {
			return $this->buffer[$m[1]];
		} elseif (preg_match('/^Set([A-Z][a-zA-Z0-9]*)$/', $fn, $m)) {
			$this->buffer[$m[1]] = $args[0];
		} else {
			echo 'No method found: ' . $fn . "\n";
		}
	}
}

$data = new DataBind();
$data->SetBook('Harry Potter');
$data->SetName('John Doe');
$data->NoMethod();
echo "My name is " . $data->GetName() . ".\n";
echo "I love a book titled " . $data->GetBook() . ".\n";
?>

จะได้ output เป็น

No method found: NoMethod
My name is John Doe.
I love a book titled Harry Potter.

ลองเอาไปประยุกต์ใช้กันดูนะครับ  

สืบเนื่องจากโพสก่อนหน้านี้ผมพูดถึง database engine ใน MySQL ไป โดยอธิบายไปว่า บางชนิดจะสนับสนุน transaction แต่บางชนิดไม่สนับสนุน แถมยังเอาลิงก์เกี่ยวกับ transaction ทิ้งไว้ให้ไปอ่านเองอีกด้วย โพสนี้เลยจะขออนุญาตมาขยายความเรื่องเกี่ยวกับ transaction ให้เห็นภาพชัดเจนมากขึ้นกันดีกว่า

Transaction (ทรานแซคชั่น) หมายถึงการดำเนินการธุรกรรมอะไรซักอย่าง แล้วแต่เนื้อหาที่นำไปใช้ เช่น ไปธนาคารถอนเงิน 1 ครั้ง ก็เรียกได้ว่าเกิด 1 transaction หรือโอนเงินให้เพื่อน 1 ครั้ง ก็เรียกว่า 1 transaction ได้เช่นกัน แล้วความสำคัญของ transaction มันอยู่ตรงไหน?… ลองพิจารณากระบวนการโอนเงินดูครับ (ตัวอย่างคลาสสิคมาก) ผมโอนเงินจากบัญชี A ไปบัญชี B กระบวนการย่อยที่เกิดขึ้นคือ ถอนเงินจาก A และฝากเข้าไปที่ B ดังนั้นเราจะเห็นได้ว่า ในธุรกรรมการโอนเงิน 1 transaction จะมี 2 operation ย่อยเกิดขึ้นคือ ถอนเงิน และฝากเงิน

ปัญหาคือ ในกรณีที่ระบบล่มระหว่าง transaction ยังไม่เสร็จสิ้นล่ะ (จากตัวอย่าง เช่น ถอนเงินจาก A มาแล้ว แต่ยังไม่ได้ฝากเข้าไปที่ B) จะเกิดอะไรขึ้น… งานงอกไงครับ

ดังนั้น ไอ้เจ้า transaction เนี่ย อย่างน้อยจำเป็นต้องมีคุณสมบัติที่จะทำให้เรามั่นใจได้ว่า กระบวนการย่อย ๆ ที่เกิดใน transaction เนี่ย ทำงานได้อย่างสมบูรณ์นะ คุณสมบัติพวกนี้ถ้าเอาเฉพาะตัวอักษรตัวแรกของชื่อภาษาอังกฤษมาเรียงกัน จะเขียนได้เป็น ACID ดังนั้น คุณสมบัติของ transaction นี้ก็จะเรียกง่าย ๆ กันว่า ACID properties ของ transaction นั่นเอง โดยที่ ACID properties นี้จะประกอบด้วย

ก่อนที่จะทำความรู้จัก ACID properties … ผมขอแนะนำให้รู้จักคำ 2 คำที่ใช้กันใน transaction ก่อน คือ rollback และ commit … การ rollback หมายถึงการยกเลิกสิ่งที่ทำมาทั้งหมดใน transaction นั้น ๆ ส่วนการ commit คือการยอมรับและบันทึกค่าที่เปลี่ยนแปลงทั้งหมดใน transaction นั้น ๆ

1. Atomicity – คุณสมบัตินี้จะสอดคล้องกับตัวอย่างที่ผมพูดไปก่อนหน้านี้ โดยจะมีหลักง่าย ๆ ที่ชัดเจนคือ transaction ที่ถูกกระทำนี้มี operation ย่อย ๆ หลายคำสั่ง ถ้าทำได้ ก็หมายถึงทำได้ทั้งหมด ถ้าทำอันใดอันหนึ่งไม่ได้ จะหมายถึงทำไม่ได้เลยตั้งแต่คำสั่งแรก (All or nothing)

2. Consistency – คุณสมบัตินี้หมายถึงว่า ความสอดคล้องของข้อมูลจะต้องถูกต้องเสมอ ถ้าไม่ถูกต้องระบบจะต้องทำการ rollback กลับไปยังจุดที่ข้อมูลทั้งหมดสอดคล้องกันอยู่ ยกตัวอย่างเช่น จำนวนเงินที่ก่อนที่จะทำการโอนของทั้ง 2 บัญชีรวมกันจะต้องเท่ากันกับหลักจากทำการโอนแล้ว หรือข้อมูลที่เก็บเฉพาะ integer แต่เราใส่ข้อมูลที่เป็นทศนิยมเข้าไป ข้อมูลทั้งเรคอร์ดนี้ก็ไม่ควรถูกบันทึก หรือในระบบฐานข้อมูลที่มีการกำหนดฟิลด์อ้างอิงได้ (ว่าฟิลด์นี้อ้างถึงฟิลด์ไหนในตารางอื่น) การลบเรคอร์ดที่มีฟิลด์ที่ถูกอ้างอิงก็ควรจะก่อให้เกิด …

• ยกเลิก transaction และ rollback กลับไปยังจุดที่สอดคล้องล่าสุด…หรือ
• ลบเรคอร์ดที่มีการอ้างถึงข้อมูลนี้…หรือ
• ทำฟิลด์ที่อ้างถึงข้อมูลนี้ให้เป็น NULL ซะ

3. Isolation – หมายถึงว่า การประมวลผล transaction หนึ่ง ๆ ถ้ามันยังไม่เสร็จ transaction อื่น ๆ จะต้องไม่เห็นผลจากการกระทำของ transaction นี้ เช่น transaction ที่ 1 โอนเงินจากบัญชี A ไป B จำนวน 200 บาท และ transaction ที่ 2 คือ ถอนเงินจาก A 100 บาท กำหนดให้ในขั้นตอนของ transaction ที่ 2 เกิดขึ้นหลังจากที่ถอนเงินออกจาก A ไป 200 เพื่อที่จะนำไปฝากเข้า B แล้ว จากคุณสมบัติของ Isolation นี้จะทำให้ transaction ที่ 2 ยังไม่เห็นว่า A เงินหายไปแล้ว 200 หรือ B ได้รับเงินแล้ว 200

4. Durability – หมายถึง transaction ใด ๆ ก็ตามที่ทำการ commit แล้ว ข้อมูลจะต้องอยู่แบบนั้น ไม่ว่าระบบจะล่มยังไง เมื่อกู้คืนมาได้ transaction นั้นก็จะยังถือว่า commit และประมวลผลเสร็จสิ้นแล้ว

ครบ 4 อย่างแล้ว… พอเห็นภาพความสำคัญของ transaction ใน database มากขึ้นแล้วหรือยังครับ

การที่เราจะรู้ว่า storage engine แบบไหนเหมาะกับเรานั้น เราก็ต้องมาทำความรู้จักกับ storage engine แต่ละชนิดกันก่อน เพื่อไม่ให้เป็นการเสียเวลา เรามาทำความรู้จักกับ storage engine แต่ละตัวกันดีกว่า (เราสามารถกำหนดให้แต่ละตารางใช้ engine ต่างกันได้ตามความเหมาะสมในการใช้งาน)

• ISAM เป็น storage engine ที่ถูกออกแบบมาโดยที่มีแนวคิดที่ว่า ตารางมักจะถูกอ่านมากกว่าอัพเดท ทำให้ storage engine ชนิดนี้สามารถประมวลผลคำสั่งที่เป็นการอ่านได้อย่างรวดเร็วมาก ๆ แต่มีข้อเสียใหญ่ ๆ คือการไม่สนับสนุนการทำงานแบบ transaction (คือไม่สามารถ rollback ได้ ถ้าเกิดกรณีการทำงานไม่สมบูรณ์ ทางทฤษฎีเรียกว่า ACID transaction properties : สามารถอ่านเพิ่มเติมได้จากที่ http://en.wikipedia.org/wiki/ACID)  และไม่รองรับระบบ fault-tolerant (คือถ้าระบบล่ม ก็อาจจะไม่สามารถที่จะกู้ข้อมูลกลับขึ้นมาได้เลย) ดังนั้นถ้าจะใช้ engine นี้ในงานสำคัญ ก็แนะนำว่าหมั่น backup บ่อย ๆ ครับ
• MyISAM เป็น engine ยอดนิยมสำหรับเว็บทั่ว ๆ ไป พัฒนาต่อเนื่องมาจาก ISAM ทำให้ความเร็วในการอ่านยังเป็นเรื่องที่โดดเด่นอยู่เหมือนเดิม นอกจากนี้แล้วยังมีการเพิ่มส่วนของการทำ indexing และ operation สำหรับ field บางอย่างลงไปด้วย ข้อดีอีกอย่างคือ ใน MyISAM นี้ มี tool ที่ใช้ในการกู้ข้อมูลในกรณีที่ตารางมีปัญหาด้วย (MyISAMChk) แต่ข้อเสียที่สำคัญก็ยังคงอยู่คือ ไม่สนับสนุนการทำงานแบบ transaction และคำสั่ง update ยังส่งผลให้เกิดขยะที่ไม่จำเป็นอีกด้วย ทำให้เราต้องใช้คำสั่ง OPTIMIZE เพื่อจัดการขยะพวกนี้ให้หายไปจากตาราง
• HEAP (หรือ Memory) เป็น engine ที่ไม่ได้สร้างตารางขึ้นมาเป็นไฟล์จริง ๆ เหมือนกับ engine อื่น ๆ แต่จะสร้างตารางลงใน Memory ของเครื่อง ทำให้การเข้าถึงทำได้รวดเร็วยิ่งกว่า ISAM และ MyISAM แต่ข้อเสียคือ มันไม่อยู่ถาวร ถ้ามีการปิดเครื่องหรือระบบล่มโดยที่ยังไม่ได้บันทึกค่าในตารางลงไฟล์ ข้อมูลใน Memory ขณะนั้นก็จะหายไปทั้งหมด ไม่สามารถกู้คืนได้ และทุกครั้งที่ใช้งานตารางที่ใช้ engine นี้เสร็จ ก็จะต้องลบตารางนี้ทิ้งด้วย ไม่เช่นนั้นแล้วจะเกิดขยะใน Memory อาจจะทำให้ Memory ไม่พอในการทำงานได้
• InnoDB และ Berkley DB (BDB) เป็นฐานข้อมูลที่ถูกพัฒนามาให้สนับสนุน transaction และแถมด้วยการสนับสนุน Foreign Key แต่ก็มีข้อเสียคือมันช้ากว่า ISAM และ MyISAM แต่สำหรับผู้ที่จำเป็นจะต้องใช้ transaction แล้ว ก็คงเลี่ยงไม่ได้ที่จะใช้ engine ชนิดนี้
• Cluster ถูกพัฒนาขึ้นเพื่อเพิ่ม High Availability และ High Performance (ประมาณว่าใช้งานได้นาน ๆ และมีประสิทธิภาพดี) แต่ก็จะต้องใช้ resource ในการ implement ค่อนข้างมากเช่นเดียวกัน โดยที่ engine สำหรับ Cluster นี้มีชื่อว่า NDB หรือ NDBCLUSTER (NDB = Network Database)

SELECT  *, (SELECT count(  *  ) FROM comment WHERE topic_id = t.id) rcount FROM  `topic` t

ทีนี้ข้อเสียมันอยู่ตรงไหน? ถ้ายังไม่เห็น ลองสังเกตดี ๆ อีกทีครับ ใครยังนึกไม่ออก ผมจะยกตัวอย่างที่ทำให้เห็นชัดเจนมากขึ้น สมมติว่า แต่ละกระทู้ มีคนตอบกระทู้โดยเฉลี่ยกระทู้ละ 50 comment คำสั่ง COUNT มันก็จะไปนั่งนับจนครบ 50 comment โดย filter ตาม t.id ที่กำหนดแต่ถ้ามีมากกว่านี้ล่ะ เว็บไซต์ดัง ๆ ฮอต ๆ สมาชิกล้นหลาม คนตอบกระทู้เป็นร้อย ๆ พัน ๆ ล่ะ

จะเห็นได้ว่า “ทุกครั้ง” ที่มีคนเปิดหน้าแสดงรายชื่อกระทู้ มันจะต้องไปนั่งนับทุกครั้ง ทั้ง ๆ ที่อาจจะไม่ได้มีใครไปตอบกระทู้เพิ่มเลยก็ได้ สิ่งที่เราได้กลับมาจากการทำ Normalization ในครั้งนี้คือ การสิ้นเปลือง CPU สุด ๆ นั่นเอง เรามาหาทางแก้ปัญหากันดีกว่า

วิธีแก้ปัญหาแบบหนึ่งที่ผมจะพูดถึงในครั้งนี้คือการทำ cache ผมไม่ได้หมายถึงการทำ file cache หรือ memory cache นะ แต่ผมหมายถึงการ cache ลงไปในฟิลด์ในตารางครับ

พูดให้ชัดเจนอีกนิดคือ ผมหมายถึงการเพิ่มความซ้ำซ้อนของข้อมูลลงไปอีกนิด เพื่อชีวิตที่ดีกว่า โดยการเพิ่มฟิลด์ชื่อ comment_count ลงไปในตาราง topic และทุกครั้งที่มีการตอบกระทู้ หรือลบ comment ผมก็แค่มาอัพเดทฟิลด์นี้ด้วยเท่านั้นเอง

UPDATE topic SET comment_count = (SELECT COUNT(*) comment_count FROM comment WHERE topic_id = t.id)

ด้วย SQL Statement ข้างบนนี้ มันก็จะไป sync ข้อมูลจำนวนนับจากตาราง comment มาลงในตาราง topic ให้ผม และทุกครั้งที่แสดงหน้ากระทู้ ผมก็เอา comment_count ไปใช้แทน subquery ได้เลย สบายจริง ๆ ครับ

Factory pattern เป็นรูปแบบที่ทำให้เราสามารถสร้าง object (instantiate) ได้ในช่วง runtime โดยการส่ง parameter ที่เป็นชื่อ class name เข้าไปเท่านั้น ไอเดียตรงนี้ ใครเคยเขียนโค๊ดใน Joomla อาจจะเคยเห็นชื่อ JFactory กันมาบ้าง

จากเดิมที่เราเคยเขียนโค๊ดเพื่อที่จะเลือกสร้าง object ประมาณนี้

include_once ('class/object.class.php');
$obj = new ClassName();
$obj->display();

หรือ จะเป็นแบบที่ dynamic ขึ้นกว่าเดิมอีกนิดนึง

$obj = null;
if ($action == 'check') {
include_once ('class/check.class.php');
$obj = new ClassCheck();
} elseif ($action == 'dispatch') {
include_once ('class/dispatch.class.php');
$obj = new ClassDispatch();
} else {
include_once ('class/default.class.php');
$obj = new ClassDefault();
}
$obj->execute();

จะเห็นว่าแบบที่ 2 จะ dynamic กว่าแบบ 1 แต่ยาวเหยียด เราจะรวบรัดแก้ไขปัญหาเรื่องนี้โดยการใช้ Factory Pattern โดยการสร้าง class ขึ้นมา 1 class และมี static function 1 ตัว ชื่อ create (จริง ๆ จะใช้ชื่ออื่นก็ได้) ยกตัวอย่างเช่น

class XFactory {
public static function create($classname) {
if (include_once 'classpath/'.$classname) {
$clsn = 'Class' . ucfirst($classname);
if (class_exists($clsn)) {
return new $clsn;
} else {
throw new Exception('Class not found');
}
} else {
throw new Exception('Class not found');
}
}
}

ทีนี้เวลาเราจะใช้งานก็เรียกใช้แค่นี้ครับ

$chkobj = XFactory::create('check');
$dspobj = XFactory::create('dispatch');

คราวนี้ง่ายขึ้นมั๊ยครับ

อ้างอิง

• http://php.net/manual/en/language.oop5.patterns.php
• http://truelogic.org/wordpress/2011/03/27/a-very-efficient-way-of-instantiating-a-class-dynamically-in-php/

ผมไม่ได้อัพเดทบล็อกมาหลายเดือนเลยครับ ด้วยเหตุผลหลาย ๆ อย่างทำให้ผมมีเวลาไม่ค่อยมากเหมือนเก่า และที่สำคัญ หลาย ๆ ครั้งผมคิดไม่ออกว่าจะเขียนอะไรดีครับ

entry นี้ เป็นไอเดียที่ผมไปได้มาตอนที่ไปประชุมวิชาการที่ญี่ปุ่นครับ ลองอ่านแล้วลองไปปรับใช้กันดูนะครับ

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

$t = (int)date("G", time());

ค่า $t ที่ได้ ก็จะเป็นเวลาชั่วโมง มีค่าตั้งแต่ 0-23 ครับ มี type เป็น int (จากการ casting ด้วย int) ด้านหน้าแหละครับ

สมมติว่าช่วงที่เรากำหนดไว้มี 2 ช่วงคือ ช่วง A คือ 10-21 (10 โมงเช้า ถึง 3 ทุ่ม) และ ช่วง B คือ 21-10 (3 ทุ่ม ถึง 10 โมงเช้า) สมมติให้แต่ละช่วงเป็น array ที่มี 2 element โดย element ที่ 0 คือเวลาเริ่มต้น และ element ที่ 1 คือเวลาสิ้นสุด ดังนั้น

$A = array(10, 21);
$B = array(21, 10);

ดังนั้นสำหรับ $A แล้ว การเช็คก็จะง่าย ๆ ใช่มั๊ยครับ แค่ใช้ว่า if (($A[0] <= $t) && ($t <= $A[1])) เท่านั้นเอง ในขณะที่ $B จะไม่สามารถทำแบบนี้ได้ เพราะเวลาของ element ที่ 1 มีค่าน้อยกว่า element ที่ 0 ดังนั้นทำให้เราต้องเช็คอีกแบบหนึ่งแทน โดยสามารถทำได้ 2 แบบครับ คือ if ((($B[0] <= $t) && ($t <= 23)) || (($t <= 0) && ($t <= $B[1]))) คือ แบ่งช่วงก่อนเที่ยงคืนและหลังเที่ยงคืนมาเช็คนั่นเองครับ หรืออีกวิธีคือ if (!(($B[1] < $t) && ($t < $B[0]))) ครับ นั่นคือเช็คว่าไม่อยู่ในช่วงนอกช่วงเวลาที่กำหนดนั่นเองครับ

จะเห็นได้ว่า การทำแบบนี้จะต้องมาเช็คช่วงว่าตัวแรกน้อยกว่าหรือมากกว่าตัวหลัง แล้วแยกไปเช็คตามวิธีที่สอดคล้องกัน

ทีนี้มาลองดูวิธีที่ผมคิดว่าน่าจะง่ายกว่ากันมั่ง

วิธีนี้ มีข้อกำหนดให้ช่วงเวลาเริ่มต้นจะต้องน้อยกว่าช่วงเวลาสิ้นสุดเสมอ โดยให้เวลาที่เลยเที่ยงคืนไป จะให้นับต่อไปเรื่อย ๆ จาก 23 ครับ ไม่ต้องวนกลับไปนับ 0 ใหม่ ดังนั้น ช่วงของ $A และ $B ใหม่ จะได้เป็น

$A = array(10, 21);
$B = array(21, 34); // 34 คือ 24 + 10 นั่นเอง เอา 10 โมงเช้า + เวลาหลังเที่ยงคืน

วิธีการเช็คก็ง่ายนิดเดียวครับ โดยการใช้แบบนี้ครับ if ((($A[0] <= $t) && ($t <= $A[1])) || (($A[0] <= ($t+24)) && (($t+24) <= $A[1]))) วิธีแบบนี้ใช้ได้กับทั้ง $A และ $B ครับ นั่นคือเอาเวลาปัจจุบันมาดูว่าอยู่ในช่วงเวลาปกติหรือเปล่า หรือว่าอยู่ในช่วงเวลาข้ามวันไปแล้ว (โดยการ +24 แล้วเอาไปเช็ค)

วิธีนี้ผมได้แนวความคิดมาหลังจากที่ผมเห็นป้ายหน้าตึก ropongi hill ที่ระบุเวลาเปิดปิดไว้ว่า ปิดเวลา 25:00 ครับ (ตี 1) ผมเลยเอามาคิดว่าทำไมถึงต้อง 25:00 ทำไมไม่เป็น 1:00 แล้วจะเอาไปใช้งานง่าย ๆ ได้ยังไง ที่เหลือผมก็คิดเองเออเองมาเป็นแบบที่เขียนให้อ่านกันนี่แหละครับ ใครมีวิธีที่น่าสนใจกว่า เอามาแชร์กันได้นะครับ

$('#selector').attr('disabled','disabled'); // สำหรับ disable
$('#selector').removeAttr('disabled'); // สำหรับ enable

แต่ถ้าใช้บ่อย ๆ แล้ว จะให้มาเขียนแบบนี้อยู่ตลอด ก็คงจะไม่สะดวกนัก จะให้เขียนเป็น function มาครอบก็อาจจะดูไม่เก๋เท่ากับเขียนให้มันเป็น แบบ plugin ซะเลย

(function($)  {
$.fn.disable = function() {return this.attr('disabled', true).addClass('disabled');}
$.fn.enable = function() {return this.removeClass('disabled').attr('disabled', false);}
})(jQuery);

เท่านี้ก็เรียกใช้ .disable() กับ .enable() ได้ละ … เก๋ซะไม่มี 5555

โหลด plugin ตัวนี้ที่นี่เลยครับ

jQuery 1.4.4 Cheat Sheet ก็จะเป็นโพยที่รวมเอา function ทุุกอย่างของ jQuery 1.4.4 รวมถึงมี remark เล็ก ๆ ไว้ด้วยว่าอะไรเป็นอะไร ใช้ได้กับ jQuery เวอร์ชั่นไหน

ข้อดีของ Cheat Sheet คือ มันรวมทุกอย่างไว้ในหน้าเดียว ไม่ต้องเสียเวลาไปหาจากตรงไหนอีก ถ้าหน้านี้ไม่มี ก็คือไม่มีแล้วครับ เรียกได้ว่า สะดวกสุด ๆ ไปเลย บนหน้าเว็บยังมีเวอร์ชั่น pdf และ png ให้โหลดเก็บไว้ได้อีกด้วย แต่เนื่องจากมันเป็น Cheat Sheet มันเลยไม่มีรายละเอียดของ function นั้น ๆ ว่าเอาไว้ทำอะไร ตัวอย่างการใช้งาน ก็คือ เราจะใช้ เราต้องรู้อยู่แล้วว่ามันทำอะไรครับ

ใครสนใจไปชมไปโหลด เชิญได้เลยที่ http://jqapi.ru/