วันเสาร์ที่ 14 ธันวาคม พ.ศ. 2562

ปัญหาในการรันโปรเจ็คเมื่อใช้ Android ที่มี API เวอร์ชันที่ใหม่กว่า (API 29)


ใครที่เอาโปรเจ็คเก่ามารันจะพบว่าไม่สามารถทำงานได้ เนื่องจาก ใน API เวอร์ชันที่ใหม่มีการ import พวก Library ต่างจากเดิม ให้เปลี่ยนตามนี้ดู 

AppCompatActivity
เก่า
import android.support.v7.app.AppCompatActivity;
ใหม่
import androidx.appcompat.app.AppCompatActivity;

Fragment
เก่า
import android.app.Fragment;
เก่า
import android.support.v4.app.Fragment;
ใหม่
import androidx.fragment.app.Fragment;

FragmentActivity
เก่า
import android.support.v4.app.FragmentActivity;
ใหม่
import androidx.fragment.app.FragmentActivity;
FragmentTransaction
เก่า
import android.support.v4.app.FragmentTransaction;
ใหม่
import androidx.fragment.app.FragmentTransaction;

Layout (xml)
เก่า
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
</android.support.constraint.ConstraintLayout>
ใหม่
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android=”http://schemas.android.com/apk/res/android"
</androidx.constraintlayout.widget.ConstraintLayout>

วันพุธที่ 13 พฤศจิกายน พ.ศ. 2562

การสร้างคลาส (Kotlin and Swift for Java Developer)



ปัจจุบันภาษาโปรแกรมสมัยใหม่นั้น รองรับการเขียนโปรแกรมเชิงวัตถุ ไม่ว่าจะเป็น ภาษา Java Swift Python  PHP  C++,C# Objective C เป็นต้น แม้ว่าแนวคิดการเขียนโปรแกรมเชิงวัตถุจะมีมานานแล้วก็ตาม ช่วงปี พ.ศ. 2500-2510 เพื่อเป็นอีกทางเลือกในการเขียนโปรแกรมเพื่อแก้ปัญหา ซึ่งเดิมทีจะใช้การเขียนโปรแกรมเชิงโครงสร้างในการแก้ปัญหา

การศึกษาการเขียนโปรแกรมเชิงวัตถุนั้นยังเป็นพื้นฐานในการเรียนรู้ Design Patterns ช่วยให้การออกแบบซอฟต์แวร์มีแบบแผนที่ดี แต่ทั้งนี้ขึ้นอยู่กับองค์ความรู้ของผู้ที่ประยุกต์ใช้งานด้วยเช่นกัน

Design Patterns ได้รับการเผยแพร่ในหนังสือ Design Patterns: Elements of Reusable Object-Oriented Software ตั้งแต่ปี 2538 ซึ่งถูกนำมาประยุกต์ใช้งานจริงอย่างแพร่หลาย อาทิ เช่น Singleton,  Facade, Strategy เป็นต้น   และใน Kotlin มี คีย์เวิร์ค Object ในการสร้างคลาสแบบ Singleton

การสร้างคลาสในภาษา Java

ไวยากรณ์
class ClassName {
   modifiers data_type properties;
   modifiers return_type method() { }
}
modifier แบ่งเป็น
- access modifier เช่น default, public, protected, private
- non access modifier เช่น static, final, abstract, synchronized กับ volatile (threads)

ตัวอย่าง
// Product.java
public class Product {
    private String productID;
    private String productName;
    Product(String p_id, String p_name){
      productID = p_id;
      productName = p_name;
    }
    public String getDetailProduct(){
      return "Product ID : "+productID+" and Product Name : "+productName;
    }
}

// TestDriveClass.java
public class TestDriveClass {
    public static void main(String[] args) {
        Product p = new Product("P0001","Nintendo Switch");
        System.out.println(p.getDetailProduct());
    }
}

การสร้างคลาสในภาษา Kotlin

