PHP อ่านบรรทัดจากไฟล์ การทำงานกับไฟล์ใน php: การเปิด, การเขียน, การอ่าน ไฟล์: โหมดการทำงาน

PHP

file_exists ("test.txt") // มีไฟล์นี้หรือไม่? ขนาดไฟล์ ("test.txt"); // ค้นหาขนาดไฟล์ // ส่งคืนการประทับเวลา: fileatime ("test.txt"); // วันที่เข้าถึงไฟล์ครั้งล่าสุด // วันที่ ("d MY", $ ต่อครั้ง); filemtime ("test.txt"); // วันที่แก้ไขไฟล์ // วันที่ ("d M Y", $ mtime); filectime ("test.txt"); // วันที่สร้างไฟล์ (Windows) // วันที่ ("d M Y", $ ctime);

ไฟล์: โหมดการทำงาน

PHP

ทรัพยากร fopen (ชื่อไฟล์สตริง, โหมดสตริง) // ทรัพยากร - ส่งคืนตัวชี้ไฟล์เมื่อสำเร็จ หรือ FALSE จากข้อผิดพลาด

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

การเปิดและปิดไฟล์ใน PHP

PHP

$ fi = fopen ("test.html", "w +") or die ("ข้อผิดพลาด"); // ตัวอย่าง $ fi = fopen ("http://www.you/test.html", "r"); $ fi = fopen ("http://ftp.you/test.html", "r"); // ปิด fclose ($ fi)

การอ่านไฟล์ใน PHP

PHP

// อ่านไฟล์ fread (int fi, int length) $ str = fread ($ fi, 5); // อ่าน 5 ตัวอักษรแรก echo $ str; // เนื่องจากเคอร์เซอร์เลื่อนไป $ str = fread ($ fi, 12); // อ่าน 12 ตัวอักษรถัดไป echo $ str; fgets (int fi [, int length]) // อ่านบรรทัดจากไฟล์ fgetss (int fi, int length [, string อนุญาต]) // อ่านบรรทัดจากไฟล์และละทิ้งแท็ก HTML // สตริงที่อนุญาต - แท็กที่ ควรเหลือ fgetc (int fi) // อ่านอักขระจากไฟล์

ในขั้นต้น การเขียนจะเกิดขึ้นที่จุดเริ่มต้นของไฟล์ โดยการเขียนทับข้อมูลที่มีอยู่ หากมี ดังนั้น หากคุณต้องการเขียนบางสิ่งต่อท้ายไฟล์ คุณต้องตั้งค่าที่สอดคล้องกัน โหมดอ่านหนังสือเช่น +

การจัดการเคอร์เซอร์ในไฟล์ PHP

PHP

int fseek (int fi, int offset [, int wherece]) // การตั้งค่าเคอร์เซอร์ // int fi - ตัวชี้ไปยังไฟล์ // offset - จำนวนอักขระที่จะย้าย // ที่ไหน: // SEEK_SET - การเคลื่อนไหวเริ่มต้นจากจุดเริ่มต้นของไฟล์ // SEEK_CUR - การเคลื่อนไหวเริ่มจากตำแหน่งปัจจุบัน // SEEK_END - การเคลื่อนไหวเริ่มต้นจากจุดสิ้นสุดของไฟล์ fseek ($ fi, -10, SEEK_END); // อ่าน 10 ตัวอักษรสุดท้าย $ s = fread ($ fi, 10); $ pos = ftell ($ fi); // ค้นหาตำแหน่งปัจจุบันย้อนกลับ ($ f) // รีเซ็ตเคอร์เซอร์ bool feof ($ f) // จุดสิ้นสุดของไฟล์

การทำงานกับไฟล์ (ข้อมูล) โดยตรงใน PHP

PHP

ไฟล์ array (ชื่อไฟล์สตริง) // รับเนื้อหาของไฟล์เป็นอาร์เรย์ // อีกทางเลือกหนึ่งสำหรับการทำงานโดยตรงกับ data file_get_contents (ชื่อไฟล์สตริง) // การอ่าน (เราจะได้ไฟล์ทั้งหมดในบรรทัดเดียว) // การเขียนไปยังไฟล์ (เขียนทับในตอนแรก) file_put_contents (ชื่อไฟล์สตริง ข้อมูลผสม [แฟล็ก int]); // FILE_APPEND // เขียนต่อท้ายไฟล์: file_put_contents ("test.txt", "data", FILE_APPEND); // ถ้าเราเขียนอาร์เรย์ $ array = array ("I", "live"); file_put_contents ("test.txt", $ อาร์เรย์); // จากนั้นเราได้รับ "Ilive"

การจัดการไฟล์ PHP

PHP

คัดลอก (แหล่งที่มาของสตริง, ปลายทางของสตริง); // คัดลอกไฟล์เปลี่ยนชื่อ (str oldname, str newname); // เปลี่ยนชื่อไฟล์ยกเลิกการเชื่อมโยง (ชื่อไฟล์สตริง); // ลบไฟล์

การอัปโหลดไฟล์ไปยังเซิร์ฟเวอร์ PHP

