วันจันทร์ที่ 4 มีนาคม พ.ศ. 2562

ข้อมูลประวัติการทำงาน และประวัติการศึกษา


ประวัติการทำงาน



ปี 2014-2015 - Freelancer ตำแหน่ง iOS Developer
หลังจากเรียนจบ ผมกับกลุ่มเพื่อนสนิทก็ได้รวมตัวกันรับงานนอก และเช่าบ้านใกล้ๆกับ มหาวิทยาลัยบูรพา อยู่ประมาณ 1 ปีครับ จนมีอยู่วันหนึ่ง ได้มีโอากาสทำงานให้กับบริษัท 4DBook และก็ได้ย้ายไปทำงานประจำกับ 4DBook ในเวลาต่อมา เนื่องจากรายได้มั่นคงมากกว่า





ปี 2015-2017 - 4DBook ตำแหน่ง iOS Developer / Graphic Designer / อื่นๆ
ตอนผมเข้ามาทำงานที่นี่ในฐานะโปรแกรมเมอร์คนแรกของบริษัทครับ เพราะที่ผ่านมาบริษัทใช้ Outsource ทั้งหมด และเนื่องจากในช่วงแรกนั้น ยังไม่ค่อยมีเพื่อนร่วมงาน ทำให้เราต้องพยายามศึกษา และทำงานหลายๆด้าน พร้อมกัน ตั้งแต่กระบวนการเก็บความต้องการของลูกค้า , การออกแบบ UX/UI ให้กับโปรแกรม , พัฒนาโปรแกรม , ทำภาพโฆษณา , ทำโปรโมทโฆษณา ยิง Ads , เป็น Admin page ใน Facebook , สรุปรายงานผล/ทำเอกสารคู่มือต่างๆ และจนถึงออกแบบทำเสื้อให้กับบริษัท  ถือว่าเป็นช่วงที่สาหัสสุดๆ แต่ก็ได้ประสบการณ์ และความสนุกเยอะมากๆ ครับ (ช่วงนี้ผมก็กำลังเรียนปริญญาโท วันเสาร์อาทิตย์ ทั้งวันด้วย)




ปี 2015-ปัจจุบัน - Stockmation ในฐานะ ผู้ก่อตั้ง
อย่างที่ผมบอกไว้ก่อนหน้านี้ ว่าช่วงนี้เป็นช่วงที่ผมได้เรียนปริญาโทและทำงานไปพร้อมๆกัน ทำให้ผมได้เจอกลุ่มเพื่อนใหม่ๆ มากมาย ซึ่งอาจารย์ที่ปรึกษา และ เพื่อนๆ ปริญาโท ก็ชวนผมทำวิจัยเกี่ยวกับพวกระบบวิเคราะห์การลงทุนในตลาดหุ้น โรบอท AI และอื่นๆ และก่อตั้งบริษัทด้านนี้โดยตรง ถือว่าเป็นการเรียนต่อที่คุ้มค่ามากๆ





ปี 2017-ปัจจุบัน - Deknerd ตำแหน่ง Project Manager
ผู้ก่อตั้งบริษัทนี้เป็นคนเดียวกับบริษัท 4DBook ครับ หลังจากย้ายมายังบริษัท Deknerd ผมก็ได้เลื่อนขั้นมาเป็น Project Manager ทันที พร้อมกับลูกทีมใหม่ทั้งหมด แต่งานเขียนโปรแกรม และงานอื่นๆ ผมก็ยังคงทำอยู่เหมือนเดิมนะ เพียงแต่มีงานของ PM เพิ่มเข้ามาครับ




ประวัติการศึกษา
- ปริญญาโท Information Technology (MIT) ที่ Burapha University
- ปริญญาตรี Computer Science (CS) ที่ Burapha University

วันพฤหัสบดีที่ 7 พฤษภาคม พ.ศ. 2558

หัดเขียน Swift ตอนที่ 5 - Array



Collection พื้นฐานในภาษา Swift ที่จะพูดถึงในวันนี้ ก็คือ Array และ Dictionary ครับ มาเริ่มกันเลย!