ไวยากรณ์
class ClassName {
   modifiers val properties:data_type
   modifiers fun method():return_type{
   }
}
modifier เกี่ยวกับ access control เช่น public, internal, fileprivate, private

ตัวอย่าง
// Product.kt
public class Product1 {
    private val productID:String
    private val productName:String
    constructor(p_id:String, p_name:String){
      productID = p_id
      productName = p_name
    }
    public fun getDetailProduct():String{
      return "Product ID : $productID and Product Name :  $productName"    
    }
}

// TestDriveClassK.kt  ไม่ต้องสร้างคลาสเพื่อเรียกใช้ กำหนด Main Class ใน Configuration เป็น TestDriveClassKKt
fun main(){
    val p1 = Product1("P0002","Play Station 4")
    println(p1.getDetailProduct())
}

มี constuctor 2 แบบ

primary constructor
class Product constructor(productName: String) { … }
หรือละคำว่า constructor
class Product (productName: String) { … }

secondary constructor
init{…}  // ใช้ตอนสร้างอ็อบเจ็คแบบไม่ระบุพารามิเตอร์ มีมากกว่า 1 ได้
constructor(){...} // กรณีมีการระบุพารามิเตอร์หลายรูปแบบ

modifier เช่น open, override

เนื้อหาที่เกี่ยวข้อง

การสร้างคลาสในภาษา Swift 

ไวยากรณ์
class ClassName {
   modifiers var properties:data_type
   modifiers func method()->return_type{
   }
}
modifier เกี่ยวกับ access control เช่น public, internal, fileprivate, private
เนื้อหาที่เกี่ยวข้อง

ตัวอย่าง ใช้ playground 
public class Product {
    private var productID:String
    private var productName:String
    init(p_id:String, p_name:String){
      productID = p_id
      productName = p_name
    }
    public func getDetailProduct()-> String{
      return "Product ID : \(productID) and Product Name : \(productName)"
    }
}

var p = Product(p_id:"P0001",p_name:"Nintendo Switch")
print(p.getDetailProduct())
print(p.getDetailProduct()+"\n")

การสร้างคลาสในภาษา PHP

ไวยากรณ์
class ClassName {
   modifiers $properties
   modifiers function method(){   // ไม่ต้องระบุ return type
       return // กรณีมีการส่งค่ากลับ
  }
}

modifier 
public, private, protected, abstract, final ใช้ได้กับ function
public, private, protected ใช้ได้กับ properties
abstract, final ใช้ได้กับ class
ตัวอย่าง PHP 7.x
class Product {
    private $productID;
    private $productName;
    function __construct($p_id,$p_name){
      $this->productID = $p_id;
      $this->productName = $p_name;
    }
    public function getDetailProduct(){
       return "Product ID : ".$this->productID." and Product Name : ".$this->productName;
    }
}
$p = new Product("P0001","Nintendo Switch");
print $p->getDetailProduct();

function หากไม่ระบุ modifier จะเป็น public

การสร้างคลาสในภาษา Python

ไวยากรณ์
class ClassName:
    def __init__(self):
    def method(self):
}

ตัวอย่าง Python 3.x
class Product:
    def __init__(self, product_id, product_name):
        self.product_id = product_id
        self.product_name = product_name

    def getDetailProduct(self):
        return "Product ID : "+self.product_id+" and Product Name : "+self.product_name

p1 = Product("P0001", "Nintendo Switch")
print(p1.getDetailProduct())
modifiers ของ properties
self.name=name # public attribute
self._name=name # protected attribute
self.__name=name  # private attribute
modifiers ของฟังก์ชัน เช่น public, private, and protected
notation เช่น @staticmethod



วันพฤหัสบดีที่ 7 พฤศจิกายน พ.ศ. 2562

