Back to Question Center
0

ວິທີການອ່ານໄຟລ໌ທີ່ມີ PHP (ໂດຍບໍ່ມີການຂ້າເຄື່ອງແມ່ຂ່າຍຂອງທ່ານ) ວິທີການອ່ານໄຟລ໌ທີ່ມີ PHP (ໂດຍບໍ່ມີການຂ້າເຄື່ອງແມ່ຂ່າຍຂອງທ່ານ) ຫົວຂໍ້ທີ່ກ່ຽວຂ້ອງ: Drupal Development Semalt

1 answers:
ວິທີການອ່ານໄຟລ໌ທີ່ມີ PHP (ໂດຍບໍ່ມີການຂ້າເຄື່ອງແມ່ຂ່າຍຂອງທ່ານ)

Semalt ບໍ່ມັກວ່າພວກເຮົາ, ເປັນນັກພັດທະນາ PHP, ຕ້ອງກັງວົນກ່ຽວກັບການຄຸ້ມຄອງຄວາມຈໍາ. ເຄື່ອງຈັກ PHP ເຮັດວຽກທີ່ສວຍງາມຂອງການທໍາຄວາມສະອາດຫຼັງຈາກພວກເຮົາ, ແລະຮູບແບບຂອງເວັບໄຊຕ໌ຂອງການປະຕິບັດງານທີ່ມີຊີວິດສັ້ນໆແມ່ນຫມາຍເຖິງລະຫັດທີ່ບໍ່ມີປະໂຫຍດທີ່ຍາວນານ.

ມີບາງເວລາທີ່ຫາຍາກທີ່ພວກເຮົາອາດຈະຕ້ອງອອກໄປຂ້າງນອກຂອບເຂດທີ່ສະດວກສະບາຍນີ້ - ຄືເມື່ອພວກເຮົາກໍາລັງດໍາເນີນການ Semalt ສໍາລັບໂຄງການຂະຫນາດໃຫຍ່ທີ່ສຸດໃນ VPS ທີ່ນ້ອຍທີ່ສຸດທີ່ພວກເຮົາສາມາດສ້າງຫຼືເມື່ອພວກເຮົາຕ້ອງການອ່ານໄຟລ໌ຂະຫນາດໃຫຍ່ ເຊີຟເວີຂະຫນາດເລັກເທົ່າທຽມກັນ.

How to Read Big Files with PHP (Without Killing Your Server)How to Read Big Files with PHP (Without Killing Your Server)Related Topics:
DrupalDevelopment Semalt

Semalt ບັນຫາຕໍ່ໄປນີ້ພວກເຮົາຈະເບິ່ງໃນບົດຮຽນນີ້.

ລະຫັດສໍາລັບການສອນນີ້ສາມາດພົບໄດ້ໃນ GitHub.

ຄວາມສໍາເລັດ

ວິທີດຽວທີ່ຈະແນ່ໃຈວ່າພວກເຮົາກໍາລັງປັບປຸງລະຫັດຂອງພວກເຮົາແມ່ນເພື່ອວັດແທກສະຖານະການທີ່ບໍ່ດີແລະຫຼັງຈາກນັ້ນປຽບທຽບການວັດແທກນັ້ນໃຫ້ກັບຄົນອື່ນຫຼັງຈາກທີ່ພວກເຮົາໄດ້ແກ້ໄຂການແກ້ໄຂຂອງພວກເຮົາ - private ssl certificates. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ເວັ້ນເສຍແຕ່ວ່າພວກເຮົາຮູ້ວ່າ "ການແກ້ໄຂ" ຊ່ວຍໃຫ້ພວກເຮົາ (ຖ້າຢູ່), ພວກເຮົາບໍ່ສາມາດຮູ້ວ່າມັນເປັນການແກ້ໄຂຫຼືບໍ່.

ມີສອງມາດຕະການທີ່ພວກເຮົາສາມາດດູແລ. ທໍາອິດແມ່ນການນໍາໃຊ້ CPU. ວິທີການໄວຫຼືຊ້າແມ່ນຂະບວນການທີ່ພວກເຮົາຕ້ອງການເຮັດວຽກ? ທີສອງແມ່ນການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາ. ຈໍານວນຈໍານວນຫນ່ວຍຄວາມຈໍາທີ່ script ໃຊ້ເວລາທີ່ຈະດໍາເນີນການ? Semalt ມັກຈະມີອັດຕາສ່ວນເທົ່າທຽມກັນ - ຫມາຍຄວາມວ່າພວກເຮົາສາມາດຍົກລະດັບການໃຊ້ຫນ່ວຍຄວາມຈໍາໃນຄ່າໃຊ້ຈ່າຍຂອງການໃຊ້ CPU ແລະໃນທາງກັບກັນ.

