บางครั้งเมื่อฉันไปที่เว็บไซต์ไอที ฉันพบว่ามีหลายสิ่งที่แสวงหาความแปลกใหม่ ความแปลกใหม่ ความเชี่ยวชาญเฉพาะทาง และอคติ! เรียกได้ว่ามีทุกสิ่งในโลก! แต่เมื่อเผชิญกับสถานการณ์ปัจจุบันของซอฟต์แวร์จีน ในด้านหนึ่งเราพบว่ามีซอฟต์แวร์ที่ใช้งานได้จริงมากมายในกระบวนการรวบรวม และหลายคนกำลังทำงานล่วงเวลาและยังมีงานยุ่งมาก โปรแกรมที่ใช้งานได้จริงที่ไม่มีใครพัฒนาและรอคอย ในทางกลับกัน เรายังพบว่ามีโปรแกรมเมอร์ที่ไม่ได้ใช้งานจำนวนมากที่ไม่รู้ว่าต้องการพัฒนาอะไร! ฉันไม่รู้ว่าฉันต้องเชี่ยวชาญทักษะการเขียนโปรแกรมอะไร ดังนั้นฉันจึงใช้เวลาส่วนใหญ่ในการเรียนรู้สิ่งนี้และสิ่งนั้นทางออนไลน์ ซึ่งทำให้อกหัก โปรแกรมเมอร์จำนวนมากไม่ทราบว่าซอฟต์แวร์เชิงปฏิบัติที่ขาดหายไปมากที่สุดในปัจจุบันไม่ใช่สิ่งใหม่ แปลก เชี่ยวชาญ หรือลำเอียง แต่เป็นเทคโนโลยีเชิงปฏิบัติ รวมถึงคุณภาพและทักษะในการประยุกต์ใช้เทคโนโลยีเชิงปฏิบัติ
เนื่องจากการเขียนโปรแกรมคือ "ถนนทุกสายมุ่งสู่กรุงโรม" โปรแกรมเมอร์จึงมีอิสระอย่างมากและสามารถใช้วิธีการใดก็ได้เพื่อใช้งานฟังก์ชันต่างๆ ส่งผลให้ระดับการเขียนโปรแกรมไม่เท่ากัน ฉันคิดว่าโปรแกรมเมอร์ควรเชี่ยวชาญทักษะการเขียนโปรแกรมเชิงปฏิบัติเพื่อฝึกฝนทักษะเหล่านี้ พวกเขาจะต้องเชี่ยวชาญแก่นแท้ของทักษะเหล่านี้ โดยทำความเข้าใจแก่นแท้เหล่านี้อย่างถี่ถ้วนเท่านั้นจึงจะสามารถสรุปขอบเขตการใช้งานและจุดสนใจได้ และโปรแกรมเมอร์ที่รู้แค่วิธีเขียนโปรแกรมเท่านั้น แต่ไม่รู้ว่าทำไมจึงเขียนในลักษณะนี้ อาจไม่สามารถใช้งบที่ดีที่สุด งบที่ง่ายที่สุด และงบที่เหมาะสมที่สุดในการเขียนโปรแกรมได้ ไม่ต้องพูดถึงการใช้ทักษะที่สูงขึ้นมารวมงบเหล่านี้เพื่อให้ได้คุณภาพสูง โปรแกรม
ในการฝึกเขียนโปรแกรมระยะยาว ฉันเชื่อว่าทักษะการเขียนโปรแกรมต่อไปนี้เป็นพื้นฐานและจะต้องเรียนรู้ทักษะการเขียนโปรแกรมระดับสูงอื่นๆ
1. การมอบหมายงาน
การมอบหมายงานเป็นคำสั่งพื้นฐานที่ขาดไม่ได้ในการเขียนโปรแกรม และเป็นคำสั่งพื้นฐานที่สุด การเรียนรู้ข้อความนี้ดูเหมือนง่ายมาก แต่ยิ่งง่ายกว่า คุณก็ยิ่งต้องให้ความสนใจมากขึ้นเท่านั้น การมอบหมายที่ง่ายที่สุดคือการกำหนดค่าให้กับตัวแปร เช่น x=1
สาระสำคัญของการมอบหมายงานคือการถ่ายโอนระหว่างสิ่งต่างๆ ยิ่งไปกว่านั้น การมอบหมายงานนั้นเป็นกระบวนการระดับกลาง และความหมายที่สะท้อนในระดับโค้ดคือการกำหนดค่าหรือตัวชี้หน่วยความจำในหน่วยความจำให้กับตัวชี้หน่วยความจำ
การมอบหมายงานมีสองลักษณะ ด้านหนึ่งคือ: ค่าหรือตัวแปรหรือวัตถุใดที่ถูกนำมาใช้ และอีกด้านคือ: ตัวแปรหรือวัตถุใดถูกกำหนดให้กับ เมื่อโปรแกรมเมอร์กำลังเขียนโปรแกรม พวกเขามักจะสับสนในสองแง่มุม: ฉันได้รับค่า ตัวแปร และอ็อบเจ็กต์อะไร วิธีค้นหาค่า ตัวแปร และอ็อบเจ็กต์เหล่านี้ และฉันจะมอบหมายให้ใครหลังจากที่ได้รับมาแล้ว นี่คือสิ่งที่เรามักจะเจอ
เมื่อเรากำหนดค่าเราควรใส่ใจกับ:
1) ชนิดข้อมูลทั้งสองด้านของสมการจะต้องเท่ากัน
2) คำสั่งการมอบหมายจะเร็วกว่าคำสั่งอื่น สิ่งนี้ควรสังเกตเมื่อมุ่งเน้นไปที่ประสิทธิภาพ
คำสั่งการกำหนดจะเร็วกว่าการเรียกใช้ฟังก์ชันและเร็วกว่าคำสั่งแบบวนซ้ำ
ตัวอย่างเช่น: คำสั่ง loop ถูกเขียนเป็นวงใหญ่:
สำหรับ(i=0;i<3;i++)
ก[i]=ฉัน+1;
อาจเปลี่ยนเป็นคำสั่งการมอบหมายงานได้เช่นกัน:
อ[0]=1;
เอ[1]=2;
เอ[2]=3;
3) เมื่อมีคำสั่งการมอบหมายหลายรายการ การประมวลผลการมอบหมายอาจเป็นไปตามลำดับ
4) มีข้อความการมอบหมายงานมากเกินไป (มากกว่า 20 ข้อความซึ่งเข้มงวดมากในการอ่านและไม่มีเนื้อหาทางเทคนิค) อาจจำเป็นต้องพิจารณาการมอบหมายงานแบบวงกลม
2. การประมวลผลแบบมีเงื่อนไข
การประมวลผลแบบมีเงื่อนไขเป็นรองเพียงการประมวลผลที่ได้รับมอบหมายในเนื้อหาการเขียนโปรแกรม และโดยพื้นฐานแล้วการเปลี่ยนแปลงโปรแกรมมีสาเหตุจากการประมวลผลแบบมีเงื่อนไข การประมวลผลที่แตกต่างกันจะดำเนินการเมื่อตรงตามเงื่อนไขที่แตกต่างกัน ดังนั้นสาระสำคัญของการประมวลผลแบบมีเงื่อนไขก็คือการเปลี่ยนแปลงในสิ่งต่าง ๆ นำมาซึ่งการเปลี่ยนแปลงที่สอดคล้องกัน
ในการฝึกเขียนโปรแกรม เรามักจะสับสนเกี่ยวกับ: เงื่อนไขอะไร? จะทำอย่างไร? และพิจารณาด้วยว่าจะเริ่มพิจารณาเงื่อนไขเมื่อใด
การประมวลผลการมอบหมายเป็นการประมวลผลตามลำดับ เงื่อนไขจะเพิ่มความเป็นไปได้ในการประมวลผลการมอบหมายงาน เมื่อตรงตามเงื่อนไข การมอบหมาย A อาจถูกดำเนินการ เมื่อไม่ตรงตามเงื่อนไข การมอบหมาย B อาจถูกดำเนินการ
เมื่อประมวลผลเงื่อนไข เราต้องใส่ใจกับ:
1) เราจะเลือกเงื่อนไขของฉันได้อย่างไร? นั่นคือนิพจน์เงื่อนไขของเรา
ที่จริงแล้วปัญหานี้ซับซ้อนมาก
โดยทั่วไป เราจะถือว่าเงื่อนไขที่สำคัญที่สุดเป็นเงื่อนไขแรก อย่างไรก็ตาม เราจะพิจารณาเงื่อนไขของชุดผลลัพธ์ที่ใหญ่ที่สุดที่ตรงตามเงื่อนไขเป็นเงื่อนไขแรกด้วย เงื่อนไขสุดท้ายดังกล่าวมักไม่สามารถตอบสนองได้ หรือแม้ว่าจะตรงตามเงื่อนไขแล้ว ก็ไม่จำเป็นต้องดำเนินการมากนัก
จากการออกแบบนิพจน์แบบมีเงื่อนไข เราสามารถใช้ตัวแปรตัวเดียวเพื่อแสดงเงื่อนไข หรือการดำเนินการหลายตัวแปรเพื่อแสดงเงื่อนไขได้ ในหมู่พวกเขาก็มีความเฉพาะเจาะจงมากเช่นกัน
ตัวอย่างเช่น. ธง==1;ธง=='1';ธง==จริง
ทั้งสองอย่างสามารถอนุญาตให้ถ่ายโอนเงื่อนไขของโปรแกรมได้ แต่มีหลายปัจจัยที่ต้องพิจารณาในการเลือก
2) อย่าละทิ้งข้อยกเว้น
ตัวอย่างเช่น เมื่อเราพิจารณา i=1 และ i=2 เราจะไม่พิจารณา i<1 และ i>2
การละเว้นเงื่อนไขมักบ่งชี้ว่าโปรแกรมเมอร์ของเราขาดแนวคิดโดยรวมและแนวคิดเรื่องข้อยกเว้น นี่เป็นหนึ่งในสาเหตุที่หลาย ๆ โปรแกรมเขียนได้ไม่ดี
3) ไม่สามารถมีจุดตัดกันระหว่างเงื่อนไขได้
ตัวอย่างเช่น:
ถ้า(i>1 &&i<=5)
x=1;
ถ้า(i>4&&i<10)
x=2;
เมื่อ i=5
x เท่ากับ 1 ก่อนแล้วจึงเท่ากับ 2 สิ่งนี้จะต้องหลีกเลี่ยง ข้อผิดพลาดของโปรแกรมหลายอย่างเกี่ยวข้องกับปัญหาดังกล่าว
4) ให้ความสนใจเป็นพิเศษกับความครอบคลุมของการประมวลผลแบบมีเงื่อนไข
ตัวอย่างเช่น: if (flag==1)
เอ็กซ์=1;
ถ้า(ธง==2)
X=2;
เอ็กซ์=5;
ไม่ว่าเงื่อนไขจะเป็นเช่นไร x ก็เท่ากับ 5 เสมอ
5) ตระหนักถึงการปรับเปลี่ยน if และ case ตามลำดับ รู้ว่าเมื่อใดควรใช้เมื่อไรและเมื่อใดควรใช้ case.
3. วงจร
Loop เป็นนิพจน์ง่ายๆ ของการดำเนินการซ้ำๆ ตราบใดที่มีการดำเนินการซ้ำๆ ก็สามารถใช้คำสั่งวนซ้ำได้ สาระสำคัญของวัฏจักรคือการทำซ้ำ
เมื่อประมวลผลลูป เราต้องใส่ใจกับ:
1) การประมวลผลแบบวงกลมเป็นสิ่งสำคัญที่ส่งผลต่อประสิทธิภาพ
เมื่อมีปัญหาด้านประสิทธิภาพในโปรแกรม คุณต้องค้นหาปัญหาดังกล่าวในคำสั่งลูปก่อน
2) ข้อกำหนดเบื้องต้นสำหรับการประมวลผลแบบวนซ้ำ
โดยทั่วไปแล้ว คำสั่งแบบวนซ้ำสามารถใช้เพื่อดำเนินการซ้ำได้มากกว่าสามครั้ง หากน้อยกว่าสามครั้ง จะเป็นการดีที่สุดที่จะไม่ใช้คำสั่งวนซ้ำ
ตัวอย่างเช่น:
สำหรับ(i=0;i<3;i++)
ข[ฉัน]=ฉัน;
จะดีกว่าที่จะเขียน:
ข[0]=0;
ข[1]=1;
ข[2]=2;
แน่นอนว่าในแง่ของความสามารถในการอ่านและความสามารถในการปรับขนาด สามารถใช้คำสั่งลูปได้เช่นกัน
3) เงื่อนไขการวนซ้ำที่แตกต่างกันใช้คำสั่งการวนซ้ำที่แตกต่างกัน
โปรแกรมเมอร์จำเป็นต้องรู้ว่าเมื่อใดควรใช้ for เมื่อใดควรใช้ do while และเมื่อใดควรใช้ foreach
แม้ว่าข้อความข้างต้นสามารถบรรลุวัตถุประสงค์เดียวกันได้ แต่โปรแกรมเมอร์ยังคงจำเป็นต้องทราบขอบเขตการใช้งานของตนเพื่อให้สามารถเหมาะสมที่สุด
4) ใช้ประโยชน์จากคำสั่งในลูปอย่างเต็มที่ เช่น ลูปขัดจังหวะ, วนต่อ, การส่งคืนฟังก์ชัน, ออกจากโปรแกรม ฯลฯ เพื่อทำให้ลูปมีสีสันมากขึ้น
4. การดำเนินการสตริง
สตริงเป็นตัวแทนข้อมูลที่สำคัญ การจัดการสตริงเป็นหนึ่งในการดำเนินการที่ใช้บ่อยที่สุดในการเขียนโปรแกรม สาระสำคัญของการดำเนินการสตริงคือการประมวลผลข้อมูล เนื่องจากไม่มีมาตรฐานสำหรับข้อมูลมากนัก โปรแกรมเมอร์จึงจัดการข้อมูลให้สอดคล้องกับข้อกำหนดมาตรฐานของตนเอง
ตัวอย่างเช่น: บางสตริงมีข้อมูลที่หลากหลาย ดังนั้นสตริงจะต้องถูกแยกออก บางสตริงไม่มีข้อมูล จากนั้นจึงต้องรวมสตริงเข้าด้วยกัน
ให้ความสนใจกับประเด็นต่อไปนี้เป็นหลักเมื่อใช้งานสตริง:
1) การประมวลผลสตริงว่าง
เนื่องจากสตริงต้นฉบับจะมีช่องว่างหลายช่องที่จุดเริ่มต้นและจุดสิ้นสุดของสตริงเนื่องจากเหตุผลด้านการปฏิบัติงานและเหตุผลของระบบ ช่องว่างจึงต้องถูกลบออกก่อนที่จะประมวลผลสตริง
2) การประมวลผลโค้ดที่อ่านไม่ออก
มีอักขระที่อ่านไม่ออกหลายตัวในบางสตริง ทำให้อักขระที่เข้าใจยากปรากฏขึ้นในการแสดงสตริง สถานการณ์เหล่านี้มีสาเหตุหลักมาจากการมีอยู่ของรหัสอักขระควบคุมในสตริงและอักขระที่ไม่ตรงกันในอักขระภาษาจีน
3) การประมวลผลตัวคั่น
ตัวคั่นมักจะปรากฏในบันทึกหรือพารามิเตอร์เพื่อแยกข้อมูล และข้อมูลสามารถนำออกได้ผ่านตัวคั่น ในทางปฏิบัติ อาจเกิดขึ้นได้ว่าเนื้อหาข้อมูลนั้นมีตัวคั่น หรือมีการสร้างตัวคั่นระหว่างการสร้างโค้ดที่อ่านไม่ออก ในกรณีเหล่านี้ จำเป็นต้องเปลี่ยนตัวคั่นหรือต้องดำเนินการประมวลผลพิเศษ
4) การแปลงระหว่างอักขระและประเภทข้อมูลอื่น
ในการเขียนโปรแกรมจริง ความสอดคล้องของออบเจ็กต์ที่เราดำเนินการมักจะต้องมีการดำเนินการแปลงสตริงเป็นประเภทข้อมูลอื่น หรือแปลงประเภทข้อมูลอื่นเป็นสตริง โดยทั่วไป การแปลงชนิดข้อมูลอื่นเป็นสตริงทำได้ง่ายกว่า แต่เมื่อแปลงสตริงเป็นชนิดข้อมูลอื่น คุณต้องพิจารณาว่ารูปแบบสตริงก่อนการแปลงตรงตามข้อกำหนดหรือไม่
ตัวอย่างเช่น หากต้องการแปลง "1,000,000" เป็นค่าตัวเลข ให้ลบ "," ก่อนการแปลง
5) การประมวลผลสตริงย่อย
การประมวลผลสตริงย่อยมักใช้ในการสืบค้น การจับคู่สตริงย่อยมีสามประเภท: ด้านหน้า ตรงกลาง และสุดท้าย การจับคู่สตริงย่อยมักจะใช้เวลานานขึ้น เมื่อทำการสืบค้นในเขตข้อมูลที่จัดทำดัชนี เฉพาะรายการที่ตรงกันแรกเท่านั้นที่สามารถใช้ดัชนีเพื่อให้บรรลุวัตถุประสงค์ของการสืบค้นอย่างรวดเร็ว อย่างไรก็ตาม หากใช้การจับคู่ตรงกลางและภายหลัง ดัชนีจะไม่ถูกต้อง และแต่ละระเบียนจะต้องตรงกันทีละรายการ ซึ่งใช้เวลานานที่สุด โปรแกรมเมอร์จะต้องเข้าใจเนื้อหาข้างต้นและใช้ประโยชน์จากสถานการณ์เพื่อประมวลผลสตริงย่อยอย่างถูกต้องเพื่อให้บรรลุวัตถุประสงค์ในการสืบค้นที่รวดเร็ว
5. การดำเนินการทางคณิตศาสตร์
การดำเนินการทางคณิตศาสตร์เป็นอันดับสองรองจากการดำเนินการสตริงในการเขียนโปรแกรม ในจำนวนนี้การเพิ่ม 1 มีการดำเนินการหลายอย่างและมีการใช้กันอย่างแพร่หลาย การบวก การลบ การคูณ และการหาร มักใช้ในซอฟต์แวร์ประยุกต์ทั่วไป สาระสำคัญของการดำเนินการทางคณิตศาสตร์คือการประมวลผลข้อมูลตัวเลข การดำเนินการทางคณิตศาสตร์เป็นข้อกำหนดของอัลกอริทึมสำหรับการใช้งานจริงในด้านหนึ่ง และอัลกอริทึมการเขียนโปรแกรมในอีกด้านหนึ่ง
เช่น ระบบแอพพลิเคชั่นจำเป็นต้องคำนวณพื้นที่สี่เหลี่ยม จากนั้นคำสั่ง S=L*D จะถูกเขียน
หากคุณต้องการโปรแกรมและคำนวณพื้นที่สี่เหลี่ยม 100 รูป คุณต้องใช้พอยน์เตอร์ในการคำนวณพื้นที่ของสี่เหลี่ยมถัดไปผ่านพอยน์เตอร์ + 1 ตัวชี้จะเพิ่มขึ้น 1 การดำเนินการนี้จำเป็นโดยอัลกอริทึม
การดำเนินการทางคณิตศาสตร์ถูกใช้ในการใช้งานที่การคำนวณสูตรค่อนข้างง่าย อย่างไรก็ตาม เทคนิคและการดำเนินการทางคณิตศาสตร์ที่ใช้ในอัลกอริทึมนั้นไม่ง่ายนัก ประเด็นสำคัญที่ควรทราบคือ: กำหนดตัวแปรระดับกลางบางตัว และทำให้พวกมันกลายเป็นการดำเนินการวนซ้ำผ่านการบวกและการลบตัวแปรระดับกลาง
6. อาร์เรย์
อาร์เรย์คือคอลเลกชันที่เก็บข้อมูล การดำเนินการของอาร์เรย์มักพบในการเขียนโปรแกรม: สาระสำคัญของอาร์เรย์คือชุดของสิ่งต่างๆ อย่างไรก็ตาม ควรสังเกตว่าออบเจ็กต์คอลเลกชันมีจำนวนจำกัด และอาเรย์ของมันถูกเก็บไว้ในหน่วยความจำ ดังนั้นการดำเนินการอาเรย์จึงรวดเร็วมาก การใช้อาร์เรย์ส่วนใหญ่คือการใช้คำสั่งวนซ้ำ การรวมกันของอาร์เรย์และลูปช่วยปรับปรุงคุณภาพของโปรแกรมได้อย่างมาก
สำหรับอาร์เรย์เราควรคำนึงถึง:
1. ปัญหาที่เกี่ยวข้องกับจำนวนอาร์เรย์
2. วิธีการแทนและรูปแบบการจัดเก็บอาร์เรย์หลายมิติ
3. ปัญหาอาร์เรย์นอกขอบเขต
4. อาร์เรย์ว่าง
5. การใช้อาร์เรย์ในคำสั่งลูป
เอกสารแนบ: ฉันคิดว่าหัวข้อนี้สามารถแก้ไขได้ในบทความเดียว แต่ยิ่งฉันเขียนมากเท่าไหร่ก็ยิ่งมากขึ้นเท่านั้น ฉันไม่มีทางเลือกอื่นนอกจากทำให้ง่ายขึ้นแล้วทำให้มันง่ายขึ้น ดังนั้นเรามาเขียนเป็นบางส่วนกันดีกว่า
บทความถัดไป "ทักษะการเขียนโปรแกรมเชิงปฏิบัติที่โปรแกรมเมอร์ควรเชี่ยวชาญ 2"
เนื้อหาหลัก:
7. โทร
8. การทำงานของไฟล์
9. การดำเนินการเชิงตรรกะ
10. อาร์เรย์
11. ฐานข้อมูล
12. การควบคุม
13. ชั้นเรียน
14. การกำหนดพารามิเตอร์