// การตั้งค่า PHP.ini file_uploads (เปิด | ปิด) // เปิดใช้งาน ปิดใช้งานการอัปโหลดไฟล์ upload_tmp_dir // โฟลเดอร์ชั่วคราวสำหรับไฟล์ที่อัปโหลด โฟลเดอร์ชั่วคราวที่เป็นค่าเริ่มต้น upload_max_filesize (ค่าเริ่มต้น = 2 Mb) // สูงสุด ขนาดของไฟล์ที่อัพโหลด post_max_size // ขนาดรวมของแบบฟอร์มที่ส่ง (ต้องมากกว่า upload_max_filesize) // อัพโหลดอย่างง่าย

Html

เราทำงานกับไฟล์บนเซิร์ฟเวอร์

PHP

// รับข้อมูล $ tmp = $ _FILES ["userfile"] ["tmp_name"]; $ ชื่อ = $ _FILES ["userfile"] ["name"]; // ย้ายไฟล์ move_uploaded_file ($ tmp ชื่อ); move_uploaded_file ($ tmp, "อัพโหลด /". ชื่อ); // เปลี่ยนเส้นทางไฟล์ไปยังโฟลเดอร์อัปโหลด // สัมพันธ์กับไฟล์ปัจจุบัน // มีอะไรอยู่ในอาร์เรย์ $ _FILES $ _FILES ["userfile"] ["name"] // ชื่อไฟล์ เช่น test.html $ _FILES [ "userfile"] [" tmp_name "] // ชื่อไฟล์ชั่วคราว (พาธ) $ _FILES [" userfile "] [" size "] // ขนาดไฟล์ $ _FILES [" userfile "] [" type "] // ประเภทไฟล์ $ _FILES [" userfile "] ["error"] // 0 - ไม่มีข้อผิดพลาด หมายเลข - ใช่

เมื่อศึกษาหัวข้อนี้ โปรดทราบว่าฟังก์ชัน PHP บางฟังก์ชันใช้ file descriptor เพื่อเข้าถึงไฟล์ ในขณะที่บางฟังก์ชันใช้เส้นทางของไฟล์

การอ่านจากไฟล์

ฟังก์ชัน fread () สามารถใช้เพื่อดึงข้อมูลตามจำนวนที่ระบุจากไฟล์

fread (ไฟล์, ความยาว)

ตัวเลือก:

file - file descriptor

ความยาว - ขนาดของข้อมูลเป็นไบต์

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

เมื่อระบุความยาวของสตริงและเมื่อย้ายตัวชี้ คุณต้องคำนึงว่าตัวอักษรรัสเซียไม่ได้มีขนาดหนึ่งไบต์ แต่มีมากกว่านั้น สำหรับข้อมูลเพิ่มเติม โปรดดู การทำงานกับสตริง นอกจากนี้ อย่าลืมว่ามีหลายไบต์ที่จุดเริ่มต้นของไฟล์ที่เข้ารหัส UTF-8 ในการเข้ารหัส UTF-8 โดยไม่มี BOM ไบต์เหล่านี้หายไป

มาอ่าน 10 ไบต์แรกจากไฟล์ myfile.txt ให้เปิดในโหมด "r +" ตัวชี้จะอยู่ที่จุดเริ่มต้น

$ file = fopen ("myfile.txt", "r +"); $ take = fread ($ ไฟล์ 10); ก้อง $ รับ;

หากไฟล์มีตัวอักษรรัสเซีย อักษรตัวสุดท้ายอาจแสดงอย่างไม่ถูกต้อง เนื่องจากอักขระมีขนาดมากกว่าหนึ่งไบต์และอ่านส่วนหนึ่งแล้วและอีกส่วนหนึ่งไม่ได้อ่าน

ฟังก์ชัน fgets () ส่งกลับหนึ่งสตริง โดยเริ่มจากตัวชี้ไปยังจุดสิ้นสุดของสตริง

fgets (ไฟล์, ความยาว)

ตัวเลือก:

file - file descriptor

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

หากไม่มีการระบุความยาว ดังนั้นในเวอร์ชันเก่าของ PHP ความยาวสูงสุดของสตริงที่ส่งคืนจะถูกจำกัด เวอร์ชันที่ใหม่กว่าไม่มีข้อจำกัดนี้

การเรียกใช้ฟังก์ชันในลูปทำให้คุณสามารถอ่านไฟล์ได้ทีละบรรทัด

มาอ่านหนึ่งบรรทัดจากไฟล์ myfile.txt เนื่องจากตัวชี้ถูกย้ายแล้ว ระบบจะไม่อ่านทั้งบรรทัด แต่จะอ่านจากตัวชี้

$ take = fgets ($ file); เสียงสะท้อน " ". $ รับ;

ฟังก์ชัน fgetss () ยังส่งคืนสตริงหนึ่งสตริง แต่จะลบแท็ก HTML ออกจากสตริงนั้น หากมีสคริปต์ PHP อยู่ในโค้ด สคริปต์นั้นจะถูกลบออกด้วย

fgetss (ไฟล์, ความยาว, แท็กที่ต้องการ)

ตัวเลือก:

file - file descriptor

ความยาว - ขนาดของสตริงเป็นไบต์ พารามิเตอร์ทางเลือก

แท็กที่จำเป็น - ให้คุณระบุแท็กที่จะไม่ถูกลบ

มีฟังก์ชัน fgetc () ที่ส่งคืนอักขระหนึ่งตัวจากไฟล์

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

ไฟล์ (พาธไฟล์ แฟล็ก บริบท)

ตัวเลือก:

เส้นทางของไฟล์ - เส้นทางของไฟล์แบบสัมบูรณ์หรือแบบสัมพัทธ์

แฟล็ก - แฟล็กที่กำหนดวิธีการทำงานของฟังก์ชัน พารามิเตอร์ทางเลือก

บริบท - ให้คุณระบุทรัพยากรบริบท

คุณสามารถระบุแฟล็กต่อไปนี้:

FILE_USE_INCLUDE_PATH - ให้คุณค้นหาไฟล์ในโฟลเดอร์พาธรวม

FILE_IGNORE_NEW_LINES - ลบอักขระที่สิ้นสุดบรรทัด หากไม่ได้ตั้งค่าสถานะนี้ จะมีอักขระสิ้นสุดบรรทัดในแต่ละบรรทัด

FILE_SKIP_EMPTY_LINES - ไม่เพิ่มบรรทัดว่างลงในอาร์เรย์

หากระบุหลายแฟล็ก แฟล็กจะถูกคั่นด้วยตัวดำเนินการ "|"

ให้แสดงไฟล์ myfile.txt ในหน้า

$ ar = ไฟล์ ("myfile.txt", FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES); เสียงสะท้อน " "; print_r ($ ar);

เขียนลงไฟล์

ฟังก์ชัน fwrite () เขียนข้อมูลลงในไฟล์

fwrite (ไฟล์ ข้อมูล ความยาว)

ตัวเลือก:

file - file descriptor

data - ข้อมูลที่กำลังเขียน

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

หากตัวชี้อยู่ที่จุดเริ่มต้นหรือตรงกลางของไฟล์ ฟังก์ชันจะแทนที่อักขระในไฟล์ด้วยอักขระใหม่ นั่นคือหากเขียนอักขระ 5 ตัว ระบบจะลบอักขระ 5 ตัวออกจากไฟล์และเพิ่มอักขระใหม่แทน

เมื่อคุณเขียนตัวอักษรรัสเซีย การเข้ารหัสสคริปต์จะต้องตรงกับการเข้ารหัสไฟล์

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

$ text = "ข้อความจากสคริปต์"; fwrite (ไฟล์ $, $ text);

การใช้ฟังก์ชัน fopen, fclose, feof, fgets, fgetss และ fscanf

มาดูความเป็นไปได้ทั้งหมดกัน

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

วิธีการ fopen แบบดั้งเดิม

วิธีการของ fopen อาจคุ้นเคยกับโปรแกรมเมอร์ C และ C ++ ในสมัยก่อนมากขึ้น อย่างที่เคยเป็นมา ไม่ว่าจะมากหรือน้อย เครื่องมือที่อยู่แค่เพียงปลายนิ้วสัมผัสมาหลายปีแล้วก็ตาม หากคุณเคยทำงานกับโปรแกรมเหล่านี้ ภาษา สำหรับวิธีการใด ๆ เหล่านี้ คุณทำตามขั้นตอนมาตรฐาน โดยใช้ fopen เพื่อเปิดไฟล์ ฟังก์ชันสำหรับอ่านข้อมูล จากนั้น fclose เพื่อปิดไฟล์ ดังที่แสดงในรายการที่ 1

รายการ 1. การเปิดและอ่านไฟล์ด้วยfgets

$ file_handle = fopen ("myfile", "r"); ในขณะที่ (! feof ($ file_handle)) ($ line = fgets ($ file_handle); echo $ line;) fclose ($ file_handle);

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

1. เปิดไฟล์. $ file_handle เก็บลิงค์ไปยังไฟล์นั้นเอง
2. ตรวจสอบเพื่อดูว่าคุณได้มาถึงจุดสิ้นสุดของไฟล์หรือไม่
3. อ่านไฟล์ต่อจนจบ พิมพ์ทุกบรรทัดที่อ่าน
4. ปิดไฟล์.

โดยคำนึงถึงสิ่งนั้น ฉันจะพูดถึงทุกฟังก์ชันของไฟล์ที่ใช้ที่นี่

ฟังก์ชั่น Fopen

ฟังก์ชัน fopen สร้างลิงก์ไปยังไฟล์ ฉันพูดว่า "เชื่อมต่อ" เพราะนอกจากจะเปิดไฟล์แล้ว fopen ยังสามารถเปิด URL ได้อีกด้วย:

$ fh = fopen ("http://127.0.0.1/", "r");

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

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

ฟังก์ชั่น Feof

คำสั่ง feof กำหนดว่าได้อ่านจนจบไฟล์และคืนค่า True หรือ False ลูปที่ระบุจะดำเนินต่อไปจนกระทั่งสิ้นสุดไฟล์ "myfile" โปรดทราบว่า feof จะคืนค่า False หากคุณอ่าน URL และการเชื่อมต่อหมดเวลาเนื่องจากไม่มีข้อมูลให้อ่านอีกต่อไป

ฟังก์ชั่น Fclose

ข้ามตรงกลางรายการ 1 และไปที่จุดสิ้นสุด fclose ทำสิ่งที่ตรงกันข้ามกับ fopen: มันปิดการเชื่อมต่อกับไฟล์หรือ URL หลังจากใช้งานฟังก์ชันนี้ คุณจะไม่สามารถอ่านจากไฟล์หรือซ็อกเก็ตได้อีกต่อไป

ฟังก์ชั่น Fgets

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

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

$ string = fgets ($ file_handle, 81);