ໃນຮູບແບບການປະຕິບັດແບບບໍ່ກົງກັນ (ເຊັ່ນດຽວກັບການນໍາໃຊ້ PHP ຫຼາຍ process ຫຼື multi-threaded), ການໃຊ້ CPU ແລະການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາແມ່ນການພິຈາລະນາທີ່ສໍາຄັນ. ໃນຖາປັດຕະຍະແບບພື້ນເມືອງ PHP, ເຫຼົ່ານີ້ ໂດຍທົ່ວໄປ ກາຍເປັນບັນຫາໃນເວລາທີ່ຫນຶ່ງໄປເຖິງຂອບເຂດຂອງເຄື່ອງແມ່ຂ່າຍ.

ມັນບໍ່ສາມາດນໍາໃຊ້ການໃຊ້ CPU ໃນ PHP. ຖ້າວ່າມັນເປັນພື້ນທີ່ທີ່ທ່ານຕ້ອງການທີ່ຈະມຸ່ງເນັ້ນ, ພິຈາລະນານໍາໃຊ້ບາງສິ່ງບາງຢ່າງເຊັ່ນ: top , ໃນ Ubuntu ຫຼື macOS. ສໍາລັບ Windows, ພິຈາລະນາໃຊ້ Linux Subsystem, ດັ່ງນັ້ນທ່ານສາມາດໃຊ້ top ໃນ Ubuntu.

ສໍາລັບຈຸດປະສົງຂອງບົດຮຽນນີ້, ພວກເຮົາຈະວັດແທກການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາ. Semalt ເບິ່ງວ່າຈໍານວນຫນ່ວຍຄວາມຈໍາຖືກນໍາໃຊ້ໃນອັກສອນ "ແບບດັ້ງເດີມ". Semalt ປະຕິບັດຄູ່ຍຸດທະສາດການເພີ່ມປະສິດທິພາບແລະວັດແທກຜູ້ທີ່ເກີນໄປ. ໃນທີ່ສຸດ, ຂ້າພະເຈົ້າຢາກໃຫ້ທ່ານສາມາດສ້າງທາງເລືອກທີ່ມີການສຶກສາ.

ວິທີທີ່ພວກເຮົາຈະໃຊ້ເພື່ອເບິ່ງວ່າຈໍານວນຫນ່ວຍຄວາມຈໍາຖືກນໍາໃຊ້ຄື:

  // formatBytes ຖືກໃຊ້ຈາກ php net documentationmemory_get_peak_usage   format functionBytes ($ bytes, precision = 2) {$ units = array ("b", "kb", "mb", "gb", "tb")$ bytes = max ($ bytes, 0)$ pow = floor (($ bytes? log ($ bytes): 0) / log (1024))$ pow = min ($ pow, count ($ units) - 1)$ bytes / = (1 << (10 * $ pow))return round ($ bytes, precision $) "". $ units [$ pow]}   

ການປະຕິບັດການນໍາໃຊ້ເຫຼົ່ານີ້ຢູ່ໃນຕອນທ້າຍຂອງສະຄິບຂອງພວກເຮົາ, ດັ່ງນັ້ນພວກເຮົາສາມາດເບິ່ງ script ທີ່ໃຊ້ຫນ່ວຍຄວາມຈໍາຫຼາຍທີ່ສຸດໃນເວລາດຽວ.

ແມ່ນຫຍັງຄືຕົວເລືອກຂອງພວກເຮົາ?

Semalt ມີຫລາຍວິທີທີ່ພວກເຮົາສາມາດໃຊ້ໃນການອ່ານໄຟລ໌ທີ່ມີປະສິດທິພາບ. ແຕ່ຍັງມີສອງສະຖານະການທີ່ພວກເຮົາສາມາດນໍາໃຊ້ໄດ້. ພວກເຮົາອາດຕ້ອງການອ່ານແລະປຸງແຕ່ງຂໍ້ມູນທັງຫມົດໃນເວລາດຽວກັນ, ສົ່ງອອກຂໍ້ມູນການປຸງແຕ່ງຫຼືປະຕິບັດການປະຕິບັດອື່ນໆໂດຍອີງໃສ່ສິ່ງທີ່ພວກເຮົາໄດ້ອ່ານ. ພວກເຮົາກໍ່ສາມາດຕ້ອງການປ່ຽນສາຍນ້ໍາຂອງຂໍ້ມູນໂດຍບໍ່ຈໍາເປັນຕ້ອງເຂົ້າເຖິງຂໍ້ມູນ.

ຈົ່ງ imagine, ສໍາລັບ scenario ທໍາອິດ, ວ່າພວກເຮົາຕ້ອງການທີ່ຈະສາມາດອ່ານໄຟລ໌ແລະສ້າງວຽກງານການປຸງແຕ່ງທີ່ແຍກຕ່າງຫາກທຸກ 10,000 ເສັ້ນ. Semalt ຈໍາເປັນຕ້ອງເກັບຮັກສາຢ່າງຫນ້ອຍ 10,000 ເສັ້ນໃນຄວາມຊົງຈໍາ, ແລະສົ່ງພວກມັນໄປຫາຜູ້ຈັດການວຽກຈັດອັນດັບແຖວ (ໃດກໍ່ຕາມທີ່ອາດຈະໃຊ້).

