อาร์เรย์ PHP ถูกใช้ทุกที่ การเพิ่มและการเปลี่ยนแปลงค่ามักจะตรงไปตรงมา

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

อาร์เรย์ PHP

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

มีชุดฟังก์ชันที่พัฒนาขึ้นสำหรับการทำงานกับอาร์เรย์และโครงสร้างวากยสัมพันธ์พิเศษ คุณสามารถสำรวจอาร์เรย์โดยใช้อัลกอริธึมของคุณเองและกำหนดฟังก์ชันการประมวลผลของคุณเองได้

ตัวอย่างการสร้างและใช้งานอาเรย์

ฟังก์ชั่น scPrint เป็นตัวช่วย โดยจะเขียนอาร์เรย์ซ้ำๆ ลงในสตริงอักขระเพื่อแสดงผลลัพธ์ที่สร้างขึ้น

อาร์เรย์ $aFruits ถูกสร้างขึ้นด้วยวิธีปกติ: ค่าต่างๆ จะถูกแสดงรายการ ดัชนีจะถูกกำหนดโดยอัตโนมัติตั้งแต่เริ่มต้น เครื่องหมายจุลภาคสุดท้ายไม่เกี่ยวข้องและไม่สร้างองค์ประกอบว่างอีก

อาร์เรย์ $aData ถูกสร้างขึ้นว่างเปล่า จากนั้นค่าต่างๆ จะถูกเพิ่มลงไป สามรายการเป็นแบบอัตโนมัติ และอีกสองรายการมีดัชนีเชื่อมโยงที่ไม่ส่งผลต่อการกำหนดหมายเลขโดยรวมของค่า ดังนั้นองค์ประกอบ “พลัม” และ “พีช” จึงมีดัชนีเป็น “ใหม่” และ “สด” ตามลำดับ

อาร์เรย์ $aInfo มีหลายมิติและเชื่อมโยงกัน

การดำเนินการลบสามรายการแสดงวิธีลบองค์ประกอบในอาร์เรย์ PHP

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

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

อันที่สามจะลบอาร์เรย์ภายในอาร์เรย์และองค์ประกอบภายในอาร์เรย์ที่เป็นส่วนหนึ่งของอาร์เรย์อื่น

การลบองค์ประกอบตามปกติ - ไม่ได้ตั้งค่า

ฟังก์ชั่นที่ไม่ได้ตั้งค่าจะถูกลบออก มันไม่สำคัญว่าอะไร อาจเป็นเพียงแค่ตัวแปรหรือองค์ประกอบอาร์เรย์ unset() ถือเป็นตัวดำเนินการภาษา ไม่ใช่ฟังก์ชัน โอเปอเรเตอร์นี้ไม่ส่งคืนค่าใดๆ และจะ "ทำลาย" สิ่งที่ส่งผ่านไปเป็นพารามิเตอร์ ตัวแปรหรืออาเรย์จะหายไปเหมือนกับว่ามันไม่เคยมีอยู่เลย

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

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

การลบองค์ประกอบโดยใช้วิธีสตริง

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

แนวคิดขององค์ประกอบว่างขึ้นอยู่กับงาน บ่อยครั้งที่องค์ประกอบอาร์เรย์ที่มีอยู่ซึ่งมีข้อมูลบางอย่างว่างเปล่า ตัวอย่างเช่น อาร์เรย์จะบันทึกผู้เยี่ยมชม องค์ประกอบอาร์เรย์ประกอบด้วย:

• เวลามาถึงของผู้เยี่ยมชม
• โหมดการทำงานปัจจุบัน
• หน้าที่ใช้งาน;
• เวลาดำเนินการครั้งสุดท้าย

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

อย่างไรก็ตาม การประมวลผลแบบ "ไลน์" นั้นดี ตัวอย่างเช่น ใน PHP คุณสามารถลบองค์ประกอบอาร์เรย์ที่ซ้ำกันได้ดังนี้:

วิธีที่รวดเร็วและประหยัด ไม่จำเป็นต้องใช้สัญลักษณ์ "[" และ "]" เพื่อแสดงถึงแต่ละองค์ประกอบ แต่โปรดจำไว้ว่าเมื่อแปลงอาร์เรย์เป็นสตริง คุณต้องแน่ใจว่าแต่ละองค์ประกอบไม่ซ้ำกัน ควรเลือกอักขระในการจัดเฟรมตามอักขระที่ได้รับอนุญาตในองค์ประกอบ กฎที่ไม่สั่นคลอน: แต่ละองค์ประกอบอาร์เรย์ในแถวไม่ซ้ำกันและมีตำแหน่ง (ไม่เช่นนั้นจะไม่มีอะไรสามารถส่งคืนได้)

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

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

หากจำนวนมิติอาร์เรย์มากกว่าสามมิติ นี่เป็นเหตุผลที่ดีที่จะพิจารณาการตัดสินใจอีกครั้ง หากองค์ประกอบอาร์เรย์มีความยาวมากกว่า 4,000-8,000 อักขระ อาจเกิดข้อสงสัยเกี่ยวกับความสมเหตุสมผลของรูปภาพข้อมูลที่สร้างขึ้น

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

เนื่องจากเป็นภาษาโปรแกรมสมัยใหม่ PHP จึงไม่ละเลยการเรียกซ้ำและสแต็ก โดยพื้นฐานแล้วมันไม่สำคัญว่าโปรแกรมเมอร์หมายถึงอะไรเมื่อเขาใช้ฟังก์ชัน array_pop() ใน PHP: ลบองค์ประกอบสุดท้ายของอาร์เรย์หรือเพียงแค่ใส่เข้าไปในตัวแปรบางตัว

แต่โปรดจำไว้ว่าในบริบทนี้ ฟังก์ชัน array_pop นั้นเป็นฟังก์ชัน push & pop กล่าวคือ มันเป็นเครื่องมือสแต็ก ไม่ใช่เครื่องมือลบ

เป็นเรื่องปกติที่จะบอกว่าไม่ใช่ "ลบ" แต่เป็น "แยกออก" ความหมายมีความแตกต่างกันอย่างมาก อย่างไรก็ตาม ฟังก์ชัน array_shift() ใน PHP ซึ่งได้แก่ การลบองค์ประกอบแรกของอาร์เรย์หรือแยกออก มีความหมายแฝงที่แตกต่างกัน นอกจากนี้ องค์ประกอบจะถูกดึงเข้าสู่ตัวแปรภายนอกและจะไม่อยู่ในอาร์เรย์ แต่ดัชนีจะถูกเลื่อน

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

ลบหรือเปลี่ยนแปลง: ประวัติการทำธุรกรรม

ตัวแปรมีมานานแล้ว อาร์เรย์มีมานานแล้ว อ็อบเจ็กต์อยู่เมื่อวาน การเขียนโปรแกรมเชิงวัตถุยังคงเป็นเพียงการพูดถึงเท่านั้น แต่ไม่มีสิ่งใดถูกนำมาใช้อย่างเต็มศักยภาพ เป็นกรณีที่ไม่ค่อยพบนักเมื่อโซลูชันแบบผิวเผินกลายเป็นหัวข้อของโซลูชันที่กระตือรือร้นและระบบการจัดการเนื้อหา (CMS) "ที่ชาญฉลาด" พร้อมด้วย "เนื้อหา" จำนวนมาก

กฎวัตถุประสงค์: ไม่ใช่ปริมาณของโค้ดที่สำคัญ แต่คุณภาพ! แต่ยังไม่มี CMS สมัยใหม่ที่ใส่ใจกฎนี้ ผู้เขียนเชื่อว่าพวกเขากำลังทำสิ่งที่ถูกต้องและรู้ว่ากำลังทำอะไรอยู่