Array

สำหรับอาเรย์ในภาษา Swift สามารถประกาศและเรียกใช้ได้ โดยมีวิธีดังตัวอย่างต่อไปนี้



จากภาพตัวอย่าง เรา กำหนด ค่า  [1,2,3,4,5]  ซึ่งเป็นข้อมูลที่มีรูปแบบโครงสร้างของอาเรย์ในภาษา Swift ดังนั้น ตัวแปรที่ชื่อ array จึงเป็นอาเรย์ ที่เก็บข้อมูลตัวเลข 1 ถึง 5 ตามลำดับ (ลำดับมีความสำคัญ)

หรือเราจะกำหนดชนิดของข้อมูลที่ต้องการเก็บลงอาเรย์ไว้ตอนประกาศเลยก็ได้ ดังนี้


          จากภาพตัวอย่าง จะเห็นว่าเราสามารถกำหนดให้อาเรย์ เก็บได้เฉพาะข้อมูลที่เป็น Interge เท่านั้น 

ดังนั้น พอผมทำการเพิ่มข้อมูลชนิด String ลงไปในอาเรย์ด้วยเมดตอด append() จึงเกิด Error ขึ้นครับ

แถม :


        จากภาพเป็นการเพิ่มข้อมูลตัวเลขลงในอาเรย์ทีละหลายๆตัวในคำสั่งเดียว โดยใช้เมดตอดชื่อ extend()



ทั้งหมดนี่ก็เป็นการใช้ Array อย่างง่ายๆนะครับ ยังมีmethod อีกหลายตัวที่ผมไม่ได้ใช้ให้ดู และถ้าถามว่า อาเรย์ในภาษา Swift นั้น  มีวิธีที่สามารถเก็บค่าแบบหลายๆชนิด ในอาเรย์ชุดเดียวกันได้ไหม ตอบว่า ได้นะครับ แต่ไว้ผมจะพูดถึงทีหลังครับ :3  ในบทความต่อไป เราจะไปต่อกันเรื่อง Dictionary นะครับ





วันพุธที่ 6 พฤษภาคม พ.ศ. 2558

หัดเขียน Swift ตอนที่ 4 - Optionals , Forced Unwrapping , Implicit Unwrapping



นบทความที่ผ่านๆมา เราได้ก็รู้พื้นฐานต่างๆของ Swift ไปบ้างแล้ว ได้แก่ ตัวแปร , ค่าคงที่ , ชนิดตัวแปร , สตริง และพวก control flow ต่างๆ (loop , if else , switch case) ดังนั้น ในบทความนี้ ผมจะเขียนถึงพื้นฐานที่ Advance ขึ้น ( อย่าเพิ่ง งง คำว่า พื้นฐานแบบ Advance 5555+ คือผมจะบอกว่า มันคือพื้นฐานของเจ้าภาษานี้ แต่ภาษาอื่นผมยังไม่เคยเห็นเค้าใช้กัน ) ซึ่งก็คือ Optionals , Forced unwrapping และ Implicit Unwrapping 

nil , Null หรือ NULL คำนี้ทุกคนคงรู้จักกันอยู่แล้ว แต่บางคนไม่รู้จักอันตรายของมัน คนที่เขียนโปรแกรมไม่รอบครอบ(อย่างผม) ก็มักจะโดนเจ้าค่า nil นี้ทำงานของผม บุ้ง! กลายเป็นโกโก้ครั้นไปหลายครั้งแล้วครับ เช่น API ภายนอกที่โปรแกรมของผมใช้งานอยู่ เกิดล่ม หรือมีการปรับเปลี่ยน ทำให้โปรแกรมผมได้ค่า nil เอาไปใช้ แล้วไม่ได้มีการดักเรื่องเหตุการณ์นี้เอาไว้ โปรแกรมผมก็เลยแครช!   (ดีนะยังไม่ตกงาน) ดังนั้นในภาษา Swift นี้ เค้าจะให้ความสำคัญกับเรื่องนี้มากๆ หากไม่มีความจำเป็นจริงๆ ก็ไม่ควรมีค่า nil เก็บอยู่ในตัวแปรเลยหล่ะครับ 0_0    งั้นเอาเป็นว่า เรามาเริ่มกันเลยดีกว่าครับ