ສໍາລັບສະຖານະການທີສອງ, ຈິນຕະນາການວ່າພວກເຮົາຕ້ອງການທີ່ຈະບີບອັດເນື້ອຫາຂອງການຕອບໂຕ້ API ໃຫຍ່ໂດຍສະເພາະ. ພວກເຮົາບໍ່ສົນໃຈສິ່ງທີ່ມັນເວົ້າ, ແຕ່ພວກເຮົາຈໍາເປັນຕ້ອງໃຫ້ແນ່ໃຈວ່າມັນຖືກສະຫນັບສະຫນູນໃນຮູບແບບທີ່ຖືກບີບອັດ. ໃນຄັ້ງທໍາອິດ, ພວກເຮົາຈໍາເປັນຕ້ອງຮູ້ວ່າຂໍ້ມູນແມ່ນຫຍັງ. ໃນຄັ້ງທີສອງ, ພວກເຮົາບໍ່ກັງວົນວ່າຂໍ້ມູນແມ່ນຫຍັງ. Semalt ຄົ້ນຫາທາງເລືອກເຫຼົ່ານີ້ .

ການອ່ານໄຟລ໌, ສາຍໂດຍເສັ້ນ

ມີຫຼາຍຫນ້າທີ່ເຮັດວຽກຮ່ວມກັບໄຟລ໌. Semalt ລວມສອງສາມເຂົ້າໄປໃນຜູ້ອ່ານໄຟລ໌ທີ່ບໍ່ຖືກຕ້ອງ:

  // ຈາກຄວາມຊົງຈໍາ. phpformat functionBytes ($ bytes, precision = 2) {$ units = array ("b", "kb", "mb", "gb", "tb")$ bytes = max ($ bytes, 0)$ pow = floor (($ bytes? log ($ bytes): 0) / log (1024))$ pow = min ($ pow, count ($ units) - 1)$ bytes / = (1 << (10 * $ pow))return round ($ bytes, precision $) "". $ units [$ pow]}print formatBytes (memory_get_peak_usage   )   
  // ຈາກ read-files-line-by-line-1. phpfunction readTheFile ($ path) {$ lines = []$ handle = fopen ($ path, "r")ໃນຂະນະທີ່ (! feof ($ handle)) {$ lines [] = trim (fgets ($ handle))}fclose ($ handle)return $ lines}readTheFile ("shakespeare txt");ຕ້ອງການ "ຄວາມຈໍາ php";   

ພວກເຮົາກໍາລັງອ່ານໄຟລ໌ຂໍ້ຄວາມທີ່ມີການເຮັດວຽກສົມບູນຂອງ Shakespeare. ແຟ້ມຂໍ້ມູນແມ່ນກ່ຽວກັບ 5. 5MB , ແລະການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາສູງສຸດແມ່ນ 12 8MB . ຕອນນີ້, ໃຫ້ໃຊ້ເຄື່ອງກໍາເນີດໄຟຟ້າເພື່ອອ່ານເສັ້ນແຕ່ລະ:

  // ຈາກການອ່ານໄຟລ໌ - ເສັ້ນໂດຍເສັ້ນ 2. phpfunction readTheFile ($ path) {$ handle = fopen ($ path, "r")ໃນຂະນະທີ່ (! feof ($ handle)) {trim trim (fgets ($ handle));}fclose ($ handle)}readTheFile ("shakespeare txt");ຕ້ອງການ "ຄວາມຈໍາ php";   

ໄຟລ໌ຂໍ້ຄວາມແມ່ນຂະຫນາດດຽວກັນ, ແຕ່ການໃຊ້ຫນ່ວຍຄວາມຈໍາສູງສຸດແມ່ນ 393KB . ນີ້ບໍ່ຫມາຍຄວາມວ່າພວກເຮົາຈະເຮັດຫຍັງກັບຂໍ້ມູນທີ່ພວກເຮົາກໍາລັງອ່ານ. ບາງທີພວກເຮົາສາມາດແບ່ງປັນເອກະສານອອກເປັນຕູນເມື່ອໃດພວກເຮົາເຫັນສອງເສັ້ນຫວ່າງ. ບາງສິ່ງບາງຢ່າງເຊັ່ນ:

  // ຈາກການອ່ານໄຟລ໌ - ເສັ້ນໂດຍເສັ້ນ - 3. php$ iterator = readTheFile ("shakespeare txt")$ buffer = ""foreach ($ iterator ເປັນ $ iteration) {preg_match ("/ \ n {3} /", $ buffer, $ matches)ຖ້າ (count ($ matches)) {ພິມ "".$ buffer = ""} else {$ buffer. = $ iteration. PHP_EOL}}ຕ້ອງການ "ຄວາມຈໍາ php";   

