หลักการเขียนโปรแกรม ตอนที่ 5

Posted on December 3, 2014 by irobustadmin — No Comments ↓

ในบทความนี้นจะต่อเรื่องจากบทความที่แล้วในเรื่องของ low coupling ในตอนนี้จะเป็นเรื่องของ high cohesion ก่อนอื่นเราต้องทำความเข้าใจเรื่องของ cohesion กันก่อน คำว่า cohesion แปลว่าเนื้อเดียวกัน หรือ การทำงานร่วมกัน ดังนั้นถ้าพูดถึงในเชิงของ Software Engineer เราจะใช้ค่า cohesion เป็นมาตรวัด ถ้าค่า codesion สูงๆ หมายถึง code นั้น reusability และ readability ที่สูง

Cohesion จะเพิ่มขึ้นถ้า

เราสร้าง class แล้วให้เรียกใช้ function ผ่าน method ของ class นั้น
1 class ต้องมีจุดประสงค์เพื่อทำงานอย่างใด อย่างหนึ่งเท่านั้น อย่าทำหลายอย่าง
method แต่ละ method ต้องทำงานให้น้อยที่สุด อย่าให้ 1 method ทำงานหลายอย่าง

ข้อดีของการทำให้ระบบของเรามี high cohesion

ลดความซับซ้อนของแต่ละ module ลง
ทำให้ระบบสามารถแก้ไขได้ง่ายขึ้น
เพิ่มค่า reusability ที่สูง

การเพิ่มค่า Cohesion อย่างง่ายๆคือ การเขียนโปรแกรมแบบ Object Oriented และใช้แนวคิด Seperation of Concern

หลักการเขียนโปรแกรม ตอนที่ 4

Posted on December 3, 2014 by irobustadmin — No Comments ↓

ในการเขียนโปรแกรม เราต้องรู้จักหลักการที่สำคัญอีกตัวนึงคือ Low coupling และ High cohesion ในบทความนี้เราจะพูดถึงในส่วนแรก คือ Low coupling

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

ลักษณะของ Coupling มีอยู่ 2 ประเภทคือ

low Coupling หรือ loosely Coupled (แต่ละ module เป็นอิสระ ไม่ขึ้นต่อกัน)
high Coupling หรือ tightly Coupled (แต่ละ module จะผูกติดกันเป็นก้อน)

ประเภทของการ Coupling ที่เป็นแบบ Procedural มีดังนี้

Content Coupling – เกิดจากการไปทำการ access local data(เช่นตัวแปร) ของ module อื่นๆ
Common Coupling – เกิดจาก 2 module เรียก global variable ตัวเดียวกัน
External Coupling – เกิดจาก 2 module มีการ export output ในรูปแบบเดียวกัน (เวลาแก้ต้องแก้ทั้ง 2 ที่)
Control Coupling -เกิดจาก module นึงทำการควบคุมอีก module นึง
Stamp Coupling – เกิดจากการ share composite data structure
Data Coupling – เป็น coupling ที่เกิดจากการส่ง parameter
Message Coupling (low) – ถ้าจำเป็นจะต้องเกิด coupling ต้องเป็นประเภทนี้ ใช้การส่ง message หากัน

ประเภทของการ Coupling ที่เป็นแบบ Object Oriented (OOP) มีดังนี้

Subclass Coupling – เกิดจากการ Inheritance ซึ่งเป็นความสัมพันธ์ที่ควรจะมีให้น้อยที่สุด
Temporal Coupling – เกิดจากมี 2 action ทำงานใน module เดียวกัน

วิธีการทำให้เกิด low coupling หรือ เรียกว่าการ decoupling ทำได้หลายวิธี ต้องทำการศึกษาในรายละเอียดของแนวคิดแต่ละแบบ แต่โดยส่วนมากให้ยึดแนวทางตาม Design Pattern เป็นหลักจะดีที่สุด

หลักการเขียนโปรแกรม ตอนที่ 2

Posted on December 2, 2014 by irobustadmin — No Comments ↓