ลองนึกถึง "\ 0" ซึ่งเป็นส่วนท้ายของบรรทัดในภาษา C แล้วตั้งค่าความยาวเป็นอักขระมากกว่าหนึ่งตัวที่คุณต้องการจริงๆ ดังที่คุณเห็น ตัวอย่างข้างต้นใช้ 81 ในขณะที่คุณต้องการ 80 อักขระ ทำให้เป็นนิสัยในการเพิ่มอักขระพิเศษเมื่อใดก็ตามที่คุณต้องการกำหนดขีดจำกัดความยาวของสตริงสำหรับฟังก์ชันที่กำหนด

ฟังก์ชั่น Fread

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

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

$ fh = fopen ("myfile", "rb"); $ data = fread ($ file_handle, 4096);

ตัวอย่างข้างต้นอ่านข้อมูล 4096 ไบต์ (4 KB) โปรดทราบว่าไม่ว่าคุณจะระบุค่าใด fread จะอ่านได้ไม่เกิน 8192 ไบต์ (8 KB)

สมมติว่าไฟล์มีขนาดไม่เกิน 8 KB ข้อมูลโค้ดด้านล่างควรอ่านไฟล์ทั้งหมดในบรรทัดเดียว

$ fh = fopen ("myfile", "rb"); $ data = fread ($ fh, ขนาดไฟล์ ("myfile")); fclose ($ fh);

หากไฟล์มีขนาดใหญ่ คุณจะต้องใช้ลูปเพื่ออ่านไฟล์ที่เหลือ

ฟังก์ชัน Fscanf

กลับไปที่การประมวลผลบรรทัด โปรดทราบว่า fscanf เป็นตัวตายตัวแทนของฟังก์ชันไลบรารี C แบบไฟล์ดั้งเดิม หากคุณไม่คุ้นเคย fscanf จะอ่านฟิลด์ข้อมูลลงในตัวแปรจากไฟล์

รายการ ($ field1, $ field2, $ field3) = fscanf ($ fh, "% s% s% s");

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

ฟังก์ชัน Fgetss

ฟังก์ชัน fgetss นั้นแตกต่างจากฟังก์ชันไฟล์ทั่วไป และช่วยให้คุณมีความคิดที่ดีขึ้นว่า PHP ทำอะไรได้บ้าง มันทำงานเหมือน fgets แต่จะแยกแท็ก HTML หรือ PHP ที่พบออก เหลือเพียงข้อความ "เปล่า" ลองใช้ไฟล์ HTML ด้านล่าง

รายการ 2. ไฟล์ HTML ตัวอย่าง

ถ้าคุณเข้าใจคำว่า "เพราะที่นั่น" ไม่มีใครทำให้คุณเจ็บปวด "หมายความว่าอย่างไร แสดงว่าคุณฟังเพลงของวง America มากเกินไป

ลองใช้ฟังก์ชัน fgetss กัน

รายการ 3. ใช้fgetss

$ file_handle = fopen ("myfile", "r"); ในขณะที่ (! feof ($ file_handle)) (echo = fgetss ($ file_handle);) fclose ($ file_handle);

นี่คือสิ่งที่คุณได้รับเป็นผลลัพธ์:

ชื่อของฉันถ้าคุณเข้าใจสิ่งที่ "สาเหตุ" ที่ไม่มีใครทำให้คุณเจ็บปวด "หมายความว่าคุณฟังวงดนตรีอเมริกามากเกินไป

ฟังก์ชัน Fpassthru

ไม่ว่าคุณจะอ่านข้อมูลจากไฟล์ด้วยวิธีใด คุณสามารถพิมพ์ข้อมูลที่เหลือโดยใช้ไปป์เอาต์พุตมาตรฐานโดยใช้ฟังก์ชัน fpassthru

fpassthru ($ fh);

ฟังก์ชันนี้จะพิมพ์ข้อมูล ดังนั้นคุณไม่จำเป็นต้องใส่ลงในตัวแปร

การประมวลผลไฟล์แบบไม่เชิงเส้น: เคลื่อนที่ผ่านไฟล์

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

fseek ($ fh, 0);

ตัวอย่างข้างต้นข้ามกลับไปที่จุดเริ่มต้นของไฟล์ หากคุณไม่ต้องการย้ายไปที่จุดเริ่มต้นของไฟล์ - พูดว่าหนึ่งกิโลไบต์ก็เพียงพอแล้ว - คุณเพียงแค่เขียน:

fseek ($ fh, 1024);

สำหรับ PHP V4.0 นั้นมีตัวเลือกอื่น ๆ อีกหลายตัวให้เลือก ตัวอย่างเช่น หากคุณต้องการข้ามไปข้างหน้า 100 ไบต์จากตำแหน่งปัจจุบันของคุณ คุณสามารถใช้รหัสต่อไปนี้:

fseek ($ fh, 100, SEEK_CUR);

ในทำนองเดียวกันการกระโดดกลับ 100 ไบต์ทำได้โดย:

fseek ($ fh, -100, SEEK_CUR);

หากคุณต้องการย้อนกลับไปที่ 100 ไบต์ก่อนสิ้นสุดไฟล์ ให้ใช้ SEEK_END แทน

fseek ($ fh, -100, SEEK_END);