การประกาศค่าตัวแปร และการแสดงผลในภาษาต่างๆ (Java, Kotlin, Swift, C#, PHP,Python, Java Script, Type Script, C/C++, Objective C)




Java
ไวยากรณ์
type variable;
variable = value;
or
type variable = value;
ตัวอย่าง
int number;
number = 5;
System.out.print(number);
Integer number2;
Integer เป็น Object Type หรือจากคลาส Integer

Kotlin
ไวยากรณ์
var variable : type
variable = value
or 
var variable : type = value
or 
var variable = value 

ตัวอย่าง
var number:Int
number = 5
print(number)

Int ในภาษา Kotlin เป็นคลาส

Swift 
ไวยากรณ์
var variable : type

ตัวอย่าง
var number:Int
number = 5
print(number)

สามารถประกาศแบบ Type inference แบบภาษา Kotlin และ PHP ก็ได้เช่นกัน
Int ในภาษา Swift เป็นโครงสร้าง ไม่ใช่ คลาส

C#
ไวยากรณ์
type variable = value;

ตัวอย่าง
number = 5;
int number1 = 5;
Int32 number2;
Console.Write(number);

Int32 เป็นคลาส
int ในภาษา C# มีขนาด 32 bit

PHP
ไวยากรณ์
$variable = value;

ไม่จำเป็นต้องประกาศชนิดข้อมูลก่อน มีลักษณะเป็น Type inference คือ อ้างอิงจากค่าที่กำหนด
หน้าชื่อตัวแปรต้องนำหน้าด้วยเครื่องหมายดอลลาร์ ($ )

ตัวอย่าง
$number = 5;
echo $number;

สามารถใช้ echo , echo () หรือ print, print()

Python
ไวยากรณ์
variable = value
มีลักษณะ Loosely typed คือไม่จำเป็นต้องประกาศชนิดข้อมูล

ตัวอย่าง
number = 5
print(number)

Java Script
ไวยากรณ์
var variable_name;
variable = value;
or 
var variable = value;

ตัวอย่าง
var number;
number = 5;
document.write(number);  // แสดงผลที่ body
console.log(number);  // แสดงผลที่ console

นำไปแสดงผลในแท็ก HTML ตามแอททริบิวต์ไอดีที่กำหนด
document.getElementById(“show_num”).innerHTML = number;
<h1 id=”show_num”><h1>

Type Script
ไวยากรณ์
var variable;
variable = value;
or 
var variable_name = value;

ตัวอย่าง
var number = 5;
console.log(number)

C/C++
ไวยากรณ์
data_type variable;
variable = value;
or
data_type variable = value;
ตัวอย่าง
int number;
number = 5;

printf("value of number : %d \n", number); // C ต้อง include <stdio.h>
cout << number;  // C++ ต้อง include <iostream>

Objective C
ไวยากรณ์
data_type variable;
variable = value;
or
data_type variable = value;
ตัวอย่าง
int number;
number = 5;

NSLog(@"Number is : %d",number);

วันพุธที่ 6 พฤศจิกายน พ.ศ. 2562

Structureในภาษา Swift

Structureในภาษา Swift




โครงสร้าง(Structure) เป็นกระบวนทัศน์ที่สำคัญในการเขียนโปรแกรมภาษา Swift ไม่ว่าจะเป็นชนิดข้อมูลต่างๆที่ใช้ในภาษา Swift มีลักษณะเป็นโครงสร้าง ซึ่งรายละเอียดของโครงสร้างไม่เพียงแค่ข้อมูล แต่ยังรวมไปถึงคำสั่งที่ทำหน้าที่ในการประมวลผลข้อมูล
ล่าสุด SwiftUI เป็นเฟรมเวิร์คสำหรับสร้าง UI สำหรับระบบปฏิบัติการต่างๆ ของแอปเปิล (macOS, iOS, iPadOS, watchOS, tvOS) ซึ่งเปิดตัวในงาน WWDC 2019 ก็มีลักษณะ structure เช่นเดียวกัน ดังนั้นเพื่อจะทำความเข้าใจใน SwiftUI ก็ควรทำความเข้าใจกับ Structure ในภาษา Swift

เมื่อเราได้ทำการนิยามโครงสร้าง สิ่งที่เรากำลังทำคือการประกาศชนิดข้อมูลที่อาจจะจัดเก็บตัวแปรหรือค่าคงที่ ที่เรียกว่า พร็อพเพอตี้ (properties) และรวมถึงฟังก์ชัน เรียกว่า เมธอด (method) ต่อมาเราทำการประกาศตัวแปรและค่าคงที่ของชนิดข้อมูลนี้ขึ้นมาเพื่อทำการจัดเก็บรายละเอียดของข้อมูลด้วยที่นิยามโดยโครงสร้าง ค่าต่างๆเหล่านั้น เรียกว่า อินสแตน (instances) มีลักษณะที่เป็นเอกลักษณ์ ซึ่งในแต่ละอินแตนจะมีค่าและเมธอดของตนเอง

การนิยามโครงสร้าง

การนิยามโครงสร้างใหม่ เราจะต้องใช้คีย์เวิร์ด struct ห่อหุ้มด้วยข้อมูลและฟังก์ชันการทำงานอยู่ภายในเครื่องหมายปีกกา(braces)
รายการคำสั่งที่ 6‑1 การประกาศชนิดโครงสร้าง
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price : Double = 0.0
}
รายการคำสั่งที่ 6–1 นิยามโครงสร้างที่เรียกว่า Product ประกอบด้วย 3 พร็อพเพอตี้ คือ amount, name และ price การนิยามไม่ได้ทำการสร้างอะไรเกิดขึ้นมา เปรียบเสมือนกับพิมพ์เขียวที่ใช้ในการสร้างโครงสร้างจริงขึ้นมา
รายการคำสั่งที่ 6‑2 การประกาศตัวแปรที่มีชนิดข้อมูลเป็น Product
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price : Double = 0.0
}
var product1 : Product = Product()
รายการคำสั่งที่ 6–2 ทำการสร้างตัวแปรที่มีชนิดข้อมูลเป็น Product ที่ทำการจัดเก็บค่าอินสแตนของ โครงสร้าง Product ที่มีพร็อพเพอตี้ amount, name และ price อินสแตนที่ถูกสร้างโดย Product() ที่เป็น Initializer และทำการกำหนดไปยังตัวแปร product1
พร็อพเพอตี้ของอินสแตนใหม่ที่สร้างขึ้นมาจะมีค่าที่ถูกประกาศอยู่ในการนิยามในโครงสร้าง ในที่นี้คือ 0 , “Empty” และ 0.0 ซึ่งเราสามารถทำการเปลี่ยนแปลงค่าได้เหมือนกับการเปลี่ยนแปลงค่าของตัวแปรอื่นๆ ในการเข้าถึงพร็อพเพอตี้ในโครงสร้าง มีรูปแบบของไวยากรณ์คือ variable.property ซึ่ง variable คือ ชื่อของตัวแปรที่จัดเก็บค่าอินสแตนของโครงสร้างและพร็อพเพอตี้คื้อขื่อของพร็อพเพอตร้ที่เราต้องการเข้าถึง
รายการคำสั่งที่ 6‑3 การกำหนดค่าใหม่ให้กับพร็อพเพอตี้ของโครงสร้าง
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price : Double = 0.0
}
var product1 : Product = Product()
product1.amount = 5
product1.name = “iPhone7”
product1.price = 21900.00
var totalValue = Double(product1.amount) * product1.price
print(“Total value of \(product1.name) is \(totalValue) baht”)
// “Total value of iPhone7 is 109500.0 baht”
โครงสร้างอาจจะเป็นอินสแตนภายในโครงสร้างอื่น ตราบเท่าที่จำเป็นแบบไม่จำกัด โดยการใช้ dot notation ในการขยายเพื่อเข้าถึงในทุกๆอีลีเมนต์ในโครงสร้าง
รายการคำสั่งที่ 6‑4 การสร้างโครงสร้างภายในโครงสร้าง
struct Price {
var TH = 0.0
var USD = 0.0
}
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price = Price()
}
var product1 = Product()
product1.amount = 5
product1.name = “iPhone7”
product1.price.TH = 21900.00
product1.price.USD = 644
จากรายการด้านบนเป็นการสร้างโครงสร้าง Price เป็นส่วนหนึ่งของโครงสร้าง Product 