ผลลัพธ์ (คุณลักษณะเฉพาะ): ไม่มี CMS สมัยใหม่ใดที่โดดเด่นด้วย "รูปร่าง" ที่เหมาะสม (การออกแบบที่เพรียวบางและเบา) ล้วนมีโค้ดที่สมบูรณ์มากมาย แต่ละความต้องการจะต้องเคารพ:

• โปรแกรมเมอร์ที่มีคุณสมบัติสูง
• ต้องการการติดตั้ง
• กำหนดข้อกำหนดการโฮสต์
• สร้างปัญหาเมื่อย้ายไปยังโฮสติ้งอื่น
• ทำให้งานและการบริหารงานช้าลงจริงๆ

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

• เลิกทำ;
• ทำซ้ำ

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

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

อาร์เรย์เป็นโครงสร้างข้อมูลในช่วงเวลาหนึ่ง จนถึงทุกวันนี้ ไม่มีภาษาใดที่ถือว่าเวลาเป็นปัจจัยในไวยากรณ์ คุณไม่จำเป็นต้องพูดถึงความหมาย: ตั้งแต่สมัยโบราณจนถึงทุกวันนี้ โปรแกรมเมอร์และผู้ใช้เข้าใจเฉพาะไฟล์และโฟลเดอร์เท่านั้น จำนวนการพัฒนาสูงสุดที่เกิดขึ้น เช่น ใน PHP เนมสเปซจะสะท้อนให้เห็นเล็กน้อยในโครงสร้างของโฟลเดอร์และไฟล์

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

นี่จะเป็นระดับการทำงานที่แตกต่างไปจากเดิมอย่างสิ้นเชิงและคุณภาพของผลลัพธ์ที่ดีขึ้นอย่างมาก

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

อาร์เรย์เป็นการออกแบบแบบโบราณ และแบบเชื่อมโยงนั้นเป็นเครื่องบรรณาการให้เวลามากกว่าข้อกำหนดของการปฏิบัติ แม้ว่าจะมีงานที่เกี่ยวข้องกับการสร้างคอลเลกชันข้อมูลของเนื้อหาที่ไม่ได้กำหนดไว้จำนวนเพียงพอ (ปริมาณ ค่า ประเภท และดัชนี) ซึ่งพร้อมสำหรับการดูและใช้ในลูป องค์ประกอบสุดท้ายของอาร์เรย์พร้อมใช้งาน วิธีการสร้างใดๆ อาร์เรย์ - แบบปกติและแบบเชื่อมโยง - ช่วยให้คุณสร้างรายการได้ แต่ในรูปแบบไวยากรณ์ PHP ปกติ มีการใช้งานที่จำกัด

ค่าอาร์เรย์ปัจจุบัน

ถ้าเรานามธรรมจากดัชนีและใช้การก่อสร้าง

$arData = scField ใหม่(); // scNumber, scString, scParagraph, ...

โดยที่ scField() เป็นตัวสร้างของวัตถุนามธรรม - “องค์ประกอบข้อมูล” ที่มีลูกหลาน: ตัวเลข (scNumber), สตริง (scString), วลี (scParagraph), ... เราได้รับใน PHP: องค์ประกอบสุดท้าย = อาร์เรย์ ของวัตถุที่แสดงคุณสมบัติเป็นองค์ประกอบจริง

โดยพื้นฐานแล้ว ไม่สำคัญว่าองค์ประกอบใดจะถือว่าเกี่ยวข้อง แต่ในกรณีนี้ คุณจะต้องติดตามตัวชี้ (ใน PHP - เคอร์เซอร์) ภายในอาร์เรย์ บ่อยครั้ง คุณจำเป็นต้องมีตัวชี้องค์ประกอบของคุณเอง ไม่จำเป็นต้องมีเคอร์เซอร์ในแนวคิด "last element = array" ของ PHP สามารถเข้าถึงได้ผ่านฟังก์ชัน end() และ array_pop() องค์ประกอบสุดท้ายจะมอบหมายคุณสมบัติให้กับอาร์เรย์ การใช้ array_pop() นอกจากนี้ จะแสดงอาร์เรย์ไปยังองค์ประกอบก่อนหน้าโดยอัตโนมัติ และคุณสมบัติของมันจะเปลี่ยนไปตามนั้น ทำให้สามารถเคลื่อนที่ผ่านองค์ประกอบต่างๆ ได้

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