จากภาพ ผมลองประกาศตัวแปร str เป็น String ซึ่งให้เก็บค่า nil ผลที่ได้ก็คือ Error ครับ เพราะใน Swift นั้น String ต้องเก็บ String value ครับ ส่วน nil มันไม่ใช่ String


แล้วถ้าผมอยากเก็บ nil จริงๆ ล่ะ เพราะบางทีเราไม่รู้ค่าในตอนเริ่มต้น แต่อยากประกาศมันไว้ก่อน ซึ่งก็ทำได้ครับ แต่คุณจะต้องใช้ ”Optional”  ซึ่งหมายถึง จะมีค่าอยู่ หรือไม่มีค่าอยู่ ก็ได้ (“have a value” or “may have a value”)  ซึ่งในภาษาอื่นๆ เรามักจะใช้ค่า -1 หรือ 0 เพื่อบอกว่า ไม่มีค่าเก็บอยู่ 



วิธีการใช้ Optionals

แบบง่ายสุดเลย คือเพิ่มเครื่องหมายคำถาม “?” ไว้ที่หลังชนิดตัวแปร เช่น




จากภาพตัวอย่าง จะเห็นว่า  str ตัวแรกที่ไม่ได้ประกาศเป็น Optional และไม่มีการกำหนดค่าเริ่มต้นให้ จะมี Error เกิดขึ้น แต่กับ str2 ดันไม่มี Error และยังสามารถเก็บค่า nil ได้ด้วย เพราะว่า str2 ประกาศเพิ่มไว้ว่าเป็น Optional นั่นเอง



จากตัวอย่าง เราประกาศ Optional ให้ str ไว้ ซึ่งพอ str เรียกใช้ method ชื่อ uppercaseString ดันเกิด Error ขึ้นดังภาพ ทั้งที่ปกติตอนไม่ได้ประกาศOptional ก็ใช้ได้นี่หว่า สาเหตุที่เป็นเช่นนี้ ก็เพราะว่า String กับ String? ถือเป็นคนละตัวกันจึงใช้ต่างกัน (String? สามารถเก็บได้ทั้ง String และ nil) ซึ่งตัว String? ไม่มี Method ชื่อ uppercaseString เหมือน String ครับ   ส่วนสาเหตุนั้นผมคิดว่า สมมุติว่าถ้า String? เก็บค่า nil อยู่ แล้วเราไปเรียกใช้ method  uppercaseString (แปลงเป็นตัวอักษรพิมพ์ใหญ่) มันก็จะมีปัญหาน่ะสิครับ เพราะแปลง nil เป็นอักษรพิมพ์ใหญ่ไม่ได้!   ซึ่งถือเป็นข้อดีที่ทำให้โปรแกรมของเรามีประสิทธิภาพกว่าเดิม ลดจำนวน Bug ที่อาจจะเกิดขึ้นได้ในอนาคต :)

จาก Error ดังกล่าว ถ้าเราอยากแปลงเป็นตัวพิมพ์ใหญ่ล่ะ ทำยังไง?  ไม่ยากครับ เราแค่ทำการตรวจสอบค่าก่อนใช้งาน ดังนี้


จากภาพ เรา assign ค่าของ str ไปไว้ที่ตัวแปร unwrappedStr ก่อน ซึ่งหากค่าที่ได้ ไม่ใช่ค่า nil (เป็น String Value) เงื่อนไข if ก็จะเป็นจริง จากนั้นค่อยเรียกใช้method uppercaseString ครับ  แต่ถ้า เป็น nil ก็จะไปเข้า Else แทนครับ ซึ่งเราจะไม่ยอมให้เรียกใช้ method uppercaseString โดยเด็ดขาด (เสี่ยงต่อการแครชมาก)  ดังนั้น นี่จึงเป็นวิธีที่เราควรใช้!  