ຄາດເດົາວ່າພວກເຮົາກໍາລັງໃຊ້ຫນ່ວຍຄວາມຈໍາຫຼາຍເທົ່າໃດແລ້ວ? ມັນແປກໃຈທີ່ທ່ານຮູ້ວ່າ, ເຖິງແມ່ນວ່າພວກເຮົາແບ່ງປັນເອກະສານຂໍ້ຄວາມເຂົ້າໄປໃນ 1,216 ສຽງ, ພວກເຮົາຍັງໃຊ້ພຽງແຕ່ 459KB ຂອງຄວາມຊົງຈໍາ? ເນື່ອງຈາກລັກສະນະຂອງເຄື່ອງກໍາເນີດໄຟຟ້າ, ຄວາມຊົງຈໍາທີ່ສຸດທີ່ພວກເຮົາຈະໃຊ້ແມ່ນສິ່ງທີ່ພວກເຮົາຈໍາເປັນຕ້ອງເກັບຮັກສາຂໍ້ຄວາມທີ່ໃຫຍ່ທີ່ສຸດໃນການເລົ່າເລື່ອງ. ໃນກໍລະນີນີ້, ສ່ວນໃຫຍ່ແມ່ນ 101,985 ຕົວອັກສອນ.

ຂ້າພະເຈົ້າໄດ້ລາຍລັກອັກສອນແລ້ວກ່ຽວກັບການເພີ່ມປະສິດທິພາບຂອງການໃຊ້ເຄື່ອງກໍາເນີດໄຟຟ້າແລະຫ້ອງສະຫມຸດ Semalt Nikita Popov, ດັ່ງນັ້ນກວດເບິ່ງວ່າທ່ານຕ້ອງການເບິ່ງເພີ່ມເຕີມ!

Semalt ມີການນໍາໃຊ້ອື່ນໆ, ແຕ່ນີ້ແມ່ນສະແດງໃຫ້ເຫັນດີສໍາລັບການອ່ານທີ່ມີປະສິດຕິພາບຂອງໄຟລ໌ຂະຫນາດໃຫຍ່. ຖ້າພວກເຮົາຈໍາເປັນຕ້ອງເຮັດວຽກກ່ຽວກັບຂໍ້ມູນ, ຜູ້ຜະລິດອາດຈະເປັນວິທີທີ່ດີທີ່ສຸດ.

Piping ລະຫວ່າງໄຟລ໌

ໃນສະຖານະການທີ່ພວກເຮົາບໍ່ຈໍາເປັນຕ້ອງດໍາເນີນການກ່ຽວກັບຂໍ້ມູນ, ພວກເຮົາສາມາດຜ່ານຂໍ້ມູນໄຟລ໌ຈາກໄຟລ໌ຫນຶ່ງໄປອີກ. ນີ້ແມ່ນທ່ີເອີ້ນກັນທົ່ວໄປ ທໍ່ (ອາດຈະເປັນເພາະວ່າພວກເຮົາບໍ່ເຫັນສິ່ງທີ່ຢູ່ໃນທໍ່ແຕ່ເວລາແຕ່ລະປາຍ .ມັນເປັນໄປບໍ່ໄດ້ແນ່ນອນ!). ພວກເຮົາສາມາດບັນລຸນີ້ໄດ້ໂດຍໃຊ້ວິທີການນ້ໍາ. ທໍາອິດໃຫ້ຂຽນສະຄິບທີ່ຈະໂອນໄຟລ໌ຫນຶ່ງໄປອີກ, ດັ່ງນັ້ນພວກເຮົາສາມາດວັດແທກການໃຊ້ຫນ່ວຍຄວາມຈໍາ:

  // ຈາກເສັ້ນທາງທໍ່ - ໄຟລ໌ 1. phpfile_put_contents ("piping-files-1 .txt", file_get_contents ("shakespeare .txt"))ຕ້ອງການ "ຄວາມຈໍາ php";   

ບໍ່ແປກໃຈ, ສະຄິບນີ້ໃຊ້ຫນ່ວຍຄວາມຈໍາເລັກນ້ອຍທີ່ຈະດໍາເນີນການກ່ວາໄຟລ໌ທີ່ມັນສໍາເນົາ. Semalt ເນື່ອງຈາກວ່າມັນມີການອ່ານ (ແລະເກັບຮັກສາ) ເນື້ອຫາຂອງໄຟໃນຫນ່ວຍຄວາມຈໍາຈົນກ່ວາມັນໄດ້ລາຍລັກອັກສອນກັບໄຟລ໌ໃຫມ່. ສໍາລັບໄຟລ໌ຂະຫນາດນ້ອຍ, ທີ່ອາດຈະດີ. ເມື່ອພວກເຮົາເລີ່ມໃຊ້ໄຟລ໌ຂະຫນາດໃຫຍ່, ບໍ່ມີຫຍັງຫຼາຍ .

Semalt ລອງນ້ໍາ (ຫຼືທໍ່) ຈາກໄຟລ໌ຫນຶ່ງໄປອີກ:

  // ຈາກ piping-files-2. txt "," r ")$ handle2 = fopen ("piping-files-2 .txt", "w");stream_copy_to_stream ($ handle1, $ handle2)fclose ($ handle1)fclose ($ handle2)ຕ້ອງການ "ຄວາມຈໍາ php";   