ในบทความนี้เราจะมาพูดถึงหลักการเขียนโปรแกรมกันต่อ สิ่งที่จะทำให้เราแก้ไข Code ได้ง่ายนั้น เราต้องทำการแยก Source Code แต่ละส่วนอย่างชัดเจน ยกตัวอย่างเหมือนการจัดหนังสือในห้องสมุด เราจะหาหนังสือได้ยังไง ถ้าหนังสือแต่ละเล่มไม่ได้จัดหมวดหมู่เอาไว้

ในการเขียนโปรแกรมก็เหมือนกัน เราต้องทำการจัดการ Source Code ของเราให้เหมือนกับการจัดการหนังสือในห้องสมุด เราต้องทำการแบ่งแยก Source Code ของเราออกเป็นหมวดหมู่หรือเป็นเรื่องๆ

ซึ่งหลักการนี้เรียกว่า Separation of Concern (SoC) หลักการนี้จะนำไปสู่หลักการเขียนโปรแกรมต่างๆมากมาย ไม่ว่าจะเป็น Object Oriented Programming (OOP) หรือ จะเป็น Architecture Pattern ชื่อดังอย่าง MVC ก็ล้วนแล้วแต่เกิดขึ้นมาเพื่อตอบสนองหลักการนี้ทั้งสิ้น

ในการนำหลักการนี้ไปทำการ Implement นั้นก็ต้องใช้แนวคิดหรือ Design Pattern ต่างๆ

Object Oriented (OOP)
Aspect Oriented Programming (AOP)
MVC
MVP
MVVM
Service Oriented Architecture (SOA)
และอื่นๆ

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

แต่ที่นำหลักการนี้มาไว้ในบทความตอนแรกๆ เนื่องจากเป็นหลักการที่สำคัญ ก่อนที่เราจะเรียนรู้ OOP เราต้องเรียนรู้หลักการนี้ก่อน ไม่งั้นเราจะใช้ Syntax แบบ OOP แต่เราไม่ได้ใช้วิธีการคิดแบบ OOP เลย เพราะ OOP เป็นการ Speration Code ออกจากกันโดยแยกเรื่องที่ไม่เกี่ยวข้องกันออกจากกัน (เนื่องจาก คำว่า Class ใน OOP ย่อมาจาก คำว่า Classify หรือ Classification)

การทำให้ object ของเราสามารถใช้ function count ได้เหมือนกับ array

Posted on November 25, 2014 by irobustadmin

ในการทำงานกับ object ใดๆ ในบางครั้งเราอยากที่จะทำการเรียกใช้ function count เหมือนอย่าง array บ้าง เพราะบางทีเราอยากที่จะวน loop for เพื่อเข้าถึงสมาชิกของ object ทุกตัว หรืออาจอยากได้จำนวนของ object นั้นๆไปประยุกต์ใช้งานทำอย่างอื่น แต่เราไม่สามารถที่จะใช้ function count ได้เหมือนกับ array

// Code จะ Error เพราะไม่สามารถใช้ function count กับ object ได้
count($object)

1 2	// Code จะ Error เพราะไม่สามารถใช้ function count กับ object ได้ count($object)

วิธีการที่จะทำให้ object นั้นสามารถ count ได้ ก่อนอื่นเราต้องทำการ count มันให้ได้ก่อน ขึ้นอยู่กับว่าเราเลือกที่จะ count ด้วยวิธีไหน อาจเป็นการ count โดย Query ข้อมูลจากฐานข้อมูล โดยใช้ SELECT COUNT(*) …. หรือการ count object โดยการนับ object ที่ทำการ new ขึ้นมาก็แล้วแต่ เราจะไม่ได้ลงในรายละเอียดของวิธีการ count แต่ละแบบ แต่ในตัวอย่างเราจะเลือกอย่างหลังคือทำการนับ object ที่ได้ทำการ instantiate ขึ้นมา

class Student{
   private static $num = 0;
   function __construct(){
      self::$num++;
   }
}