Forced unwrapping

ส่วนอีกวิธีหนึ่งที่สามารถทำให้ Optional สามารถเรียกใช้ method ของ String ได้ โดยไม่ต้องตรวจสอบ if - else ก่อนเหมือนข้างบน คือ ใช้ Forced unwrapping ครับ คำว่า Forced ก็เหมือนกับการบังคับให้ทำไม่ว่ายังไงก็ตาม คล้ายกับ Force Close หรือบังคับปิดโปรแกรมแบบ ใช้ Ctrl+Alt+Delete แบบนั้นเลย ซึ่งถ้าเรามั่นใจว่าจะไม่เกิดปัญหาภายหลัง ก็ใช้ได้ครับ แต่ถ้าไม่ ก็อย่าใช้ไปเด็ดขาด! ดังนั้น Forced unwrapping จะใช้เมื่อตัวแปรนั้นมีค่าเก็บอยู่ 100% ถ้าเป็น nil จะ Error ครับ ดังนั้นเมื่อแน่ใจว่าจะมีค่าเก็บอยู่แน่ๆแล้ว มันก็เลยยอมให้เราเรียกใช้ Method uppercaseString ได้

วิธีการใช้ Force Unwrapping ก็เพียงแค่เติมเครื่องหมายตกใจ “ ! ” ต่อท้ายชื่อตัวแปร ครับ ดังนี้



 จากภาพ เรามั่นใจว่า ถึง str จะประกาศเป็น Optional แต่ไม่ได้เก็บค่า nil แน่นอน เพราะเรากำหนดค่า String ไว้แล้ว จึงสามารถบังคับให้ใช้ method uppercaseString ได้ (ปกติ Optional เรียกใช้ method นี้ไม่ได้)


Implicitly Unwrapped Optional

ทวนเรื่องเก่าสักนิดนะครับ 
Optional เป็นการอนุญาติให้ตัวแปรที่เราสร้างสามารถเป็น nil ได้ ซึ่งก่อนใช้งานตัวแปร เราสามารถใช้ if ตรวจสอบว่ามีค่าว่างก่อนใช่งาน หรือถ้าเรามั่นใจว่าไม่เป็นค่า nil แน่ๆ เราก็ใช้ Forced unwrapping (“!”) ได้เลย

แต่ในบางครั้ง เรามั่นใจเสมอว่า Optional ที่เราสร้างขึ้น หลังจากที่เราได้ค่าออกมาใช้งานในครั้งแรกแล้ว ตัวแปรนี้จะไม่เป็นค่า nil อีกต่อไป เราก็สามารถกำหนดได้ว่า ตัวแปรนี้ จะไม่มีวันเป็นค่า nil ตลอดไป ซึ่งจะเป็น optional ที่มีค่าเก็บอยู่ 100% โดยปกติเราจะใช้เครื่องหมาย ! ตอนเรียกใช้งานตัวแปรทุกครั้ง ซึ่งบางทีมันก็เสียเวลาใช่ไหมครับ ทั้งที่เรามั่นใจว่า ไม่ใช่ค่า nil แน่ๆ แต่ต้องมาใส่ “!” ทุกครั้งเลย   เพราะเหตุนี้จะมีวิธีให้เรายกเลิกการใช้เครื่องหมาย ! ทั้งหมดได้โดยง่าย ซึ่งจะถูกเรียกว่า Implicitly Unwrapped Optional
โดยที่ตอนที่สร้าง optional เราจะไม่ใช้เครื่องหมาย ? เพื่อสร้าง optional แต่เราจะใช้ ! ตั้งแต่ตอนสร้างเลย ยกตัวอย่างเช่น



เพื่อให้เห็นตัวอย่างชัดเจน มาดูเปรียบเทียบแบบใช้ Implicitly Unwrapped Optional กับแบบไม่ได้ใช้กันดีกว่า ดังนี้