ລະຫັດນີ້ມີຄວາມແຕກຕ່າງເລັກນ້ອຍ. ພວກເຮົາເປີດມືໃສ່ທັງສອງໄຟລ໌, ຄັ້ງທໍາອິດໃນໂຫມດອ່ານແລະທີສອງໃນໂຫມດການຂຽນ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາສໍາເນົາຈາກຄັ້ງທໍາອິດເຂົ້າໃນທີສອງ. ພວກເຮົາສໍາເລັດໂດຍປິດໄຟລ໌ທັງສອງຄັ້ງອີກເທື່ອຫນຶ່ງ. ມັນອາດຈະແປກໃຈວ່າທ່ານຮູ້ວ່າຫນ່ວຍຄວາມຈໍາທີ່ໃຊ້ແມ່ນ 393KB .

ທີ່ເບິ່ງຄືວ່າຄຸ້ນເຄີຍ. ບໍ່ແມ່ນສິ່ງທີ່ລະຫັດຜູ້ຜະລິດໃຊ້ໃນການເກັບຮັກສາໃນເວລາທີ່ອ່ານແຕ່ລະບັນທັດ? ນັ້ນແມ່ນຍ້ອນວ່າການໂຕ້ຖຽງທີ່ສອງ fgets ກໍານົດວິທີການຈໍານວນ bytes ຂອງແຕ່ລະເສັ້ນທີ່ຈະອ່ານ (ແລະ defaults ກັບ -1 ຫຼືຈົນຮອດເສັ້ນໃຫມ່).

ການໂຕ້ຖຽງທີສາມກັບ stream_copy_to_stream ແມ່ນແທ້ໆປະເພດດຽວກັນຂອງພາລາມິເຕີ (ມີແທ້ຢ່າງດຽວກັນ). stream_copy_to_stream ແມ່ນການອ່ານຈາກເສັ້ນຫນຶ່ງ, ເສັ້ນຫນຶ່ງໃນເວລາຫນຶ່ງ, ແລະຂຽນມັນໄປຍັງສາຍອື່ນ. ມັນຂ້າມພາກສ່ວນບ່ອນທີ່ເຄື່ອງກໍາເນີດໄຟຟ້າໃຫ້ຜົນຜະລິດ, ເພາະວ່າພວກເຮົາບໍ່ຈໍາເປັນຕ້ອງເຮັດວຽກກັບມູນຄ່ານັ້ນ.

ການຂຽນຂໍ້ຄວາມນີ້ບໍ່ເປັນປະໂຫຍດຕໍ່ພວກເຮົາ, ດັ່ງນັ້ນຈິ່ງຄິດເຖິງຕົວຢ່າງອື່ນໆທີ່ອາດຈະເປັນ. Semalt ພວກເຮົາຕ້ອງການທີ່ຈະຜະລິດຮູບພາບຈາກ CDN ຂອງພວກເຮົາ, ເປັນເສັ້ນທາງການນໍາໃຊ້ທີ່ຖືກໂອນ. ພວກເຮົາສາມາດສະແດງໃຫ້ເຫັນດ້ວຍລະຫັດທີ່ຄ້າຍກັບຕໍ່ໄປນີ້:

  // ຈາກ piping-files-3. phpfile_put_contents ("piping-files-3 jpeg", file_get_contents ("https: // github com / assertchris / uploads / raw / master / rick jpg"))// ທີ່ຢູ່ ທີ່ຢູ່ ຫຼືຂຽນນີ້ກົງກັບ stdout, ຖ້າພວກເຮົາບໍ່ຕ້ອງການຂໍ້ມູນຄວາມຈໍາຕ້ອງການ "ຄວາມຈໍາ php";   

ຈິນຕະນາການເສັ້ນທາງຄໍາຮ້ອງສະຫມັກນໍາພວກເຮົາໄປສູ່ລະຫັດນີ້. ແຕ່ແທນທີ່ຈະຮັບເອົາໄຟລ໌ຈາກລະບົບໄຟລ໌ໃນທ້ອງຖິ່ນ, ພວກເຮົາຕ້ອງການທີ່ຈະໄດ້ຮັບມັນຈາກ CDN. ພວກເຮົາອາດຈະປ່ຽນແທນ file_get_contents ສໍາລັບບາງສິ່ງບາງຢ່າງທີ່ສວຍງາມ (ເຊັ່ນ: Guzzle), ແຕ່ພາຍໃຕ້ການດູດຊັບມັນກໍ່ຄືກັນ.