เมธอดของ Structures

โครงสร้างเป็นชนิดข้อมูลที่มีความซับซ้อน เช่นเดียวกับ tuple เราสามารถกำหนดชุดคำสั่งเป็นส่วนหนึ่งภายในโครงสร้างได้ สิ่งที่กำหนดลงไปเรียกกว่าฟังก์ชัน ซึ่งฟังก์ชันที่อยู่ในโครงสร้างเรียกกว่า เมธอด(method)
รายการคำสั่งที่ 6‑5 การนิยามเมธอด
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price : Double = 0.0
func total() -> Double {
let totalValue = Double(amount) * price
return totalValue
}
}
var product1 : Product = Product()
product1.amount = 5
product1.name = “iPhone7”
product1.price = 21900.00
print(“Total Value : \(product1.total())”) // “Total Value : 109500.0“
การทำการเปลี่ยนแปลงค่าพร็อพเพอตี้ในโครงสร้าง สามารถทำได้โดยใช้คีย์เวิร์ด mutating หน้าฟังก์ชันหรือเมธอดที่ทำการเปลี่ยนแปลงค่าของพร็อพเพอตี้
รายการคำสั่งที่ 6‑6 การกำหนดค่าใหม่ให้กับพร็อพเพอตี้จากภายในโครงสร้าง
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price : Double = 0.0
mutating func total() {
let totalValue = Double(amount) * price
name += “ \(totalValue) Baht”
}
}
var product1 : Product = Product()
product1.amount = 5
product1.name = “iPhone7”
product1.price = 21900.00
product1.total()
print(“Total Value : \(product1.name)”)
// “Total Value : iPhone7 109500.0 Baht“