สำหรับบทความนี้ จบเพียงเท่านี้นะครับ ขอให้ผู้อ่านพยายามอ่านเรื่องนี้ให้เข้าใจ เพราะจะต้องเจอต้องใช้มันบ่อยมาก ซึ่งตอนผมเห็นพวกนี้ครั้งแรก ผมก็งงเป็นไก่ตาแตกเหมือนกันครับ Xcode มันบอกให้ผมเติมเครื่องหมายพวกนี้ ผมก็เติมตามที่มันบอก โดยไม่รู้ว่ามันคืออะไร 555+ ไว้เจอกันใหม่ในบทต่อไป เรื่อง Array นะครับ ^_^



วันอังคารที่ 17 มีนาคม พ.ศ. 2558

หัดเขียน Swift ตอนที่ 3 - Control Flow


สวัสดีครับเพื่อนๆ บทความที่แล้ว ผมได้เขียนเกี่ยวกับ Numeric type และ Conversion ไปแล้ว
และในวันนี้เอง ผมจะเขียนสรุปเรื่อง Control Flow หรือ Loop , If และ Switch case !! มาเริ่มกันเลยครับ

1) Loop For อย่างง่ายนั้น เขียนง่ายมากครับ ใช้ ... แทน "i++" และเงื่อนไข  ตัวอย่างเช่น


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

2) หากต้องการแสดงCharacter แต่ละตัว ใน String โดยใช้ Loop  ก็สามารถเขียนได้ง่ายมาก ดังนี้


3) While Loop ก็เขียนง่ายๆ คล้ายๆแบบเดิม ดังนี้


4) If หรือเงื่อนไข ก็ไม่ต่างจากแบบเดิมเท่าไหร่ครับ ตามนี้
จากตัวอย่างเป็นการวน Loop โดยตั้งเงื่อนไขให้การวนรอบสุดท้ายนั้น แสดง String ออกมาในรูปแบบตัวพิมพ์ใหญ่ทั้งหมด (Upper case)


5) Switch Statement ก็เช่นเดียวกัน รูปแบบคล้ายกับภาษาเดิมครับ (ต้องมี default ด้วยนะครับ ไม่งั้น Error)




และหากต้องการกำหนดเงื่อนไขหลายเงื่อนไขใน case เดียว ก็สามารถทำได้ง่ายๆ ดังนี้

เท่านี้ยังไม่พอ หากจะกำหนดเงื่อนไขเป็นช่วงของตัวเลขก็ได้ !!  ดังนี้




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

Good Bye

หัดเขียน Swift ตอนที่ 2 - Numeric type , Conversion


      สวัสดีครับเพื่อนๆ วันนี้ผมจะสรุปเรื่อง Numeric type และ Conversion นะครับ มาเริ่มกันเลย!!

1) Range ของ Interger type  มีขนาด 8 Bit (Signed Interger) และ  16 Bit (Unsigned Integer) ซึ่งส่วนใหญ่ ที่เราคุ้นเคยคือ Int มักจะมีขนาด 4 bit ในภาษาอื่นๆใช่ไหมครับ :) แต่ภาษา swift ไม่ใช่ 4 นะครับ ^_^

 2) สามารถแทรก เครื่องหมาย Underscore ( '_' ) เข้าไปในตัวเลขแบบนี้ได้ด้วย !!!!! เพื่อช่วยโปรแกรมเมอร์อย่างเราให้อ่านเลขได้ง่ายขึ้น และป้องกันการผิดพลาดในการอ่านหรือพิมพ์เลขด้วยครับ เจ๋งไปเลย :3


3) สามารถหาเรียกดูค่าสูงสุดของแต่ละชนิดตัวแปรนั้นๆ ได้ง่ายๆ ตัวอย่าง เช่น


ในบรรทัดที่ 2 จะเห็นว่า หากมีการกำหนดค่าที่มีขนาดเกินกว่าที่ชนิดตัวแปรนั้นๆจะเก็บได้ ก็จะเกิดการ overflow ขึ้น

4) ตัวแปร ชนิด Booleans ก็ไม่ต่างจากภาษาเดิมครับ คือ เก็บค่า true หรือ false


