Backup source code แบบย้อน version ได้ style programmer

Backup source code แบบย้อน version ได้ style programmer

เนื้อหาคราวนี้ จะมาแนะนำเครื่องมือ ที่ต้องบอกว่า programmer ที่เป็นมืออาชีพจะมีใช้กันทุกคน เพราะว่ามันจะช่วยชีวิตได้ในคราวคับขันเสมอๆ หรือ มันเป็นผู้ช่วยอีกคน ที่ช่วยในการทำ project ของเราได้เลยทีเดียว ทั้งนี้ เครื่องมือนี้ ไม่จำกัดเฉพาะคนที่เป็น programmer เท่านั้น จริงๆ ใครก็ใช้ได้คนทำงาน office ก็ใช้ได้ และจะได้ประโยชน์มากด้วย เพราะน่าจะเคยเจอเหตุการณ์แบบนี้ คือ update ไฟล์ word หรือ powerpoint แล้ว save เป็นชื่อว่า ใหม่ จากนั้นแก้ต่อ save อีก ตั้งชื่อ ใหม่กว่า จากนั้น แก้ต่อ save อีก ตั้งชื่อ ใหม่ล่าสุด จากนั้น แก้ต่อ save อีกตั้งชื่อ ใหม่ล่าสุด 2 อะไรแบบนี้ ตอนที่เรายังทำงานอยู่ตรงนั้นก็จำได้ ว่าอันไหนคือล่าสุด แต่หากทิ้งเอาไว้ 1 ปีแล้วมาดูอีกที จะยังจำได้หรือเปล่า? แล้วถ้าคนอื่นมาดูจะรู้ได้อย่างไรว่า ใหม่กว่า กับใหม่ล่าสุด 2 อันไหนใหม่กว่ากัน? พากันงงไปหมด แม้กระทั่งตัวเองยังงง

เทคนิค หรือเครื่องมือที่จะแนะนำวันนี้ ต้องบอกว่า ไม่ใช่เรื่องใหม่ แต่เป็นเรื่องเก่าที่มีใช้กันมานานมาก เค้าจะเรียกมันว่า version control ชื่อก็บอกอยู่แล้ว ว่าเป็นตัวจัดการ version ความสามารถของมันน่ะเหรอ เกริ่นให้สั้นๆก็คือ เราสามารถ save ไฟล์แยก version ได้ โดยไฟล์มีแค่ไฟล์เดียวเท่านั้น ตั้งแต่เริ่มสร้าง จนถึง version ปัจจุบัน เราสามารถแก้ไฟล์ไป 100 รอบ และทำไว้ 100 version โดยมีแค่ไฟล์เดียวชื่อเดิมตลอดเลย และยังสามารถเปลี่ยนกลับไปเป็น version ไหนก็ได้ หรือเลือกเอา version ไหนออกมาใช้ก็ได้ เจ๋งมั้ยล่ะ เท่านั้นยังไม่พอ เพราะว่าแต่ละ version เรายังมี comment เอาไว้จากตัวเราเองเพื่อกันการลืมด้วย ว่า version นี้แก้ตรงไหน แก้อะไรไปบ้าง และที่เจ๋งกว่านั้น สำหรับคนที่เอาไปใช้งานกับ source code ก็คือ มันสามารถระบุได้เลย ว่าไฟล์นี้ถูกแก้จุดไหน จากอะไรเป็นอะไร หรือบรรทัดไหนถูกลบ บรรทัดไหนถูกเพิ่ม ทั้งหมดนี้ ฟรีทุกอย่าง แบบไม่ต้องละเมิดลิขสิทธ์เลย

การทำงานของ version control

เนื่องจากปัจจุบัน version control เอง ก็มีหลายยี่ห้อ ซึ่งแต่ละยี่ห้อ ก็มีการทำงานเบื้องหลัง ที่แตกต่างกันไป แต่จะพูดโดยรวมๆ เพื่อให้พอเข้าใจภาพกว้างๆแล้วกันครับ 

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