การกำหนดค่าเริ่มต้นของ Structures

ในทุกๆอินสแตนที่เราทำการสร้างจากการนิยามโครงสร้างมีวัตถุประสงค์ในการจัดเก็บและประมวลผลข้อมูล ตัวอย่างเช่น เราทำการสร้างหลายๆ อินสแตนของโครงสร้างของสินค้า ทำการจัดเก็บข้อมูลของสินค้าต่างๆ แต่ละสินค้าจะมีชื่อและราคาสินค้าที่แตกต่างกัน ดังนั้นพร็อพเพอตี้ของแต่ละอินสแตนจำเป็นต้องมีการกำหนดค่าเริ่มต้นด้วยค่าที่เหมาะสม การกำหนดค่าเริ่มต้นให้กับอินสแตนเป็นการทำงานโดยทั่วไป และจะมีความยุ่งยากหากจะต้องกำหนดค่าแต่ละค่าให้กับอินสแตนที่ได้สร้างขึ้นมา ภาษา Swift จึงได้นำเสนอทางเลือกที่แตกต่างในการกำหนดค่าเริ่มต้น วิธีที่สะดวกที่ทำโดยส่วนใหญ่ เรียกกว่า memberwise initializer
รายการคำสั่งที่ 6‑7 การกำหนดค่าเริ่มต้นให้กับพร็อพเพอตี้
struct Product {
var amount : Int = 0
var name : String = “Empty”
var price : Double = 0.0
}
var product1 = Product(amount : 5, name : “iPhone7”, price : 21900.00)
var total = Double(product1.amount) * product1.price
print(“Total Value : \(total)”) “Total Value : 109500.0“
จากรายการคำสั่งที่ 6–7 เป็นการกำหนดค่าให้กับพร็อพเพอตี้ด้วยค่าเริ่มต้น และถูกแทนที่ด้วยค่าเริ่มต้นในตอนสร้างตัวแปรแบบโครงสร้าง
รายการคำสั่งที่ 6‑8 การกำหนดค่าเริ่มต้นให้กับโครงสร้างด้วย memberwise initializer
struct Product {
var amount : Int
var name : String
var price : Double
}
var product1 = Product(amount : 5, name : “iPhone7”, price : 21900.00)
var total = Double(product1.amount) * product1.price
print(“Total Value : \(product1.name) \(total)”) “Total Value : iPhone 7 109500.0“
จากคำสั่งด้านบนเราไม่จำเป็นต้องกำหนดค่าเริ่มต้นให้กับตัวแปรในโครงสร้าง แต่กำหนดค่าเริ่มต้นจากการสร้างตัวแปรโครงสร้าง
อีกรูปแบบหนึ่งของการกำหนดค่าเริ่มต้นให้กับโครงสร้าง ที่มีหลายๆพร็อพเพอตี้คือการใข้เมธอดที่เรียกว่า init() ซึ่งเมธอด init() จะถูกเรียกใช้ในทันทีที่อินสแตนถูกสร้างขึ้นมา
รายการคำสั่งที่ 6‑9 การกำหนดค่าเริ่มต้นจากเมธอด init()
struct Price {
var USD : Double
var TH : Double
init() {
USD = 5.99
TH = USD * 34.55
}
}
var productPrice = Price()
print(productPrice.USD) // 5.9900000000000002
print(productPrice.TH) // 206.9545
รายการคำสั่งที่ 6‑10 การประกาศ init() ด้วยพารามิเตอร์
struct Price {
var USD : Double
var TH : Double
init(usa:Double) {
USD = usa
TH = USD * 34.55
}
}
var productPrice = Price(usa: 5)
print(productPrice.USD) // 5.0
print(productPrice.TH) // 172.75
รายการคำสั่งที่ 6‑11 การกำหนดค่าเริ่มต้นจากเมธอด init() ที่มีมากกว่า 1 ด้วยพารามิเตอร์
struct Price {
var USD : Double
var TH : Double
init(usa:Double) {
USD = usa
TH = USD * 32.84
}
init(thai:Double) {
TH = thai
USD = thai * 0.030451
}
}
var productPrice = Price(thai: 5000)
print(productPrice.USD) // 152.255
print(productPrice.TH) // 5000.0