เมื่อคุณไปถึงตำแหน่งใหม่แล้ว คุณสามารถใช้ fgets, fscanf หรือฟังก์ชันอื่นเพื่ออ่านข้อมูลได้

บันทึก:คุณไม่สามารถใช้ fseek กับ file descriptor ที่อ้างอิง URL

จับภาพทั้งไฟล์

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

$ my_file = file_get_contents ("ชื่อไฟล์ของฉัน"); เสียงสะท้อน $ my_file;

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

echo file_get_contents ("ชื่อไฟล์ของฉัน");

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

echo file_get_contents ("http://127.0.0.1/");

คำสั่งนี้จริง ๆ แล้วเหมือนกับ:

$ fh = fopen ("http://127.0.0.1/", "r"); fpassthru ($ fh);

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

readfile ("http://127.0.0.1/");

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

@readfile ("http://127.0.0.1/");

แน่นอน ถ้าคุณต้องการประมวลผลเนื้อหาของไฟล์ แสดงว่าบรรทัดเดียวที่ file_get_contents ส่งคืนนั้นอาจมากเกินไป คุณอาจต้องการแบ่งออกเป็นส่วน ๆ ก่อนโดยใช้ฟังก์ชัน split ()

$ array = split ("\ n", file_get_contents ("myfile"));

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

$ array = ไฟล์ ("myfile");

ควรสังเกตว่ามีความแตกต่างเล็กน้อยระหว่างสองตัวอย่างข้างต้น คำสั่ง split จะลบการขึ้นบรรทัดใหม่ ในขณะที่คำสั่ง file ลงท้ายด้วยการขึ้นบรรทัดใหม่ (เหมือนกับ fgets)

อย่างไรก็ตาม ความสามารถของ PHP นั้นเหนือกว่าที่อธิบายไว้ข้างต้นมาก คุณสามารถแยกวิเคราะห์ไฟล์ .ini สไตล์ PHP ทั้งหมดได้ด้วยคำสั่งเดียว parse_ini_file คำสั่ง parse_ini_file ใช้กับไฟล์ที่คล้ายกับในรายการ 4

รายการ 4. ตัวอย่าง .ini file

; ชื่อความคิดเห็น = ภารกิจ "King Arthur" = เพื่อแสวงหาจอกศักดิ์สิทธิ์สีโปรด = สีน้ำเงิน ซามูเอลคลีเมนส์ = Mark Twain Caryn Johnson = Whoopi Goldberg

คำสั่งต่อไปนี้แสดงไฟล์เป็นอาร์เรย์ แล้วพิมพ์อาร์เรย์นั้น:

$ file_array = parse_ini_file ("holy_grail.ini"); print_r $ file_array;

สิ่งนี้จะสร้างผลลัพธ์ต่อไปนี้:

รายการ 5. ผลลัพธ์

Array (=> King Arthur => เพื่อแสวงหา Holy Grail => Blue => Mark Twain => Whoopi Goldberg)

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

$ file_array = parse_ini_file ("holy_grail.ini", จริง); print_r $ file_array;

และผลลัพธ์ของคุณจะมีลักษณะดังนี้:

รายการ 6. ผลลัพธ์

Array (=> Array (=> King Arthur => เพื่อแสวงหา Holy Grail => Blue) => Array (=> Mark Twain => Whoopi Goldberg))

PHP วางข้อมูลในอาร์เรย์หลายมิติที่สามารถแยกวิเคราะห์ได้อย่างง่ายดายสำหรับการวิเคราะห์

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

รูปแบบการเขียนโปรแกรมที่ดี

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

รายการ 7. การใช้ file_exists และ is_readable