เจ้า repository จะเป็นเหมือน กล่องสมบัติที่มีพนักงานคอยจดบันทึกความเปลี่ยนแปลงในทุกๆอย่างที่เราได้ทำ และประทับตราออกมาเป็น version ต่างๆ ให้เรารับทราบ โดยคนที่คอยประทับตราก่อนเก็บเข้ากล่องนั้น จะทำงานก็ต่อเมื่อเราสั่งให้มันทำเท่านั้น (commit) ถ้าเราไม่สั่ง (เขียนไฟล์แล้ว save อย่างเดียว แต่ไม่มีการสั่ง commit) พนักงานก็จะไม่ประทับตราออกมาเป็น version ให้เรา ดังนั้น หากจุดไหน ที่เราคิดว่า เราพอใจแล้ว และเหมาะแก่การประทับตราเป็น version เพื่อใช้ในการย้อน version กลับมาจุดนั้นอีกครั้งได้ เราก็แค่สั่ง commit ไปเท่านั้น ระบบก็จะเอาความเปลี่ยนแปลงนั้นเก็บเข้าใส่กล่องไป ซึ่งผลที่ได้จากการ commit ก็คือ เราสามารถย้อนไปยังจุดที่ commit แต่ละครั้งได้ หากเคยเล่นเกมส ก็เหมือนการ save เกมส์หลายๆ slot แล้วเรียกย้อนหลังจากจุดนั้นขึ้นมาเล่นต่อได้นั่นล่ะครับ

จริงๆ concept ก็มีเพียงเท่านี้ แต่ว่าปัจจุบัน ได้มีการขยายความสามารถของ version control ด้วยการสร้างระบบ server ขึ้นมาเเพื่อทำหน้าที่เป็น ถังกลาง ที่เอางานแต่ละคนที่ทำ ขึ้นไปเก็บข้างบน แล้วให้เรา หรือ ใครก็ได้ โหลดออกมาได้ ซึ่งเปรียบได้คล้ายกับ การที่เราสร้างเว็บในเครื่องเสร็จแล้วก็เอาขึ้นไปเก็บบน server ซึ่งเราสามารถโหลดลงมาทำต่อ หรือคนอื่นโหลดไปทำต่อก็ได้เหมือนกัน (จริงๆขึ้นอยู่กับสิทธ์ของงานแต่ละคน ว่าตั้งให้ทุกคนโหลดได้ หรือ เฉพาะบางคนเท่านั้น)

โดยการที่เราเอางานเราขึ้นไปเก็บ server กลางนี้ เค้าจะเรียกว่าการ push ขึ้นไป ส่วนการเอาลงมาก็เรียกว่า pull หรือ clone (มีความต่างกันนิดหน่อย) แต่เราเป็นว่าคร่าวๆก็ประมาณนี้ก็ครบถ้วนแล้ว ที่เหลือจะเป็นรายละเอียดปลีกย่อยครับ

เริ่มต้นใช้ version control

สำหรับคนที่ทำงานคนเดียว และต้องการความเร็วสูง แนะนำให้เลือกใช้งาน git ครับ (ปัจจุบัน version control มีเยอะ เช่น git, svn, hg เป็นต้น) เมื่อก่อน ผมก็ใช้ svn ปัจจุบันใช้ git เพราะว่า git มีการทำงาน เบื้องหน้าและเบื้องหลังทำงานได้เร็ว และใช้ปริมาณการเก็บข้อมูลที่เล็กกว่า svn มาก ก็เลยใช้ตัวนี้มาเรื่อยๆ อีกทั้งเครื่องมือที่มีให้ใช้ก็ถือว่าใช้งานง่าย เข้าใจได้ไม่ยากเลยครับ ทุกวันนี้ ประทับใจอยู่ครับ