วันเสาร์ที่ 6 มกราคม พ.ศ. 2561

โครงสร้างองค์กรในการบริหารโครงการ

โครงสร้างองค์กรในการบริหารโครงการ

          การเข้าใจถึงโครงสร้างองค์กร มีส่วนสำคัญต่อการบริหารงานโครงการเช่นเดียวกัน รูปแบบของโครงสร้างองค์กรที่สามารถพบได้ มีดังนี้ โครงสร้างองค์กรตามหน้าที่ (Functional Organization) โครงสร้างองค์กรแบบเมตริกซ์ (Matrix Organization) และโครงสร้างองค์กรแบบโครงการ (Projectized) ซึ่งในแต่ละโครงสร้างก็จะมีลักษณะของการบริหารงานและอำนาจหน้าที่ของผู้บริหารโครงการแตกต่างกันไป

๑.       โครงสร้างองค์กรตามหน้าที่

โครงสร้างองค์กรมีการจัดพนักงานโดยแบ่งเป็นแผนก การรายงานผลการทำงานก็รายงานไปยังผู้จัดการที่พนักงานเหล่านั้นสังกัดอยู่ มีงานจำนวนมาก พนักงานทำงานโครงการไม่เต็มเวลา ผู้บริหารโครงการ มีอำนาจน้อยหรือไม่สามารถควบคุม และไม่สามารถควบคุมงบประมาณ