class Student{

private static $num = 0;

function __construct(){

self::$num++;

}

ในตัวอย่างนี้ตัวแปร $num จะเพิ่มขึ้นทุกครั้งที่มีการ new Student ขึ้นมาใช้งาน แต่จุดประสงค์หลักของบทความนี้คือต้องการเอาค่า $num ที่นับได้ไปแสดงผลโดยการใช้ function count เราเลยต้องทำการ implement interface ที่ชื่อว่า countable เพื่อให้ใช้ function count กับ object นี้ได้

class Student implements Countable{
   private static $num = 0;
   function __construct(){
      self::$num++;
   }
   function count(){
      return self::$num;
   }
}

class Student implements Countable{

private static $num = 0;

function __construct(){

self::$num++;

}

function count(){

return self::$num;

}

เพียงแค่นี้ดราก็จะสามารถใช้ function count กับ object ได้แล้ว

การใช้งาน Eloquent โดยไม่ง้อ Laravel

Posted on November 23, 2014 by irobustadmin — No Comments ↓

จากบทความตอนที่แล้ว ทำความรู้จักกับ Eloquent เราได้ทำความรู้จักกับ Feature ต่างๆที่ Eloquent มี แต่เราต้องใช้กับ Laravel เท่านั้นรึเปล่า คำตอยคือไม่ใช่ สำหรับคนที่ยังไม่ได้ใช้งาน Laravel เราสามารถนำเอา Eloquent ไปใช้งานข้างนอกได้เหมือนกับ library ปกติ

โดยการนำเอา Eloquent ไปใช้งานมีดังนี้

ทำการ Download Eloquent จาก Github งานนี้ต้องใช้ Composer เข้าช่วย โดยการสร้าง Coposer.json ไว้ใน Folder ที่ต้องการจะ Download โดยใน Conposer จะมีเนื้อหาดังนี้

{
    "require": {
        "illuminate/Database": "*"
    }
}

{

"require": {

"illuminate/Database": "*"

}

หลังจากนั้น เราเข้าไปที่ Folder ที่เราต้องการนี้แล้ว run คำสั่ง

composer install

1	composer install

เท่านี้ Conposer จะไปทำการ Download library ตัวที่เกี่ยวข้องมาให้เราทั้งหมด

หลังจากนั้นเราต้อง require ไฟล์ autoload.php ที่อยู่ใน folder vendor เข้ามา

ขั้นตอนที่สำคัญที่สุดคือการ new Capsule ขึ้นมาใช้งาน เพราะ Capsule นี่จะเป็น Class ที่ทำให้ Eloquent สามารถทำงานอยู่ภายนอก Laravel ได้ แนะนำว่าให้แยกไฟล์นี้ไว้ต่างหาก แล้วใช้การ require หรือ include เข้ามาใช้งาน

โดย Code ที่เขียนมีดังนี้

use Illuminate\Database\Capsule\Manager as Capsule;

$capsule = new Capsule;

$capsule->addConnection([
    'driver'    => 'mysql',
    'host'      => 'localhost',
    'database'  => 'database',
    'username'  => 'root',
    'password'  => 'password',
    'charset'   => 'utf8',
    'collation' => 'utf8_unicode_ci',
    'prefix'    => '',
]);

// ทำให้สามารถเรียก Capsule แบบ Static Class ได้
$capsule->setAsGlobal();

// Setup the Eloquent ORM
$capsule->bootEloquent();

use Illuminate\Database\Capsule\Manager as Capsule;

$capsule = new Capsule;

$capsule->addConnection([

'driver' => 'mysql',

'host' => 'localhost',

'database' => 'database',

'username' => 'root',

'password' => 'password',

'charset' => 'utf8',

'collation' => 'utf8_unicode_ci',

'prefix' => '',

]);

// ทำให้สามารถเรียก Capsule แบบ Static Class ได้

$capsule->setAsGlobal();

// Setup the Eloquent ORM

$capsule->bootEloquent();

เปลียน Connection ไปยัง Database ที่เราต้องการ หลังจากนั้นเราก็สามารถใช้งาน Eloquent ได้โดยไม่ต้องพึ่ง Laravel อีกต่อไป

ทั้งแบบ Query Builder

$users = Capsule::table('users')->where('votes', '>', 100)->get();

1	$users = Capsule::table('users')->where('votes', '>', 100)->get();

และ แบบ ORM

class User extends Illuminate\Database\Eloquent\Model {}

$users = User::where('votes', '>', 1)->get();

class User extends Illuminate\Database\Eloquent\Model {}

$users = User::where('votes', '>', 1)->get();

ทำความรู้จักกับ Eloquent

Posted on November 23, 2014 by irobustadmin — No Comments ↓

หลายคนที่ได้ใช้ Laravel ส่วนหนึ่งคงจะติดใจการใช้งานตัว ORM อย่าง Eloquent ซึ่งใช้ Active Record Pattern เหมือนกับใน Ruby on Rail ซึ่งจะทำให้เราสามารถทำงานกับฐานข้อมูลได้อย่างง่ายดายและเป็น OOP แบบ 100% ซึ่งความสามารถของ Eloquent นั้นทำได้หลายอย่าง ทั้งเรื่องของ Query Builder ซึ่งจะเหมือนกับ Active Record ใน CI เราสามารถทำงานกับฐานข้อมูลโดยที่ไม่ต้องทำการ Map Object เลย Feature นี้จะเหมาะกับคนที่ยังติดอยู่กับการเขียน Query ด้วย SQL

นอกจากนี้ยังมีส่วนของ ORM ซึ่งต้องทำการ Mapping ก่อนการใช้งาน แต่การ Mapping แบบ Acrive Record นั้นง่ายมากๆ

ส่วน Featuure พื้นฐานอื่นๆ เช่นการสร้าง Connection ไปยัง Database หลายๆตัว หรือการ return ผลลัพธ์กลับมาเป็น Array หรือ JSON ก็มีให้ใช้งานอย่างครบถ้วน

ส่วน Feature ที่เด็ดมากของ Eloquent คือมีตัว Migration ทำให้เราสร้าง Schema ของ Database เก็บไว้ใน Code เลย (เราสามารถ Generate Table ใหม่กี่ครั้งก็ได้ ) ต่อไปนี้เราไม่ต้องแยกทำ Version Control ของ Database Schema อีกต่อไป

การทำงานกับการ Insert, Update และ Delete แบบทีละหลายๆ Record ก็ทำได้ง่าย

เรื่องของความรวดเร็วก็ต้องบอกว่าทำงานได้เร็ว โดยที่ไม่รู้สึกว่ามี ORM

ส่วนเรื่องของ Database ที่ Support นั้น มีหลายตัว ประกอบไปด้วย MySQL, Postgres, SQLite, and SQL Server เสียอย่างเดียวยังไม่ Support Database ยักษ์ใหญ่อย่าง Oracle

ข้อเสียอีกอย่างที่สำคัญมากคือ การ Mapping แบบ Single Table Inheritance และ Create Table Inheritance ยังทำไม่ได้ แต่ก็มีคนสร้าง plugin ต่างๆ เพื่อพยายามปิดช่องโหว่ตรงนี้

แต่โดยรวมแล้วถือว่าเป็น ORM ที่น่าใช้งานเป็นอย่างยิ่ง

การใช้งาน instanceof ใน JavaScript

Posted on November 22, 2014 by irobustadmin — No Comments ↓

การใช้งาน instanceof ใน JavaScript จะใช้สำหรับการตรวจสอบว่า ตัวแปรตัวนั้น instantiate หรือ new object ขึ้นมาจาก Class นั้นรึเปล่า ดังนั้น instanceof จะเป็น operator ที่เราจะใช้ในการแยกว่า object ตัวนั้นเกิดจาก Class ใด เนื่องจากใน JavaScript ไม่มี keyword Class จึงทำให้ต้องทำการเปรียบเทียบกับ Constructor แทน ดูเพิ่มเติมในเรื่องของการสร้าง Constructor ได้ที่ Object Oriented กับ JavaScript ตอนที่ 1

โดย syntax ของการใช้ instanceof จะเป็นดังนี้

object instanceof constructor

1	object instanceof constructor

ตัวอย่างการใช้งาน

// สร้าง constructors
function C(){}
function D(){}

// new object มาจาก C
var o = new C();

// return ค่า true กลับมา
o instanceof C;

// return ค่า false กลับมา
o instanceof D;

// สร้าง constructors

function C(){}

function D(){}

// new object มาจาก C

var o = new C();

// return ค่า true กลับมา

o instanceof C;

// return ค่า false กลับมา

o instanceof D;

ดังนั้น เราจะสามารถรู้ได้ว่า o นั้นมาจาก Class ไหน มี method อะไร

นอกจากการใช้งาน instanceof ใน JavaScript แล้ว เรายังสามารถใช้กับ PHP ได้ด้วย Syntax ที่ใช้ก็เหมือนกัน

Object Oriented กับ JavaScript ตอนที่ 2

Posted on November 22, 2014 by irobustadmin — No Comments ↓

จากที่เราได้เรียนรู้วิธีการประกาศ Class , การสร้าง Constructor และการกำหนด Property ให้กับ Object กันมาแล้ว ใน Object Oriented กับ JavaScript ตอนที่ 1

ต่อไปเราจะพูดถึงการสร้าง method ให้กับ Class ของเรา โดยเราจะใช้ keyword prototype ซึ่งเราสามารถย้อนกลับไปอ่านเรื่องของการใช้งาน prototype ใน JavaScript ได้ที่การ Casting ใน JavaScript ในบทความนี้เราจะทำเรื่องของการใช้ prototype มาประยุกต์ใช้งาน โดยถ้าเราอยากให้ Method หรือ function อยู่ภายใน Object ใด เราจะใช้การกำหนดให้เป็น function ใน prototype ของ Object นั้น เช่น

// เรากำหนด function sayHello ให้เป็น method ของ Person
Person.prototype.sayHello = function() {
  console.log("Hello, I'm " + this.firstName);
};

// เรากำหนด function sayHello ให้เป็น method ของ Person

Person.prototype.sayHello = function() {

console.log("Hello, I'm " + this.firstName);

};

เวลาเราจะทำการเรียกใช้เราก็จะ new object Person ขึ้นมาแล้วเรียก method say Hello ได้เลย

// Instantiate
var person = new Person();
// กำหนดค่าให้ property
person.firstName = 'Jenny';
// เรียก method sayHello();
person.sayHello();

// Instantiate

var person = new Person();

// กำหนดค่าให้ property

person.firstName = 'Jenny';

// เรียก method sayHello();

person.sayHello();

นอกนี้เรายังสามารถทำให้ sayHello() กลายเป็น Chain method เหมือนใน jQuery ได้โดยทำการ return this ออกมา

// Say Hello จะ return เอาตัวมันเองออกมา 
// ดังนั้นเราจะสามารถเรียกใช้งาน method อื่นๆ ของ object นี้ได้
Person.prototype.sayHello = function() {
  console.log("Hello, I'm " + this.firstName);
  return this;
};

// Say Hello จะ return เอาตัวมันเองออกมา

// ดังนั้นเราจะสามารถเรียกใช้งาน method อื่นๆ ของ object นี้ได้

Person.prototype.sayHello = function() {

console.log("Hello, I'm " + this.firstName);

return this;

};

ดูรายละเอียดเพิ่มเติมเกี่ยวกับการสร้างและการใช้งาน Chain Method ได้ใน ารสร้าง Chain method ใน PHP

Object Oriented กับ JavaScript ตอนที่ 1

Posted on November 22, 2014 by irobustadmin — No Comments ↓

การเขียน JavaScript เราสามารถทำให้เป็น Objet Oriented ได้ แต่เนื่องจากตัว Syntax ของ JavaScript จะแตกต่างจาก Object Oriented ในภาษาอื่นๆ ดังนั้นเราจึงต้องมาเรียนรู้ความแตกต่างของการเขียน Object Oriented ใน JavaScript กัน

เริ่มจากใน JavaScript ไม่มี Class แล้วเราจะเขียน Object Oriented ได้ยังไง คำตอบคือ เราก็ไม่ต้องสร้าง Class เสมือนว่ามันมีอยู่แล้ว เช่นเราสร้าง function ขึ้นมาสำหรับเรื่องของการจัดการ Stock เราก็จะแยกไฟล์ JavaScript มาอีกไฟล์นึงแล้วตั้งชื่อเป็น Person.js แล้วถือเสมือนว่านี่เป็น Class ที่เราสร้างขึ้น หลังจากนั้นตังชื่อฟังก์ชั่นที่เหมือนกับชื่อไฟล์ แล้วมองว่านี่เป็น Constructor ของ Class เช่น

// Save ไว้ใน file ชื่อว่า Person.js
function Person(){
    // Constructor
}

// Save ไว้ใน file ชื่อว่า Person.js

function Person(){

// Constructor

}

ถ้าเราต้องการกำหนดค่าตัวแปรให้กับ Constructor ก็ต้องทำการกำหนดค่าให้กับ property โดยใช้ this.ชื่อตัวแปร

var Person = function (firstName) {
  // กำหนดค่า firstName ที่เข้ามาทาง Constructor ให้กับ Property
  this.firstName = firstName;
};

var person = new Person('John');

var Person = function (firstName) {

// กำหนดค่า firstName ที่เข้ามาทาง Constructor ให้กับ Property

this.firstName = firstName;

};

var person = new Person('John');

หลังจากนั้นถ้าเราต้องการสร้าง property ของ Object เราก็จะทำการสร้างตัวแปรไว้ใน Constructor หรือ ประกาศตัวแปรไว้เฉยๆก็ได้ เช่น

var Person = function () {
  var firstName;
};

var person = new Person();
person.firstName = 'Jack';

var Person = function () {

var firstName;

};

var person = new Person();

person.firstName = 'Jack';

สิ่งที่เราได้จากการ Instantiate หรือ new object ขึ้นมาเราจะได้ instance ของ Object เป็น JSON ที่มี type เป็น Person เพราะ JSON ก็เป็น object อยู่แล้ว นี่ก็เป็นความแปลกอีกอย่างของ JavaScript คือเราสามารถสร้าง Object ได้เลยโดยที่ไม่ต้องมี Class

ต่อไปเราจะพูดถึงการสร้าง Method ให้กับ Class ที่เรามี ในตอนที่ 2

การใช้ ตัวแปรแบบ static ใน PHP

Posted on November 19, 2014 by irobustadmin — No Comments ↓

การใช้ keyword static ใน PHP ไม่ได้มีเฉพาะการใช้สร้าง Static Class หรือ Static Method เท่านั้นแต่เรายังสามารถใช้กับ ตัวแปร ได้ด้วย

โดยปกติตัวแปรที่อยู่ในฟังก์ชั่น อย่างเช่น $x จะเป็น Local Scope ค่าของ $x จะหายไปกลับมากลายเป็น null ทุกครั้ง ดังนั้นถ้าเรียก function doSomething() 3 ครั้ง ค่า $x จะ reset กลับมาเป็น null และผลลัพธ์จะได้เป็น 10 ทั้ง 3 ครั้ง
Read more การใช้ ตัวแปรแบบ static ใน PHP ›

IRobust.co.th

Blog สำหรับ PHP Developer

Object Oriented

หลักการเขียนโปรแกรม ตอนที่ 5

หลักการเขียนโปรแกรม ตอนที่ 4

หลักการเขียนโปรแกรม ตอนที่ 2

การทำให้ object ของเราสามารถใช้ function count ได้เหมือนกับ array

การใช้งาน Eloquent โดยไม่ง้อ Laravel

ทำความรู้จักกับ Eloquent

การใช้งาน instanceof ใน JavaScript

Object Oriented กับ JavaScript ตอนที่ 2

Object Oriented กับ JavaScript ตอนที่ 1

การใช้ ตัวแปรแบบ static ใน PHP

Categories

Tag Cloud