$ filename = "myfile"; if (file_exists ($ ชื่อไฟล์) && is_readable ($ ชื่อไฟล์)) ($ fh = fopen ($ ชื่อไฟล์ "r"); # กำลังประมวลผล fclose ($ fh);)

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

if ($ fh = fopen ($ ชื่อไฟล์ "r")) (# กำลังประมวลผล fclose ($ fh);)

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

เช่นเดียวกับ fopen ฟังก์ชัน file_get_contents, file และ readfile จะคืนค่า False หากไม่สามารถเปิดหรือประมวลผลไฟล์ได้ ฟังก์ชัน fgets, fgetss, fread, fscanf และ fclose จะคืนค่า False เมื่อเกิดข้อผิดพลาด แน่นอน ยกเว้น fclose คุณอาจได้ประมวลผลผลลัพธ์ที่ส่งคืนแล้ว เท่าที่เกี่ยวข้องกับ fclose มีเพียงเล็กน้อยที่สามารถทำได้หาก file descriptor ไม่ปิดอย่างถูกต้อง ดังนั้นการตรวจสอบค่าส่งคืนของ fclose มักจะเกินความจำเป็น

ทางเลือกเป็นของคุณ

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

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

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

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

ในการสร้างไฟล์ php ในสคริปต์ปฏิบัติการ คุณเพียงแค่ระบุฟังก์ชันสองสามอย่าง:

ลองพิจารณาตัวอย่างทันที:

$ text = "ข้อความบางส่วนสำหรับเขียนไฟล์";
$ fp = fopen ("file.txt", "w");
fwrite ($ fp, $ ข้อความ);
fclose ($ fp);
?>

ที่นี้ควรรู้:

เปิด ()- ฟังก์ชั่นเปิดไฟล์สำหรับอ่านหรือเขียนและปรับแต่ง

การปรับแต่งเหล่านี้ (พารามิเตอร์โหมดของฟังก์ชัน fopen) มีความสำคัญมาก:

• "NS"- เปิดไฟล์ใน php สำหรับการอ่านเท่านั้น... เคอร์เซอร์ถูกวางไว้ที่จุดเริ่มต้น
• "r +"- เปิดไฟล์ใน php สำหรับการอ่านและการเขียน... เคอร์เซอร์ถูกวางไว้ที่จุดเริ่มต้น !!! - ด้วยสองโหมดนี้ r และ r + ไฟล์จะต้องถูกสร้างขึ้นแล้ว (มิฉะนั้นจะเกิดข้อผิดพลาดขึ้น คำเตือน: fopen (file.txt): ไม่สามารถเปิดสตรีม: ไม่มีไฟล์หรือไดเรกทอรีดังกล่าวใน ...) และเราอ่านเท่านั้นหรือเรามีโอกาสที่จะเพิ่ม
• "w"- ไฟล์ถูกเปิดเพื่อเขียนเท่านั้น ไฟล์ถูกตัดให้มีความยาวเป็นศูนย์ - นั่นคือมันถูกเขียนทับ มันถูกเขียนในสิ่งที่จำเป็นและวางเคอร์เซอร์ไว้ที่จุดเริ่มต้น
• "w +"- ไฟล์ถูกเปิดเพื่อเขียนและอ่าน! ส่วนที่เหลือเหมือนกับในโหมด" w " !!! - ด้วยสองโหมดนี้ - หากไฟล์ไม่ได้ถูกสร้างขึ้น - พยายามสร้างมัน!
• "NS"- เปิดไฟล์เพื่อเขียนเท่านั้น ไม่เหมือนกับ" w " พารามิเตอร์นี้ไม่เขียนทับเนื้อหาของไฟล์ แต่วางเคอร์เซอร์ไว้ที่ท้ายบรรทัดและต่อท้ายเนื้อหาที่เราต้องการเพิ่มต่อท้าย
• "เป็น +"- เปิดไฟล์สำหรับเขียนอ่าน

fwrite($ fp, $ text) - หน้าที่ของการเขียนไปยังไฟล์ใน php - นั่นคือสิ่งที่อยู่ในตัวแปร $ text ถูกเขียนไปยังไฟล์ซึ่งอยู่ในตัวแปร $ fp;

fclose($ fp) - ฟังก์ชั่นปิดไฟล์ที่เราเขียนไปยังตัวแปร $ fp;

ในตอนนี้ คุณสามารถสร้างไฟล์ที่ถูกต้องใน php ได้อย่างปลอดภัย เปิดอ่านและแก้ไข

โปรแกรมเสริมและฟังก์ชัน PHP ที่มีประโยชน์สำหรับการทำงานกับไฟล์ที่เปิดอยู่:

ในขณะที่ (! feof ($ fp)) (
$ mytext = fgets ($ fp, 99);
echo $ mytext. "
";
}

ที่นี่เงื่อนไขเป็นจริง - "จนกว่าจะถึงจุดสิ้นสุดของไฟล์แล้วทำอย่างนั้น" ในขณะที่ (! feof ($ fp))

1. ฟังก์ชัน fgets($ fp, 99) - ให้คุณแบ่งเนื้อหาทั้งหมดออกเป็นส่วนๆ 99 ไบต์และเพิ่มเติม เพื่อดูสิ่งนี้ให้ชัดเจนยิ่งขึ้น เราใส่แท็ก

ฟังก์ชันสตริงนี้ fgets(ตัวจัดการทรัพยากร [, ความยาว int]) โดยค่าเริ่มต้นจะยอมรับความยาว 1024 ไบต์ (1 กิโลไบต์) หากไม่ได้ระบุไว้ พารามิเตอร์นี้เป็นทางเลือกตั้งแต่ PHP 4.2.0 (คืนค่า FALSE เมื่อมีข้อผิดพลาด)

ฟังก์ชันเพิ่มเติมสำหรับการเปิด เขียน และสร้างไฟล์

ฟังก์ชัน - int readfile(ชื่อไฟล์สตริง [, bool use_include_path [, บริบททรัพยากร]]) - อ่านไฟล์โดยรวม

อ่านไฟล์และเขียนเนื้อหาไปยังบัฟเฟอร์เอาต์พุต และจะส่งกลับจำนวนไบต์ที่พิมพ์ ในกรณีที่มีข้อผิดพลาดจะกลับมาหากไม่ได้ใช้สุนัข - @readfile

สิ่งนี้จะกลายเป็น:

ที่ท้ายคำ แท็กคือ
.

NS. ฟังก์ชัน - อาร์เรย์ ไฟล์(ชื่อไฟล์สตริง [, int use_include_path [, บริบททรัพยากร]]) ทำเช่นเดียวกับฟังก์ชัน readfile โดยมีข้อยกเว้นประการหนึ่งคือจะเพิ่มเนื้อหาของไฟล์ลงในอาร์เรย์:

ดังนั้น คุณสามารถอ่านหน้าใดก็ได้บนอินเทอร์เน็ต: $ lines = file ("http: // site /"); และวนซ้ำอาร์เรย์ผ่านฟังก์ชัน foreach

3ก. ฟังก์ชันสตริง file_get_contents(ชื่อไฟล์สตริง [, bool use_include_path [, บริบททรัพยากร [, int offset [, int maxlen]]]]) - ให้คุณรับเนื้อหาเป็นบรรทัดเดียว

มันอเนกประสงค์มากขึ้น ฟังก์ชัน PHPหากต้องการอ่านไฟล์ คล้ายกับฟังก์ชันไฟล์ เฉพาะเนื้อหาที่ส่งคืนไปยังสตริง ไม่ใช่อาร์เรย์ และคุณสามารถระบุเงื่อนไขได้ - ไบต์ใดที่จะเริ่มต้นด้วย - offsetและอันไหนที่จะลงท้ายด้วย - maxlen... ส่งกลับ FALSE เมื่อล้มเหลว

สำคัญ!!!- ในกรณีนี้ ฟังก์ชันจะแทนที่ 3 อย่างพร้อมกัน: fopen (), fread () และ fclose () จึงกำจัดแสตมป์

3b. ฟังก์ชัน Int file_put_contents(ชื่อไฟล์สตริง, ข้อมูลผสม [, แฟล็ก int [, บริบททรัพยากร]]) - เหมือนกับการเรียกตามลำดับของฟังก์ชัน fopen (), fwrite () และ fclose () - ส่งกลับจำนวนไบต์ที่เขียน

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

การทำงานกับไฟล์แบ่งออกเป็น 3 ขั้นตอน:

1. การเปิดไฟล์.
2. การจัดการข้อมูล
3. การปิดไฟล์.

ผม. การเปิดไฟล์

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

$ fp = fopen ("counter.txt", "r");

ตามเอกสารของ PHP โหมดไฟล์ประเภทต่อไปนี้มีความโดดเด่น:

1. r - เปิดไฟล์แบบอ่านอย่างเดียว
2. r + - เปิดไฟล์พร้อมกันเพื่ออ่านและเขียน
3. w - สร้างไฟล์เปล่าใหม่ หากในขณะที่โทรมีไฟล์ดังกล่าวอยู่แล้ว ไฟล์นั้นจะถูกทำลาย
4. w + - คล้ายกับ r + เฉพาะในกรณีที่มีไฟล์ดังกล่าวอยู่ในขณะที่โทร เนื้อหาจะถูกลบออก
5. a - เปิดไฟล์ที่มีอยู่ในโหมดเขียน ในขณะที่ตัวชี้ถูกเลื่อนไปที่ไบต์สุดท้ายของไฟล์ (ไปที่ท้ายไฟล์)
6. a + - เปิดไฟล์ในโหมดอ่านและเขียน ในขณะที่ตัวชี้ถูกเลื่อนไปที่ไบต์สุดท้ายของไฟล์ (ไปที่ส่วนท้ายของไฟล์) เนื้อหาของไฟล์จะไม่ถูกลบ

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

สำหรับการสาธิต ให้พิจารณาสถานการณ์สมมติต่อไปนี้:

// เปิดไฟล์ในโหมดต่างๆ
$ fp = fopen ("counter.txt", "r"); // โหมดไบนารี
$ fp = fopen ("counter.txt", "rt"); // โหมดข้อความ
$ fp = fopen ("http://www.yandex.ru", "r"); // เปิดการเชื่อมต่อ HTTP สำหรับการอ่าน
$ fp = fopen ("ftp: // ผู้ใช้: [ป้องกันอีเมล]"," w "); // เปิดการเชื่อมต่อ FTP ด้วยการเข้าสู่ระบบและรหัสผ่าน
?>

II... การจัดการข้อมูลไฟล์

เขียนข้อมูลลงไฟล์เมื่อ PHP helpคุณสามารถใช้ฟังก์ชั่น เขียน ()... ฟังก์ชันนี้ใช้พารามิเตอร์ที่จำเป็น 2 ตัวและพารามิเตอร์เสริม 1 ตัว พารามิเตอร์ที่จำเป็นคือ file descriptor และ file mode:

$ fp = fopen ("counter.txt", "a"); // เปิดไฟล์ในโหมดเขียน
$ mytext = "เราต้องเขียนบรรทัดนี้ \ r \ n"; // สตริงต้นทาง
$ test = fwrite ($ fp, $ mytext); // เขียนลงไฟล์
if ($ test) echo "ข้อมูลถูกป้อนลงในไฟล์เรียบร้อยแล้ว";
else echo "เกิดข้อผิดพลาดในการเขียนไปยังไฟล์";
fclose ($ fp); // ปิดไฟล์
?>

หากต้องการอ่านไฟล์ทีละบรรทัด ให้ใช้ฟังก์ชัน fgets ()... ฟังก์ชันใช้พารามิเตอร์ที่จำเป็น 2 ตัว:

ถ้า ($ fp)
{
ในขณะที่ (! feof ($ fp))
{
$ mytext = fgets ($ fp, 999);
echo $ mytext. "
";
}
}

fclose ($ fp);
?>

หมายเหตุ: B ตัวอย่างนี้ค่า 999 กำหนดจำนวนอักขระที่จะอ่านจนกว่าตัวชี้จะถึงจุดสิ้นสุดของไฟล์ (EOF)

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

echoreadfile ("counter.txt");
?>

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

$ fp = fopen ("counter.txt", "r"); // เปิดไฟล์ในโหมดอ่าน
ถ้า ($ fp) echo fpassthru ($ fp);
elseecho "เกิดข้อผิดพลาดในการเปิดไฟล์";
?>

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

หมายเหตุ: อย่าใช้ฟังก์ชัน ไฟล์ ()ไปยังไฟล์ไบนารี (ปลอดภัยแบบไบนารี) เพราะ มันไม่ปลอดภัยในแง่ของการอ่านไฟล์ไบนารี่ ถ้าในขณะเดียวกัน ที่ไหนสักแห่งที่มีอักขระ end-of-file (EOF) ก็ไม่รับประกันว่าคุณจะอ่านไฟล์ไบนารีทั้งหมด

$ file_array = ไฟล์ ("counter.txt"); // อ่านไฟล์เป็น $ file_array
// ทำงานกับข้อมูลอาร์เรย์
?>

หมายเหตุ: มีการอธิบายการทำงานกับอาร์เรย์โดยละเอียด ผู้เขียน: Mukhametshin D.F. , Simdyanov I.V.

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

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

$ fp = fopen ("counter.txt", "r"); // เปิดไฟล์ในโหมดอ่าน
ถ้า ($ fp)
{
ในขณะที่ (! feof ($ fp))
{
$ ถ่าน = fgetc ($ fp);
if ($ char == "c") $ i = $ i + 1; // ค้นหาอักขระ "c"
}
echo "จำนวนตัวอักษร" c "ในไฟล์:" $ ฉัน;
}
else echo "เกิดข้อผิดพลาดในการเปิดไฟล์";
?>

สาม... การปิดไฟล์

การปิดไฟล์โดยใช้ฟังก์ชั่น ปิด ()ซึ่งรับ 1 พารามิเตอร์ที่จำเป็น

$ fp = fopen ("counter.txt", "r");
ถ้า ($ fp)
{
echo "เปิดไฟล์";
fclose ($ fp); // ปิดไฟล์
}
?>

รวบรวมสูตรอาหาร

1) เราจำเป็นต้องตรวจสอบว่าไฟล์นี้หรือไฟล์นั้นมีอยู่จริง เมื่อต้องการทำเช่นนี้ เราจะใช้ฟังก์ชัน แฟ้มที่มีอยู่ ().

myfile ("counter.txt"); // ใช้ฟังก์ชัน myfile ส่งชื่อไฟล์เป็นอาร์กิวเมนต์

function myfile ($ name) // สร้างฟังก์ชันเพื่อตรวจสอบว่ามีไฟล์อยู่หรือไม่
{
if (file_exists ($ name)) echo "มีไฟล์อยู่";

}
?>

หมายเหตุ: ฟังก์ชั่น แฟ้มที่มีอยู่ไม่ตรวจสอบไฟล์บนเว็บเซิร์ฟเวอร์ระยะไกล สำหรับ งานที่ถูกต้องฟังก์ชัน ไฟล์สคริปต์ต้องอยู่บนเซิร์ฟเวอร์ที่ไฟล์ถูกตรวจสอบอยู่

2) กำหนดขนาดไฟล์โดยใช้ฟังก์ชัน ขนาดไฟล์()