๒.     โครงสร้างองค์กรแบบเมตริกซ์

          ลักษณะโครงสร้างองค์กรแบบเมตริกซ์สมาชิกในทีมจะต้องรายงานผลการทำงานไปยังผู้จัดการที่พนักงานเหล่านั้นสังกัดอยู่และผู้บริหารโครงการ โครงสร้างแบบเมตริกซ์ยังสามารถแบ่งออกได้อีก ๓ รูปแบบ คือ เมตริกซ์แบบสมดุล (Balanced Matrix)  เมตริกซ์แบบอ่อน (Weak Matrix) และ เมตริกซ์แบบแข็ง (Strong Matrix) ซึ่งในแต่ละรูปแบบผู้บริหารโครงการมีอำนาจและหน้าที่ดังนี้
          เมตริกซ์แบบสมดุล ผู้บริหารโครงการสทำงานเต็มเวลา อำนาจในการบริหารและจัดหาทรัพยากรอยู่ในระดับต่ำถึงกลาง มีส่วนร่วมในการควบคุมงบประมาณกับผู้บริหารฝ่ายอื่นๆ

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

          เมตริกซ์แบบแข็ง  ผู้บริหารโครงการสทำงานเต็มเวลา อำนาจในการบริหารและจัดหาทรัพยากรอยู่ในระดับกลางถึงสูง มีสิทธิ์เต็มที่ในการควบคุมงบประมาณ

๓.     โครงสร้างองค์กรแบบโครงการ

ในโครงสร้างการบริหารงานแบบโครงการ สมาชิกในทีมไม่มีแผนกที่สังกัดแต่จัดอยู่ตามโครงการต่างๆ อยู่ภายใต้การบริหารงานโดยผู้บริหารโครงการและอุทิศเวลาในการทำโครงการเต็มเวลา ผู้บริหารโครงการทำงานเต็มเวลาเช่นเดียวกัน มีอำนาจในการบริหารและจัดหาและใช้ทรัพยากรอยู่ในระดับสูง และควบคุมงบประมาณได้เต็มที่


ที่มา: เอกสารประกอบการสอน รายวิชา การจัดการโครงการซอฟต์แวร์, อาจารย์นฤพล สุวรรณวิจิตร, สาขาวิชาวิศวกรรมซอฟต์แวร์ มหาวิทยาลัยราชภัฏนครปฐม, 2558.


วันพฤหัสบดีที่ 4 มกราคม พ.ศ. 2561

คำสั่ง When ในภาษา Kotlin

คำสั่ง When ในภาษา Kotlin


การใช้คำสั่ง when ถูกนำมาใช้แทนคำสั่ง switch ในภาษาที่มีโครงสร้างคล้ายกับภาษา C (ภาษา C, C++, C#, java เป็นต้น)
รูปแบบการใช้คำสั่ง แบบมีพารามิเตอร์
when (data) {
    1 -> print("1")
    2 -> print("2")
    else -> {
        print("ค่าข้อมูลไม่ใช่ทั้ง 1 และ 2")
    }
}

               การตรวจสอบค่าข้อมูล data ซึ่งเป็นพารามิเตอร์ หากข้อมูลมีค่าเป็น 1 ก็จะแสดงค่า 1 ออกทางหน้าจอ และในกรณีเดียวกัน หากข้อมูลมีค่าเป็น 2 ก็จะแสดงค่า 2 ออกมาทางหน้าจอ และหากไม่ใช่ทั้ง 1 หรือ 2 ก็จะแสดงข้อความว่า ค่าข้อมูลไม่ใช่ทั้ง 1 และ 2
รูปแบบการใช้คำสั่ง แบบไม่มีพารามิเตอร์
var price:Int = 150
var msg:String = "goodbye!!"
val data = when {
    price in 100..200 -> "buy"
    msg.contains("bye") -> "bye"
    else -> ""
}
print(data)
             
               จากคำสั่งด้านบนตัวแปร data จะมีค่าเป็น “buy” เนื่องจากตรงกับเงื่อนไขแรก ที่ price มีค่าอยู่ระหว่าง 100 ถึง 200 และออกจากเงื่อนไขถึงแม้ว่าคำสั่งถัดมาจะเป็นจริงก็ตาม

ที่มา:

Kotlin. (n.d.). Control Flow: if, when, for, while. Retrieved from kotlinlang.org: https://kotlinlang.org/docs/reference/control-flow.html
Leiva, A. (n.d.). Using “when” expression in Kotlin: The “switch” with super powers (KAD 13). Retrieved from Antonio Leiva: https://antonioleiva.com/when-expression-kotlin/