สำหรับมือใหม่มากๆ ผมแนะนำให้ใช้ software การจัดการ git ที่ชื่อว่า SmartGit นะครับ เพราะว่าเอามาใช้งานได้ฟรีครับ ผมข้ามเรื่องขั้นตอนการ download เลยนะครับ

การติดตั้ง SmartGit

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

เค้าจะถามเราว่าให้เราติดตั้งแบบไหน เราก็เลือกแบบ non-commercial ครับ แต่ว่าเป็นเพื่อการใช้งานส่วนตัวนะครับ ถึงจะใช้ฟรีครับ

ติดตั้งแบบ non-commercial

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


เลือกแบบให้มันทำตัวเหมือน SSH client จะได้ไม่ต้อง config อะไรกันมากครับ

ให้ทำตัวเสมือน SSH client

จากนั้นก็เป็นหน้าจอให้เรากรอก username, email ตรงนี้ ก็กรอกไปเพื่อแสดงความเป็นตัวตนของ source code และการ commit ต่างๆ ไม่ต้องสมัครอะไรมาก่อนครับ

กรอกข้อมูลส่วนตัวของเรา

เสร็จแล้วจะเป็นหน้าจอให้เราเลือกว่า เรามี server กลางสำหรับการเก็บ repo ของเราที่ไหนหรือเปล่า สำหรับมือใหม่แน่นอนว่ายังไม่มีครับ

การเชื่อมต่อกับ git hosting provider

แค่นี้ จบกระบวนการติดตั้งแล้วนะครับ

การสร้างพื้นที่สำหรับเก็บไฟล์ ที่ต้องการเก็บ version

พื้นที่สำหรับเก็บไฟล์ที่ต้องการควบคุม version เค้าจะเรียกว่า repository หรือสั้นๆว่า repo การสร้าง repo ขั้นตอนจะมีประมาณนี้ครับ

  1. สร้าง folder เปล่าๆ
  2. ใช้ SmartGit สร้าง Project ใหม่ โดยชี้พื้นที่เก็บไปยัง folder ที่สร้าง
  3. เริ่มใช้งานได้ทันที

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

จากโปรแกรม SmartGit ให้เราสร้าง windows ใหม่ หรือกด ctrl+N

จากนั้นเลือก Open an existing local or create a new repository เพราะเรากำลังจะสร้างใหม่ (แต่ถ้ามันขึ้น pop up ให้เลือกว่าจะ open หรือ new repository ก็ข้ามขั้นตอนนี้ไปเลยนะครับ)

สร้าง repo ใหม่ Project และ new windows

ระบบจะให้เรา browse ไฟล์ ไปยัง folder ที่เราสร้างรอเอาไว้ก่อนแล้ว โดยปกติ ผมใช้สร้าง folder เอาไว้ใน folder เดียวกับที่ใช้เขียนเว็บเลย จะได้ไม่ต้องย้ายไฟล์ไปมา เวลาทดสอบการแสดงผลหน้าเว็บครับ (และไม่แนะนำให้แยกคนละพื้นที่ด้วย) อย่างของผม ก็เลือก T:\xampp\htdocs\test_git  (ผมสร้าง folder test_git เอาไว้ใน T:\xampp\htdocs\ เพราะ T:\xampp\htdocs เป็นพื้นที่สำหรับทำงานเว็บของผม)

เลือกว่า open an existing local or create a new repository

จากนั้นระบบจะถามว่า เราจะใช้ version control อะไร ก็ให้เราเลือก git ไปครับ

เลือกให้ทำงานแบบ git

ระบบจะให้เราตั้งชื่อ project เราก็ตั้งเพื่อให้ตัวเราเข้าใจเองครับ เป็นอันเสร็จ เท่านี้ ไฟล์อะไรก็ตามที่อยู่ในแฟ้มนี้ ก็จะสามารถ track version ได้แล้วครับ

การกำหนด version ให้กับไฟล์