ການໃຊ້ຫນ່ວຍຄວາມຈໍາ (ສໍາລັບຮູບພາບນີ້) ປະມານ 581KB . ໃນປັດຈຸບັນ, ແນວໃດກ່ຽວກັບພວກເຮົາພະຍາຍາມທີ່ຈະນ້ໍານີ້ແທນ?

  // ຈາກທໍ່ສົ່ງໄຟ -4. php$ handle1 = fopen ("https: // github com / assertchris / uploads / raw / master / rick jpg", "r")$ handle2 = fopen ("piping-files-4 jpeg", "w")// ທີ່ຢູ່ ທີ່ຢູ່ ຫຼືຂຽນນີ້ກົງກັບ stdout, ຖ້າພວກເຮົາບໍ່ຕ້ອງການຂໍ້ມູນຄວາມຈໍາstream_copy_to_stream ($ handle1, $ handle2)fclose ($ handle1)fclose ($ handle2)ຕ້ອງການ "ຄວາມຈໍາ php";   

ການໃຊ້ຫນ່ວຍຄວາມຈໍາເລັກນ້ອຍ (ຢູ່ທີ່ 400KB ), ແຕ່ຜົນໄດ້ຜົນຄືກັນ. ຖ້າພວກເຮົາບໍ່ຈໍາເປັນຕ້ອງມີຂໍ້ມູນກ່ຽວກັບຄວາມຈໍາ, ພວກເຮົາກໍ່ສາມາດພິມເປັນ output ມາດຕະຖານ. ໃນຄວາມເປັນຈິງ, PHP ສະຫນອງວິທີທີ່ງ່າຍດາຍທີ່ຈະເຮັດສິ່ງນີ້:

  $ handle1 = fopen ("https: // github com / assertchris / uploads / raw / master / rick jpg", "r")$ handle2 = fopen ("php: // stdout", "w")stream_copy_to_stream ($ handle1, $ handle2)fclose ($ handle1)fclose ($ handle2)// ຕ້ອງການ "memory php"   

ນ້ໍາອື່ນ ໆ

Semalt ແມ່ນເສັ້ນທາງອື່ນໆທີ່ພວກເຮົາສາມາດທໍ່ແລະ / ຫຼືຂຽນແລະ / ຫຼືອ່ານຈາກ:

  • php: // stdin (ອ່ານເທົ່ານັ້ນ)
  • php: // stderr (ຂຽນເທົ່ານັ້ນ, ເຊັ່ນ php: // stdout)
  • php: // input (ອ່ານ - ພຽງແຕ່) ເຊິ່ງສາມາດໃຫ້ພວກເຮົາເຂົ້າເຖິງຮ່າງກາຍທີ່ຮ້ອງຂໍວັດຖຸດິບ
  • php: // output (write-only) ເຊິ່ງຊ່ວຍໃຫ້ພວກເຮົາຂຽນເຂົ້າໄປໃນ buffer output
  • php: // memory ແລະ php: // temp (ອ່ານ - ຂຽນ) ແມ່ນບ່ອນທີ່ພວກເຮົາສາມາດເກັບຂໍ້ມູນເປັນຂໍ້ມູນຊົ່ວຄາວ. ຄວາມແຕກຕ່າງກັນແມ່ນວ່າ php: // temp ຈະເກັບຂໍ້ມູນໃນລະບົບໄຟລ໌ເມື່ອມັນຂະຫຍາຍຕົວຂະຫນາດໃຫຍ່, ຂະນະທີ່ php: // memory ຈະເກັບຮັກສາໄວ້ໃນຫນ່ວຍຄວາມຈໍາຈົນກ່ວາທີ່ຫມົດແລ້ວ ທີ່ຢູ່

ກອງ

ມີ trick ອື່ນທີ່ພວກເຮົາສາມາດນໍາໃຊ້ກັບສາຍທີ່ເອີ້ນວ່າ ຕົວກອງ . ພວກເຂົາເຈົ້າເປັນປະເພດຂອງຂັ້ນຕອນໃນລະຫວ່າງການ, ສະຫນອງການຄວບຄຸມເລັກນ້ອຍກ່ຽວກັບຂໍ້ມູນນ້ໍາໂດຍບໍ່ມີການເປີດເຜີຍໃຫ້ພວກເຮົາ. ຈິນຕະນາການພວກເຮົາຕ້ອງການທີ່ຈະເຮັດໃຫ້ເຂັ້ມແຂງ shakespeare ຂອງພວກເຮົາ. txt . php$ zip = new ZipArchive $ filename = "filters-1 zip";$ zip-> open ($ filename, ZipArchive :: CREATE)$ zip-> addFromString ("shakespeare txt", file_get_contents ("shakespeare txt"))$ zip-> close ຕ້ອງການ "ຄວາມຈໍາ php";

ນີ້ແມ່ນລະຫັດດີ, ແຕ່ມັນໂມງຢູ່ປະມານ 10. 75MB . ພວກເຮົາສາມາດເຮັດໄດ້ດີກວ່າ, ມີຕົວກອງ:

  // ຈາກຕົວກອງ -2. php$ handle1 = fopen ("php: // filter / zlib deflate / resource = shakespeare txt", "r")$ handle2 = fopen ("ການກັ່ນຕອງ -2. deflated", "w")stream_copy_to_stream ($ handle1, $ handle2)fclose ($ handle1)fclose ($ handle2)ຕ້ອງການ "ຄວາມຈໍາ php";   

