Kapag nagtatrabaho sa maliit na halaga ng data sa PHP, mas madaling iimbak ang mga ito sa mga file kaysa lumikha ng isang database at ayusin ang pakikipag-ugnay ng mga script dito. Sa ganitong mga kaso, ang gawain ng pagtanggal ng mga tinukoy na linya mula sa isang text file ay hindi bihira. Tingnan natin nang mas malapit ang pinakasimpleng posibleng paraan upang magawa ito.
Kailangan
Pangunahing kaalaman sa PHP
Panuto
Hakbang 1
Paunang data:
- mayroon kaming isang text file na allStrings.txt, na naglalaman ng isang bilang ng mga linya ng data
- kinakailangan upang tanggalin ang linya No. 44 mula sa file
Ang algorithm para sa paglutas ng problema ay ang mga sumusunod: kailangan mong buksan ang file, basahin ang mga linya na nakapaloob dito sa isang hanay ng mga string at patungan ang umiiral na file sa mga nilalaman ng array, laktawan ang linya na inilaan upang matanggal.
Hakbang 2
Upang maipatupad ang algorithm na ito sa script, nagtatalaga muna kami ng mga halaga sa mga variable na maglalaman ng pangalan ng pinagmulang file at ang bilang ng linya na tatanggalin: $ fileName = "allStrings.txt";
$ lineToKill = 44; Pagkatapos ay basahin natin ang file sa isang hanay ng mga string: $ stringsArray = file ($ fileName); Suriin natin kung naglalaman ang file ng linya na kailangan natin. Ang lahat ng karagdagang code ay naisasagawa lamang kung ang kundisyon na $ lineToKill ay hindi hihigit sa bilang ng mga linya sa $ stringsArray array: kung ($ lineToKill <= count ($ stringsArray)) {
// ito ang magiging pangunahing loop ng programa
} Kung hindi nakamit ang kundisyon, wala kaming tatanggalin. Hayaan ang script na mag-print ng isang mensahe ng impormasyon tungkol dito: kung hindi ay i-echo ang "Ang bilang ng mga linya sa file ay mas mababa sa". $ LineToKill. "!"; Kung nakamit ang kundisyon, dapat mong i-clear ang pinagmulang file para sa isang bagong entry: $ fileHandle = fopen ($ fileName, "w"); Ngayon ay dapat naming ayusin ang isang loop na umuulit sa lahat ng mga elemento ng string array. Ngunit dahil ang pag-index ng array ay nagsisimula mula sa zero, at binibilang namin ang numero ng linya para sa pagtanggal mula sa isa, pagkatapos bago pa magsimula ang loop ay babawasan namin ang halaga ng $ lineToKill ng isa, upang hindi maulit ang operasyon na ito sa bawat hakbang: $ lineToKill -; Upang ayusin ang isang loop: unahan ($ stringsArray bilang $ key => $ halaga) {
// narito ang code ng bawat hakbang ng loop
} Ang variable na $ key ay maglalaman ng index ng kasalukuyang linya sa array, at ang variable na $ halaga ay maglalaman ng halaga ng linyang ito. Sa bawat hakbang ng loop, ihinahambing namin ang index ng linya sa array na may numero na tatanggalin, at kung hindi ito tumutugma, isusulat namin ang halaga ng linyang ito sa file: kung ($ key! = $ LineToKill) fwrite ($ fileHandle, $ halaga); kung magkatugma sila, kung gayon hindi kami susulat sa file, ngunit magpi-print ng isang mensahe tungkol sa matagumpay na pagtanggal: kung hindi ay i-echo ang "Line". $ LineToKill. "Tinanggal."; At sa pagtatapos ng siklo, kapag ang pagsusulat sa file ay tapos na, dapat mo itong magalang isara ito: fclose ($ fileHandle);
Hakbang 3
Magiging ganito ang kumpletong code: <? Php $ fileName = "allStrings.txt";
$ lineToKill = 44; $ stringsArray = file ($ fileName);
kung ($ lineToKill <= count ($ stringsArray)) {
$ fileHandle = fopen ($ fileName, "w");
$ lineToKill--;
paunahan ($ stringsArray bilang $ key => $ halaga) {
kung ($ key! = $ lineToKill) fwrite ($ fileHandle, $ halaga);
kung hindi man echo ang "Line". $ lineToKill. "tinanggal.";
}
fclose ($ fileHandle);
}?> Siyempre, ito ang pinakasimpleng code, kung saan walang proteksyon laban sa lahat ng mga komplikasyon na maaaring mangyari sa panahon ng gawain ng script sa totoong mga kundisyon. Halimbawa, kung ang isang file ay naglalaman ng isang malaking bilang ng mga linya, pagkatapos ay ang pagbabasa ng mga ito sa isang array ay kakagat ng isang tipak na hindi mapipintasan na malaki para sa isang script mula sa mga mapagkukunan ng server. Siyempre, ang pagtatrabaho kasama ang maraming halaga ng data ay dapat na ayusin sa pamamagitan ng mga database, hindi mga file ng teksto. Ngunit pa rin, bilang isang halimbawa ng pang-edukasyon, magbibigay kami ng isang code na malulutas din ang problemang ito. Narito ang algorithm ay naiiba mula sa nakaraang isa: upang hindi maiimbak ang isang malaking bilang ng mga linya sa array, basahin ng script mula sa pinagmulang file ang isang linya nang paisa-isa at isulat ang mga ito isa-isa sa pansamantalang file. Sa pagtatapos ng prosesong ito, tatanggalin ang orihinal na file, at ililipat ang pansamantalang file sa lugar nito.
Hakbang 4
Magsisimula ang script na ito sa parehong paraan tulad ng naunang isa:
$ fileName = "allStrings.txt";
$ lineToKill = 44;
Pagkatapos ay kailangan mong lumikha ng isang pansamantalang file upang gumana. Gawin natin ito sa folder na "tmp" at ibigay ang parehong preview sa pansamantalang file: $ tempFile = tempnam ("/ tmp", "tmp"); Subukan nating buksan ang pinagmulan ng file para sa pagbabasa: kung ($ fileHandle = @fopen ($ fileName, "rb")) {
// ang code na ito ay papatayin sa kaso ng normal na pagbubukas ng source file
} Kung nabigo ito - ang karagdagang gawain ng script ay walang katuturan, pinapatay namin ang proseso sa pagbibigay ng kaukulang mensahe: kung hindi man mamatay ("Ang file ng mapagkukunan ay hindi umiiral!"); Kung ang file ay binuksan nang normal, pagkatapos ay ay mag-print ng isang abiso tungkol dito at susubukan na buksan ang dati nang nilikha pansamantalang file na may kaukulang mensahe: echo "May pinagmulan ng file";
kung ($ tempHandle = fopen ($ tempFile, "w")) echo "Ang isang pansamantalang file ay nilikha."; Ngayon na upang simulan ang isang loop ng mga linya ng pagbabasa mula sa pinagmulang file, na magpapatuloy hanggang sa maabot nito ang pagtatapos ng ang file: habang (! feof ($ fileHandle)) {
// narito ang magiging code para sa pagtatrabaho sa kasalukuyang linya
} Sa bawat hakbang ng loop, babasahin namin ang isang linya: $ lineToWrite = fgets ($ fileHandle); At kung hindi ito ang linya na tatanggalin, pagkatapos isulat ito sa isang pansamantalang file. Ang line counter $ lineNum ay madaragdag direkta sa operasyon ng paghahambing: kung ($ lineToKill! = (++ $ lineNum)) fwrite ($ tempHandle, $ lineToWrite); Kapag naubos ang mga linya, isara ang file: fclose ($ fileHandle);
fclose ($ tempHandle); Panghuli, palitan ang pangalan ng temp file sa orihinal. Kung matagumpay ang operasyon na ito, maglalabas kami ng kaukulang mensahe: kung (palitan ang pangalan ng ($ tempFile, $ fileName)) ay i-echo ang "Ang linya na $ lineToKill ay tinanggal";
Hakbang 5
Kumpletuhin ang code:
<? php $ fileName = "allStrings.txt";
$ lineToKill = 44; $ tempFile = tempnam ("/ tmp", "tmp");
kung ($ fileHandle = @fopen ($ fileName, "rb")) {
echo "May pinagmulan ng file";
kung ($ tempHandle = fopen ($ tempFile, "w")) echo "Ang pansamantalang file ay nilikha.";
}
kung hindi man ay mamatay ("Walang file na pinagmulan!"); habang (! feof ($ fileHandle)) {
$ lineToWrite = fgets ($ fileHandle);
kung ($ lineToKill! = (++ $ lineNum)) fwrite ($ tempHandle, $ lineToWrite);
} fclose ($ fileHandle);
fclose ($ tempHandle);
kung (palitan ang pangalan ($ tempFile, $ fileName)) echo "Inalis ang linya $ lineToKill";?>