แนะนำให้ลองสร้างไฟล์ .txt ขึ้นมาสักไฟล์หนึ่ง แล้วใส่ข้อความเพื่อบ่งบอกว่า นี้เป็น version ที่ 1อะไรก็ได้ครับ แล้ว save ใส่ใน folder นี้ให้เรียบร้อย

จากนั้น ให้เราเปิดโปรแกรม SmartGit จะเห็นว่ามีไฟล์ปรากฏขึ้นมา ก็ให้เรากดเลือก และกดปุ่ม commit แล้วพิมพ์ในช่อง commit message ว่า การ commit ครั้งนี้ มีการเปลี่ยนแปลง ปรับปรุง แก้ไขอะไรไปบ้าง จะมีโปรโยชน์มาก ในการฟื้นความทรงจำเมื่อวันและเวลาผ่านไป ว่าเราได้ทำอะไรกับไฟล์นี้ไปแล้วบ้าง แล้วกด commit

การ commit ไฟล์ บันทึกความเปลี่ยนแปลง ไปในจุดที่เราต้องการ

เมื่อ commit เสร็จ เราจะเห็นว่ามีไฟล์ปรากฏใน outgoing ที่ด้านล่างพร้อมคำอธิบายของเรา เรียบร้อย

commit สำเร็จแล้ว

จากนั้น ให้ทำแบบเดิมนะครับ แก้ไขไฟล์ เป็น version 2 แล้วทำการ commit เราก็จะสังเกตุได้ว่า หลังจากที่ commit แล้ว ไฟล์จะหายไปจากโปรแกรม SmartGit นั่นหมายความว่า ไฟล์ใน folder นี้ไม่มีความเปลี่ยนแปลงใดๆครับ

ดูความเปลี่ยนแปลงย้อนหลัง

เมื่อเราทำไปเรื่อยๆหลาย version แล้ว เราต้องการดูย้อนหลังไปในแต่ละ version ทำได้ง่ายๆโดย กดปุ่ม Log ที่มุมขวาบนครับ

ดู logs ความเปลี่ยนแปลง

โปรแกรมจะแสดง list การ commit แต่ละครั้งขึ้นมาให้เราดู และเราก็จะเห็นว่า การเปลี่ยนแปลงนั้น เปลี่ยนแปลงอะไรไปบ้าง จากเดิมคือ อะไร ของใหม่คืออะไร ซึ่งจะมีประโยชน์มากๆ เวลาที่เราเขียนโปรแกรมไปนานๆแล้วเราไปลบ function บางตัวออกไป ก็ไม่ต้องเขียนใหม่ มาเอาจากตรงนี้แหล่ะ ไปแปะใหม่ได้เลย ง่ายๆ

compare file ระหว่าง version

ย้อน version ไฟล์

เวลาเราทำไปนานๆ แล้วปรากฏว่าเรามาผิดทาง เราอยากย้อนกลับไปยังจุดหนึ่ง ที่เราเคย commit เอาไว้ ทำได้ไม่ยากครับ และมีหลายวิธีขึ้นอย่กับผลลัพท์ที่เราอยากได้ ถ้าเราแค่อยากได้โค้ดบ้างส่วนออกมาจาก version เก่า เราก็แค่กดปุ่ม Log ขวาบน เหมือนเราเข้าไปดูความเปลี่ยนแปลงย้อนหลังไปนั่นล่ะครับแล้วเลือกเอา ว่าเราอยากได้ version ไหนแล้ว copy บางส่วนออกมาแปะของใหม่

แต่ถ้าเป็นการย้อน version ไปเลยเหมือนเปิดประตูทะลุมิติกลับไปเป็นของหลาย version ก่อน ก็ต้องพึงระวังว่า ตั้งแต่ version ที่เรากำลังจะย้อนไป ถึง version ที่เรากำลังทำงานนี้ ทุกอย่างจะหายไปหมดนะครับ เหมือนเราย้อนเวลาไป แล้วแก้ไขสิ่งที่จะเกิดขึ้น เพื่อจะเขียนประวัติศาสตร์ในแบบใหม่ ยังไงอย่างนั้นเลย แบบนี้จะทำได้โดย คลิกที่เมนูด้านบน Local >> Reset แล้วเลือก version ที่ต้องการถอยหลังไป แล้ว เลือก option ให้เป็นแบบ hard