ນີ້, ພວກເຮົາສາມາດເບິ່ງ php: // filter / zlib. deflate filter, ເຊິ່ງອ່ານແລະ compresses ເນື້ອໃນຂອງຊັບພະຍາກອນ. ຫຼັງຈາກນັ້ນພວກເຮົາສາມາດທໍ່ຂໍ້ມູນທີ່ຖືກບີບອັດເຂົ້າໄປໃນໄຟລ໌ອື່ນ. ນີ້ໃຊ້ພຽງແຕ່ 896KB .

ຂ້າພະເຈົ້າຮູ້ວ່ານີ້ບໍ່ແມ່ນຮູບແບບດຽວກັນ, ຫຼືວ່າມີຄວາມຂັດແຍ່ງກັນໃນການສ້າງຮວບຮວມ zip. ທ່ານຕ້ອງສົງໃສວ່າ: ຖ້າທ່ານສາມາດເລືອກເອົາຮູບແບບທີ່ແຕກຕ່າງກັນແລະປະຫຍັດເວລາ 12 ເທື່ອ, ທ່ານຈະບໍ່?

ເພື່ອ uncompress ຂໍ້ມູນ, ພວກເຮົາສາມາດ run ໄຟລ໌ deflated ກັບຄືນໄປບ່ອນໂດຍຜ່ານຕົວກໍານົດການ zlib ອື່ນ:

  // ຈາກຕົວກອງ -2. phpfile_get_contents ("php: // filter / zlib inflate / resource = filters-2 deflated")   

Streams ໄດ້ກວມເອົາຢ່າງກວ້າງຂວາງໃນ "ຄວາມເຂົ້າໃຈໃນ Streams ໃນ PHP" ແລະ "ການໃຊ້ PHP Streams Semalt". ຖ້າທ່ານຕ້ອງການທັດສະນະທີ່ແຕກຕ່າງກັນ, ໃຫ້ກວດເບິ່ງຜູ້ທີ່ອອກມາ!

Customizing Streams

fopen ແລະ file_get_contents ມີຊຸດຕົວເລືອກຕົວເລືອກຂອງຕົນເອງ, ແຕ່ເຫຼົ່ານີ້ແມ່ນສາມາດປັບແຕ່ງໄດ້ຢ່າງສົມບູນ. ເພື່ອກໍານົດພວກມັນ, ພວກເຮົາຈໍາເປັນຕ້ອງສ້າງສະພາບການໃຫມ່:

  // ຈາກການສ້າງສະພາບ - 1. php$ data = join ("&", ["twitter = assertchris",])$ headers = join ("\ r \ n", ["ປະເພດເນື້ອຫາ: ຄໍາຮ້ອງສະຫມັກ / x-www-form-urlencoded","ຄວາມຍາວຂອງເນື້ອຫາ:". strlen ($ data),])$ options = ["http" => ["method" => "POST","header" => $ headers,"ເນື້ອຫາ" => ຂໍ້ມູນ $,],]$ context = stream_content_create ($ options)$ handle = fopen ("https: // example com / register", "r", false, $ context)$ response = stream_get_contents ($ handle)fclose ($ handle)   

ໃນຕົວຢ່າງນີ້, ພວກເຮົາກໍາລັງພະຍາຍາມເຮັດ POST ຂໍໃຫ້ API. ຈຸດປາຍ API ແມ່ນປອດໄພ, ແຕ່ພວກເຮົາຍັງຈໍາເປັນຕ້ອງໃຊ້ຄຸນສົມບັດ context http (ໃຊ້ສໍາລັບ http ແລະ https ). ພວກເຮົາກໍານົດ headers ບາງແລະເປີດຕົວຈັດການໄຟລ໌ API. ພວກເຮົາສາມາດເປີດ handle ໄດ້ເປັນ read-only ເນື່ອງຈາກສະພາບການເບິ່ງແລການຂຽນ.

Semalt ແມ່ນສິ່ງທີ່ພວກເຮົາສາມາດປັບແຕ່ງໄດ້, ສະນັ້ນມັນດີທີ່ສຸດເພື່ອກວດສອບເອກະສານຖ້າທ່ານຕ້ອງການຮູ້ເພີ່ມເຕີມ.

ການເຮັດໂປຣແກຣມແລະການກັ່ນຕອງລູກຄ້າ

Semalt ພວກເຮົາຫໍ່ສິ່ງທີ່ຂຶ້ນ, ໃຫ້ເວົ້າກ່ຽວກັບການເຮັດໂປຣແກຣມທີ່ກໍາຫນົດເອງ. Semalt ມີຫຼາຍວຽກທີ່ຕ້ອງເຮັດ. ແຕ່ເມື່ອເຮັດວຽກແລ້ວ, ພວກເຮົາສາມາດລົງທະບຽນເຄື່ອງບິນຂອງພວກເຮົາໄດ້ຢ່າງງ່າຍດາຍ:

  ຖ້າ (in_array ("highlight-names", stream_get_wrappers   )) {stream_wrapper_unregister ("highlight-names");}stream_wrapper_register ("highlight-names", "HighlightNamesProtocol");$ highlighted = file_get_contents ("highlight-names: // story .txt");   