5) อันนี้อาจจะยังไม่เคยเห็นกันนะครับ นั่นก็คือ Tuple ซึ่ง Tuple คือชนิดตัวแปรอย่างนึง ที่เป็น grouping of multiple values into a single type หรือ กลุ่มของค่าหลายๆค่า ที่เก็บอยู่ในตัวแปรตัวเดียว (มันไม่ใช่ Class และ Structs นะ) ผมมองว่าเหมือน Tuple ใน Table ของฐานข้อมูลมากกว่า ซึ่งแต่ละแถวในtable ก็สามารถมีค่าได้หลายค่า


บรรทัดแรก คือการสร้างตัวแปรที่มี type เป็น tuple ครับ โดยเก็บค่า2ชนิด ที่เป็น int และ string 
บรรทัดที่ 2-3 เป็นการแสดงค่าของตัวแปร address ที่ประกาศเป็นชนิด tuple ซึ่งเราสามารถบ่งบอก index ที่ต้องการให้แสดงได้
บรรทัดที่ 4 เป็นการกำหนดค่าให้ใหม่สำหรับค่าในตำแหน่งแรก  หากไม่อยากให้เปลี่ยนแปลงค่าได้ ก็ให้กำหนดบรรทัดแรกใหม่ เป็น let หรือค่าคงที่ แทน var  นั่นเองครับ :)


หรือเพื่อนๆอยากจะประกาศตัวแปร tuple โดยวิธีอื่น ก็ทำได้หลายวิธี 

เช่น หากต้องการสร้างตัวแปร tuple โดย เก็บค่า 2 ค่า เป็นชนิด Double และ String ตามลำดับ ก็สามารถทำได้ ดังนี้ครับ



นอกจากนี้ หากต้องการกำหนดค่าให้ตัวแปรหลายๆตัว มีค่าเท่ากับ ค่าในแต่ละใน indexของtuple ก็สามารถเขียนแบบสั้นๆ ได้ ดังนี้ (ง่าย และยืดหยุ่น จนผมจำไม่ได้ละครับ)


จากภาพ เป็นการกำนหนดให้ตัวแปร house มีค่าเท่ากับ address4 ใน index แรก และกำหนดให้ตัวแปร street มีค่าเท่ากับ address4 ใน index ที่สอง ตามลำดับ



แค่นี้ยังไม่พอ!!!!!!  หากต้องการจะกำหนด index ให้เป็นข้อความ แทนที่จะเป็นตัวเลข ก็สามารถทำได้เช่นกัน  (โอ้ย โหดเกินไปแล้ว)  ดังนี้




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

  สรุปว่า วันนี้พระเอกของเราคือ Tuple นะฮะ :3







วันพุธที่ 11 กุมภาพันธ์ พ.ศ. 2558

หัดเขียน Swift ตอนที่ 1 - Variables, Constants, String



          สวัสดีครับ ในบทความนี้ก็จะเป็นบทความถัดจาก บทความที่แล้ว ที่ได้มีการแนะนำเพื่อนๆให้รู้จักกับภาษา Swift และไฟล์สำหรับฝึกทดลองเล่นคำสั่งภาษา Swift อย่าง Playground ไปแล้ว ในบทความนี้ผมแนะนำเรื่องของ Variables , Constants และ String ในภาษา Swift กันครับ โดยใช้เจ้าตัว Playground นี่แหละครับ มาเริ่มกันเลยดีกว่า เพื่อจะได้ไม่เสียเวลาเน้อะ

        ผมเชื่อว่าคนส่วนใหญ่ที่กำลังศึกษาภาษา Swift เพื่อเขียนโปรแกรมสำหรับ iOS หรือ Mac OSX ก็ตาม น่าจะมีพื้นฐานทางโปรแกรมกันมาอยู่แล้ว ดังนั้นผมจะไม่ขอแนะนำพื้นฐานทางโปรแกรมมิ่งทั่วๆไปอย่างเช่น ตัวแปรคืออะไร ชนิดตัวแปรคืออะไร ลูปคืออะไรนะครับ และจะพูดในแง่ของการใช้งาน จะไม่ขอเจาะลึกถึงเบื้องหลังการทำงานในเชิงลึก  ดังนั้นรูปแบบของผมจะเป็น การแสดง Code ตัวอย่างก่อน จากนั้นจะอธิบาย Code ส่วนที่สำคัญที่เกี่ยวกับภาษา Swift ครับ  ป่ะ เริ่ม!!!