การย้อน version ของ git

หลังจากที่เราผ่านขั้นตอนนี้แล้ว ไฟล์ หรืองานที่เราเคยทำ ก็จะย้อนไปเป็นเหมือนที่ version นั้นเคยบันทึกเอาไว้ทุกอย่างเลยครับ

วันนี้ ก็เอาไว้เท่านี้ก่อนครับ จะเห็นได้ว่า มันไม่ได้ยากอะไรเลย สำหรับการใช้งาน version control ช่วยเราได้มาก หรือเวลาที่เราต้องทำงานต่อจากจุดเดิม เราก็กดดูได้ว่า ครั้งที่แล้วเราทำอะไรเอาไว้จาก git commit message นั่นเอง ช่วยเตือนความจำได้เป็นอย่างดีครับ

จะต้อง commit เมื่อไร

อันนี้เป็นคำถามที่จะเจอบ่อยมาก ซึ่งคำตอบก็ดันไม่ชัดเจนตายตัวเสียด้วย เพราะว่าเค้าไม่มีข้อบังคับที่ชัดเจน ขึ้นอยู่กับอิสระของคนที่ทำงานเองครับ ซึ่งแต่ละแบบมันมีข้อดีข้อเสียต่างกัน หากว่าเรา commit วันละครั้ง เพื่อให้เป็นตัวบอกว่าวันนี้เราทำงานเสร็จถึงตรงนี้แล้ว แบบนี้จะเจอปัญหา เมื่อโปรแกรมโดยรวมเกิด bug เราจะไม่รู้เลยว่ามันเกิดมาจากส่วนไหน เพราะทั้งวันเราเขียนอะไรไปเยอะแยะมากมาย อีกทั้งการย้อน version ยังเป็นไปด้วยความยากลำบากอีกด้วย แต่ถ้าเรา commit กันถี่มาก เช่น ทุก line ก็ commit 1 ที แบบนี้ เราจะเสียเวลาในการ commit เยอะกว่าการเขียนโปรแกรมเสียอีก และเวลาเราจะย้อน version เราจะเสียเวลาคุ้ยอยู่นานมาก สุดท้ายก็แยกไม่ออกว่า จุดไหนเป็นจุดที่ควรย้อนไปหา เพราะว่ามันเยอะไปหมด

เทคนิคที่ดี ก็คือการแบ่งงานเป็นส่วนย่อยๆ ที่เราต้องทำให้เสร็จ เมื่อทำเสร็จ ทดสอบส่วนย่อยนั้นแล้ว ก็ commit ครับ เพื่อให้รู้ว่า โค้ด ณ การ commit นี้มันทำงานได้แล้วนะ หรือว่า ทุกครั้งที่มีการ change ใดๆ แก้ไข change นั้นเสร็จก็ commit รวมไปถึงการแก้ไข bug ก็ด้วยเช่นกัน เป็นในลักษณะเดียวกัน แต่ว่าบางคนบอกว่า ไองานส่วนย่อยเนี่ย มันใช้เวลาทำนาน 3 วัน นั่นแปลว่า 3 วัน commit ทีนึงเหรอ คำตอบคือ ไม่ใช่ครับ มันผิดที่คุณยังแบ่งงานออกมาได้ไม่ย่อยเพียงพอนั่นล่ะครับ งานส่วนเดียวที่ต้องทำ 3 วัน มันน่าจะต้องประกอบด้วยส่วนย่อยของมันอีกเป็นจำนวนมากอย่างแน่นอน

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

Create: Modify : 2013-12-14 12:26:01 Read : 3787 URL :