องค์ประกอบแรกและองค์ประกอบอื่นๆ

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

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

หากคุณเปลี่ยนจุดศูนย์ถ่วงไปที่องค์ประกอบนั้นเอง และปล่อยให้องค์ประกอบตัดสินใจเอง การใช้งานโปรแกรมจะแตกต่างไปจากเดิมอย่างสิ้นเชิงและมีความหมาย ส่วนใหญ่แล้ว นี่เป็นวิธีการที่ช่วยให้คุณบรรลุเป้าหมาย โดยเฉพาะอย่างยิ่งในกรณีดังกล่าว เช่น การใช้แท็กเอกสาร *.docx จำนวนมากที่เขียนในมาตรฐาน Open XML

ใน PHP การรับองค์ประกอบสุดท้ายของอาร์เรย์มีความหมายใหม่และความเป็นไปได้ที่ดี

การโหลดไฟล์และไดนามิกของคุณสมบัติอาร์เรย์

เมื่อไซต์ให้ความสามารถในการดาวน์โหลดไฟล์ใด ๆ จะสะดวกในการใช้แนวคิดของวัตถุนามธรรมเช่น scFile และลูกหลานของ scImage, scDocument, scTabe ซึ่งจะมีคุณสมบัติเหมือนกัน แต่การสำแดงและความหมาย (เนื้อหา)จะแตกต่างออกไป ในบริบทของไวยากรณ์ PHP (องค์ประกอบสุดท้าย = อาเรย์) โดยใช้ฟังก์ชัน end() คุณสามารถใช้เป็นองค์ประกอบสุดท้ายที่กำหนดได้ โซลูชันนี้น่าสนใจเนื่องจากจะแปลงการแสดงตามปกติและช่วยให้คุณสามารถนำทางผ่านโครงสร้างข้อมูลในขณะที่ถูกสร้างขึ้นได้

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

ด้วยการจัดเตรียมวิธีการแสดงภาพการบันทึกในฐานข้อมูลการคืนสภาพการทำงาน (ตัวอย่าง) คุณจะไม่ต้องคิดว่าจะต้องทำอย่างไรในบางกรณี ไฟล์ที่ดาวน์โหลดทั้งหมดจะถูกวางในอาร์เรย์ตามลำดับ และเมื่อมีการประมวลผล วิธีการเดียวกันนี้จะถูกเรียกตามรูปแบบเดียวกันเสมอ แต่ไฟล์รูปภาพจะแสดงตามที่เป็นอยู่ ไฟล์สเปรดชีตเป็นตาราง และเอกสารเป็น ข้อความที่เกี่ยวข้อง เข้าถึงได้ผ่านไวยากรณ์ PHP องค์ประกอบสุดท้ายของอาร์เรย์มีคุณสมบัติและเนื้อหาเฉพาะ

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

สแต็กและการเรียกซ้ำภายในไวยากรณ์

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

แท้จริงแล้ว การใช้ PHPOffice\PHPWord คุณสามารถเปิดเอกสาร Word ใดก็ได้ (*.docx) แต่นี่เป็นเพียงการเก็บถาวรของไฟล์ xml รูปภาพ วัตถุ ฯลฯ ที่มีโครงสร้างจำนวนมาก

ในเวลาเดียวกันหากคุณใช้เฉพาะไฟล์ xml แม้ว่าจะเกี่ยวข้องกัน (ในแง่ของสไตล์ตารางรูปภาพ) ก็จะไม่สามารถสร้างเอกสารใหม่โดยยึดตามเอกสารเก่าและเพียงถ่ายโอนการเปลี่ยนแปลงที่ต้องการไปยังเอกสารนั้น (เช่น เปลี่ยนแบบอักษร สี การจัดรูปแบบ) มีตัวเลือกมากมายสำหรับการใช้แท็ก Open XML และแม้แต่ผลิตภัณฑ์ที่ใช้งานได้ดีอย่าง MS Word ก็ไม่สามารถรับมือกับแนวคิดของผู้ใช้ได้เสมอไปและทำผิดพลาด

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

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