1) เข้า Playgroud แล้วทดลองพิมพ์คำสั่งตาม ดังนี้


จะเห็นได้ว่า

- การประกาศตัวแปรนั้น เปลี่ยนไปนิดหน่อย โดยมีรูปแบบดังนี้

                   var [ชื่อตัวแปร]: [ชนิดของตัวแปร] = [value]

- สามารถ assign ค่าให้กับ ตัวแปร greeting ใหม่ได้ 

- การแสดงค่าของตัวแปรออกมา (Debug) จะใช้ฟังก์ชั่น println( )   
  ( มันก็คือ NSLog( ) ในภาษา  Objective-C  นั่นเอง )



2) ลองเอา ชนิดของตัวแปรออก และกำหนดค่าให้ greeting ใหม่ เป็นเลขจำนวนเต็ม ดังนี้


จะเห็นได้ว่า

- เราไม่จำเป็นต้องประกาศชนิดของตัวแปร ก็ได้ แต่ต้องมีการกำหนดค่าเริ่มต้นให้ ซึ่งตัว compiler จะทราบชนิดตัวแปรและกำหนดให้อัตโนมัติ โดยอาศัยดูจาก ค่าเริ่มต้นที่กำหนดให้ (initial assignment) จากตัวอย่างคำสั่งนี้ greeting จะมี type เป็น String เพราะ Hello อยู่ภายใต้เครื่องหมาย Double quotes ซึ่งหมายถึง Value ที่เป็นชนิด String นั่นเอง

- พบ Error ที่ คำสั่ง greeting = 2558 เนื่องจาก greeting เป็นตัวแปรชนิด String แต่เราไปกำหนดค่าใหม่ ที่เป็น Interger ดังนั้นในเรื่องนี้ มันจะไม่ยืดหยุ่นเหมือนในภาษา PHP ครับ


3) กำหนดค่าให้กับตัวแปร greeting ใหม่ ตามนี้เลย 



- ดูจาก Code และผลลัพธ์ แล้ว คงพอเดากันได้ ว่ามันคือการ "ต่อสตริง" นั่นเอง โอ้วว พระเจ้าจอร์จ การต่อสตริง ง่ายเหมือนกับในภาษา Javascript และ PHP เลยครับ ใช้แค่เครื่องหมาย + ในการเชื่อมต่อเท่านั้นเอง  หากคนที่เคยใช้ Objective-C มาก่อน คงจะดีใจน้ำตาไหลแน่ๆ เพราะของเดิมนั้น "โคตรยาว"


4) ลองเปลี่ยนการประกาศตัวแปร โดยใช้ var นำหน้า เป็น let แทน ดังนี้


- การใช้ let นำหน้าตัวแปร ขณะประกาศตัวแปร หมายถึง การกำหนดชนิดตัวแปรให้เป็น ค่าคงที่ หรือ Constant นั่นเอง  ดังนั้น เราจึงไม่สามารถไปเปลี่ยนแปลงค่าให้กับตัวแปร greeting ได้นั่นเอง จึงเกิด Error ขึ้นมาทันทีครับ

หมายเหตุ : พยายามกำหนดตัวแปรให้เป็น ค่าคงที่ เท่าที่จะเป็นไปได้ เพื่อจะได้ทำให้โปรแกรมของเรานั้นแข็งแกร่งยิ่งกว่าชัชชาติเสียอีก

5) ลองแก้โค้ดเป็นแบบนี้ดูครับ


จะเห็นได้ว่า