Semalt, ມັນກໍ່ເປັນໄປໄດ້ທີ່ຈະສ້າງຕົວກໍານົດການນ້ໍາ custom. ເອກະສານທີ່ມີຫຼັກສູດການກັ່ນຕອງຕົວຢ່າງ:

  ກອງ {public $ filternamepublic $ paramspublic filter (resource $ in, resource out $ int & $ consumed,bool $ ປິດ)public void onClose (void)public bool onCreate (void)}   

ນີ້ສາມາດຈົດທະບຽນໄດ້ງ່າຍດາຍ:

  $ handle = fopen ("story txt", "w +")stream_filter_append ($ handle, "highlight-names", STREAM_FILTER_READ);   

ຈຸດເດັ່ນ ຕ້ອງສອດຄ່ອງກັບຄຸນລັກສະນະ filtername ຂອງຊັ້ນການກັ່ນຕອງໃຫມ່. ມັນຍັງສາມາດນໍາໃຊ້ການກັ່ນຕອງທີ່ກໍານົດໄວ້ໃນ php: // filter / highligh-names / resource = story. txt string ມັນງ່າຍຫຼາຍທີ່ຈະກໍານົດການກັ່ນຕອງຫຼາຍກ່ວາມັນກໍານົດໂປຣແກຣມ. ຫນຶ່ງໃນເຫດຜົນສໍາລັບການນີ້ແມ່ນວ່າໂປໂຕຄອນຈໍາເປັນຕ້ອງຈັດການການດໍາເນີນງານລະບົບ, ໃນຂະນະທີ່ການກັ່ນຕອງພຽງແຕ່ຕ້ອງການຈັດການຂໍ້ມູນແຕ່ລະຂໍ້.

ຖ້າທ່ານມີ gumption, ຂ້ອຍຂໍແນະນໍາໃຫ້ທ່ານທົດລອງສ້າງໂປຣແກຣມແລະຕົວກອງທີ່ກໍາຫນົດເອງ. ຖ້າທ່ານສາມາດນໍາໃຊ້ການກັ່ນຕອງກັບການດໍາເນີນງານ stream_copy_to_stream , ແອັບພລິເຄຊັນຂອງທ່ານຈະນໍາໃຊ້ຕໍ່ໄປບໍ່ມີຫນ່ວຍຄວາມຈໍາແມ້ຈະເຮັດວຽກກັບໄຟລ໌ຂະຫນາດໃຫຍ່. ຈິນຕະນາການຂຽນຕົວກອງ Filter ຮູບພາບຂະຫນາດໃຫຍ່ ແລະ ສໍາລັບການເຂົ້າລະຫັດລັບ .

ສະຫຼຸບ

Semalt ນີ້ບໍ່ແມ່ນບັນຫາທີ່ພວກເຮົາມັກຈະທົນທຸກ, ມັນງ່າຍທີ່ຈະລັງກິນອາຫານໃນເວລາທີ່ເຮັດວຽກຮ່ວມກັບໄຟລ໌ຂະຫນາດໃຫຍ່. ໃນຄໍາຮ້ອງສະຫມັກທີ່ບໍ່ຖືກຕ້ອງ, ມັນງ່າຍທີ່ຈະເຮັດໃຫ້ເຄື່ອງແມ່ຂ່າຍທັງຫມົດຫຼຸດລົງເມື່ອພວກເຮົາບໍ່ລະມັດລະວັງກ່ຽວກັບການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາ.

ຄໍາແນະນໍານີ້ໄດ້ສະເຫນີໃຫ້ທ່ານຄິດເຖິງຄວາມຄິດໃຫມ່ໃຫມ່ (ຫຼືປັບປຸງຄວາມຊົງຈໍາຂອງທ່ານກ່ຽວກັບພວກມັນ), ດັ່ງນັ້ນທ່ານສາມາດຄິດກ່ຽວກັບວິທີການອ່ານແລະຂຽນໄຟລ໌ທີ່ມີປະສິດທິພາບ. ໃນເວລາທີ່ພວກເຮົາເລີ່ມມີຄວາມຄຸ້ນເຄີຍກັບສາຍນ້ໍາແລະເຄື່ອງກໍາເນີດໄຟຟ້າແລະຢຸດການນໍາໃຊ້ຫນ້າທີ່ເຊັ່ນ file_get_contents : ປະເພດຂໍ້ຜິດພາດທັງຫມົດຫາຍໄປຈາກຄໍາຮ້ອງສະຫມັກຂອງພວກເຮົາ. ວ່າເບິ່ງຄືວ່າເປັນສິ່ງທີ່ດີທີ່ຈະມຸ່ງຫມາຍສໍາລັບ!

March 1, 2018