Reg.ru: โดเมนและโฮสติ้ง

นายทะเบียนและผู้ให้บริการโฮสติ้งที่ใหญ่ที่สุดในรัสเซีย

มีชื่อโดเมนมากกว่า 2 ล้านชื่อที่ให้บริการ

โปรโมชั่น เมลโดเมน โซลูชั่นทางธุรกิจ

ลูกค้ามากกว่า 700,000 รายทั่วโลกได้ตัดสินใจเลือกแล้ว

กรอบ Bootstrap: รูปแบบที่ปรับเปลี่ยนได้รวดเร็ว

หลักสูตรวิดีโอทีละขั้นตอนเกี่ยวกับพื้นฐานของเค้าโครงแบบปรับได้ในกรอบงาน Bootstrap

เรียนรู้วิธีการจัดวางเลย์เอาต์อย่างง่ายดาย รวดเร็ว และมีประสิทธิภาพโดยใช้เครื่องมือที่ทรงพลังและใช้งานได้จริง

เค้าโครงการสั่งซื้อและรับเงิน

*เลื่อนเมาส์ไปเหนือเพื่อหยุดการเลื่อนชั่วคราว

กลับไปข้างหน้า

PHP: การลบองค์ประกอบอาร์เรย์

เรากำลังเผชิญกับงานที่ดูเหมือนไม่สำคัญ: การลบองค์ประกอบอาร์เรย์ หรือองค์ประกอบหลายประการ

อย่างไรก็ตาม เพื่อความเรียบง่าย มีตัวเลือกที่ไม่ชัดเจนทั้งหมดและควรค่าแก่การรู้หากคุณต้องการพัฒนา PHP ให้ไกลกว่า "Hello, world!" เล็กน้อย :)

เริ่มจากฐานกันก่อน: หากต้องการลบองค์ประกอบหนึ่งออกคุณต้องใช้ฟังก์ชัน ไม่ได้ตั้งค่า():

ยกเลิกการตั้งค่า($อาร์เรย์); unset($array["foo"]);

ยกเลิกการตั้งค่า($array, $array); unset($array["foo"], $array["bar"]);

คำถามเชิงตรรกะถัดไปคือ: จะลบองค์ประกอบหลายรายการที่ติดตามกัน (เช่น ที่อยู่ติดกัน) ได้อย่างไร หากต้องการลบองค์ประกอบที่อยู่ติดกันหลายรายการ ให้ใช้ฟังก์ชัน array_splice():

Array_splice($อาร์เรย์, $ชดเชย, $ความยาว);

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

$array = $array["foo"] = "";

สิ่งสำคัญคือต้องเข้าใจว่าฟังก์ชั่น ไม่ได้ตั้งค่า()ลบองค์ประกอบในขณะที่กำหนด "" ให้กับองค์ประกอบจะไม่ลบองค์ประกอบนั้น แต่จะทำให้ค่าของมันเท่ากับสตริงว่าง

หากคุณทำงานกับตัวเลข การเชื่อมโยงค่า 0 กับคีย์ดังกล่าวอาจเป็นการดีกว่า

สมมติว่า หากบริษัทหยุดผลิตชิ้นส่วนสำหรับรุ่น HBL-568 ก็สามารถเปลี่ยนแปลงอาร์เรย์ชิ้นส่วนได้:

ยกเลิกการตั้งค่า($ผลิตภัณฑ์["HBL-568"]);

หากไม่มีอะไหล่ HBL-568 ในสต็อกเพียงชั่วคราวและคาดว่าจะมาถึงจากโรงงานก็ควรดำเนินการอย่างอื่นดีกว่า:

$ผลิตภัณฑ์["HBL-568"] = 0;

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