- String type มี API Method ให้เรียกใช้ด้วย อย่างเช่น capitalizedString และ append เพราะ String type ในภาษา Swift ก็เหมือนกับ NSString ใน Objective-C นั่นเอง หากคนที่เคยใช้Objective-C หรือพวกJava มาก่อน จะคุ้นเคยกับพวก method ต่างๆ เหล่านี้  เพราะ String ในภาษา Swift ไม่ใช่ Primative Data type เหมือนพวก int , float หรือ double  แต่เป็น Object type



ในบทความหน้า เราจะลุยกันต่อ ในเรื่องของ Numeric type และ Conversion  สวัสดีครับ :3


หัดเขียน Swift ตอนที่ 0 - แนะนำให้รู้จัก ภาษา "Swift" [ฉบับย่อ]




 
(ภาพจาก หนังสือ Swift by Tutorials A Hands-on Approach by Ray Wenderlich)


          ครั้งนี้เป็นครั้งแรกที่ผมเขียนบทความเกี่ยวกับภาษา Swift ซึ่งก่อนอื่นผมต้องบอกก่อนเลยว่า ผมไม่ได้มีความเชี่ยวชาญเกี่ยวกับภาษา Swift เลย เนื่องจากภาษา Swift นั้น เพิ่งได้มีการแนะนำอย่างเป็นทางการในงาน WWDC 2014 ที่ Apple ได้จัดขึ้นครับ ดังนั้น สิ่งที่ผมจะเขียนต่อไปนี้จึงเป็นสิ่งที่ผมเพิ่งศึกษามาทั้งสิ้นครับ ดังนั้น เราจะเรียนรู้ไปพร้อมๆกัน อาจจะมีถูกบ้างผิดบ้าง ต้องขออภัยไว้ ณ ที่นี้ด้วยครับ

          ในงาน WWDC 2014 บริษัท Apple ได้มีการแนะนำ New Swift Language  ซึ่งตัวภาษา Swift นั้น ก็จะมี Syntax ที่สั้นกระชับมากกว่าภาษา Objective-C อยู่มาก นอกจากนี้ยังมีฟีเจอร์ใหม่ๆ สำหรับ นักพัฒนาตัว Mac และ iOS อีกด้วยครับ

          ก่อนที่จะมาเริ่มเรียนรู้เกี่ยวกับ Basic element ของภาษานั้น  Appleได้มีการแนะนำประเภทของไฟล์ชนิดใหม่ที่เรียกกันว่า playground ครับ ซึ่งจะเป็นไฟล์เดี่ยวๆไฟล์เดียว(Single Swift File) ซึ่งจะไม่เหมือนพวกกลุ่มไฟล์ตอนสร้างProjectใหม่ ที่จะมีหลายไฟล์ครับ

         Playground แปลว่า "สนามเด็กเล่น" พอเดาได้ใช่ไหมครับ ว่ามันมีไว้ทำอะไร มันมีไว้ให้เราฝึกหัด เขียน หรือทดลองพิมพ์คำสั่งภาษา Swift เล่นนั่นเอง ซึ่งจะแสดงผลลัพธ์แบบ Real-time ที่ด้านข้างของทุกๆคำสั่งเลยทีเดียว ถ้ายังมองไม่เห็นภาพ สามารถดูตัวอย่างดังภาพด้านล่างได้เลยครับ

         ไฟล์ชนิด Playground นั้นเพื่อนๆสามารถสร้างได้ง่ายๆ โดยเลือกเมนู File จากนั้นเลือก New Playground จากนั้นเลือก iOS Plaform จากนั้นก็เลือก Save เป็นอันเสร็จเรียบร้อยครับ ^_^

       ในบทความหน้า ผมจะเริ่ม Basic ภาษา swift กันแล้วนะครับ โดยใช้เจ้าตัว Playground ในการทดลองคำสั่งครับ ไว้เจอกันใหม่ในบทความต่อไปครับ


ลิ้งสำหรับบทความถัดไป

หัดเขียน Swift ตอนที่ 1

http://tapepii-app.blogspot.com/2015/02/swift-1.html