myfile ("counter.txt");

function myfile ($ name) // สร้างฟังก์ชันเพื่อตรวจสอบการมีอยู่ของไฟล์และกำหนดขนาดของไฟล์
{
if (file_exists ($ name)) echo "File size:" .filesize ($ name) "byte";
อื่น echo "ไม่มีไฟล์";
}
?>

3) สร้างไฟล์ชั่วคราวโดยใช้ฟังก์ชั่น tmpfile()

$ myfile = tmpfile ();
fwrite ($ myfile, "บรรทัดนี้ถูกเขียนไปยังไฟล์ชั่วคราว"); // เขียนลงไฟล์ชั่วคราว
fseek ($ myfile, 0); // ตั้งค่าตัวชี้ไฟล์
เสียงสะท้อน ($ myfile, 1024); // แสดงเนื้อหาของไฟล์
?>

4) คุณต้องกำหนดจำนวนบรรทัดในไฟล์ สำหรับสิ่งนี้เราใช้ฟังก์ชั่น นับ()

$ fp = ไฟล์ ("counter.txt");
echo "จำนวนบรรทัดในไฟล์:" .count ($ fp);
?>

5) เราจำเป็นต้องใช้กลไกการล็อกไฟล์

$ fp = fopen ("counter.txt", "a");
ฝูง ($ fp, LOCK_EX); // ล็อกไฟล์สำหรับเขียน
fwrite ($ fp, "สตริงที่จะเขียน");
ฝูง ($ fp, LOCK_UN); // ปลดล็อค
fclose ($ fp);
?>

6) เราจำเป็นต้องลบบรรทัดเฉพาะออกจากไฟล์

$ num_stroka = 5; // ลบบรรทัดที่ 5 ออกจากไฟล์
$ file = ไฟล์ ("counter.txt"); // อ่านไฟล์ทั้งหมดลงในอาร์เรย์

สำหรับ ($ i = 0; $ i< sizeof($file); $i++)
ถ้า ($ i == $ num_stroka) ยกเลิกการตั้งค่า ($ file [$ i]);

$ fp = fopen ("counter.txt", "w");
fputs ($ fp, ระเบิด ("", $ file));
fclose ($ fp);
?>

7) การกำหนดประเภทไฟล์ เราใช้ฟังก์ชัน