กล่าวอีกนัยหนึ่ง อาเรย์จะไม่ถูกบีบอัดเพื่อเติมเต็ม "รู" ที่เป็นผลลัพธ์ โดยพื้นฐานแล้ว นี่หมายความว่าอาร์เรย์ทั้งหมดมีความเชื่อมโยงกัน แม้ว่าจะดูเหมือนเป็นตัวเลขเมื่อมองแวบแรกก็ตาม ลองดูตัวอย่างที่ชัดเจนเพื่อแสดงให้เห็นพฤติกรรมนี้:

// สร้างอาร์เรย์ "ตัวเลข" $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); พิมพ์ $animals; // พิมพ์ "ผึ้ง" พิมพ์ $animals; // พิมพ์จำนวน "cat" ($animals); // คืนค่า 6 // unset() unset($animals); // ลบองค์ประกอบ $animals = "bee" พิมพ์ $animals; // ไม่แสดงผลใดๆ และมีข้อผิดพลาด E_NOTICE print $animals; // พิมพ์จำนวน "cat" ($animals); // ส่งคืน 5 ในขณะที่องค์ประกอบ $array ยังคงอยู่และมี "fox" // เพิ่มองค์ประกอบใหม่ $animals = "gnu"; // เพิ่มองค์ประกอบใหม่ print $animals; // ไม่พิมพ์อะไรเลย แถมยังแสดงข้อผิดพลาด E_NOTICE พิมพ์ $animals; // พิมพ์จำนวน "gnu"($animals); // ส่งคืน 6 // กำหนด "" (สตริงว่าง) $animals = ""; // ตั้งค่าเป็น "สตริงว่าง" พิมพ์ $animals; // พิมพ์ "" count($animals); // คืนค่า 6 เช่น คำนึงถึงองค์ประกอบอาร์เรย์ว่างเมื่อทำการนับ

หากต้องการเข้าถึงอาร์เรย์ตัวเลขที่มีประชากรหนาแน่น ให้ใช้ฟังก์ชัน array_values():

$animals = array_values($สัตว์);

นอกจากนี้ ฟังก์ชัน array_splice() จะสร้างดัชนีอาร์เรย์ใหม่โดยอัตโนมัติเพื่อกำจัด “holes”:

// สร้างอาร์เรย์ "ตัวเลข" $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); array_splice($สัตว์, 2, 2); print_r($สัตว์);

ที่ผลลัพธ์ที่เราได้รับ:

อาร์เรย์ ( => มด => ผึ้ง => กวาง => สุนัขจิ้งจอก)

คุณลักษณะนี้จะมีประโยชน์ที่ไหน?

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

และสุดท้าย เพื่อลบองค์ประกอบแรกหรือสุดท้ายออกจากอาร์เรย์อย่างปลอดภัย นั่นคือฟังก์ชัน array_shift()และ array_pop()ตามลำดับ

ทุกอย่างง่ายมากสำหรับพวกเขา:

$stack = array("ส้ม", "กล้วย", "แอปเปิ้ล", "ราสเบอร์รี่"); $fruit = array_shift($สแต็ค); print_r($กอง);

จากการรันโค้ดข้างต้น เราจะได้ผลลัพธ์ดังนี้:

อาร์เรย์ ( => กล้วย => แอปเปิ้ล => ราสเบอร์รี่)

หากต้องการลบองค์ประกอบสุดท้าย ให้ใช้ฟังก์ชัน array_pop():

$stack = array("ส้ม", "กล้วย", "แอปเปิ้ล", "ราสเบอร์รี่"); $fruit = array_pop($สแต็ค); print_r($กอง);

ผลลัพธ์คือการพิมพ์อาร์เรย์ต่อไปนี้:

อาร์เรย์ ( => ส้ม => กล้วย => แอปเปิ้ล)

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

คุณชอบเนื้อหาและต้องการขอบคุณฉันหรือไม่?
เพียงแบ่งปันกับเพื่อนและเพื่อนร่วมงานของคุณ!

ดูเพิ่มเติมที่: