La prima metà di questo tutorial spiega diversi modi per creare un file zip utilizzando le API CodeIgniter incorporate. Vedremo come creare e salvare file zip sul server e come renderli disponibili per il download anche agli utenti finali.

La seconda metà include una discussione su come decomprimere il file. Per dimostrarlo, costruiremo una pagina personalizzata che consenta agli utenti di caricare file zip che verranno estratti sul server dopo il caricamento del file. Per ottenere la funzionalità desiderata, l'estensione PHP ZipArchive viene in nostro soccorso!

Prima di andare avanti e approfondire lo sviluppo, elencherò i file che svilupperemo nel corso di questo tutorial:

• application / controller / Zip.php: È un file controller che dimostra vari modi in cui è possibile creare un file zip.
• application / controller / Unzip.php: È un file controller che include il codice utilizzato per decomprimere un file caricato dall'utente.
• application / views / file_upload_form.php : È un file di visualizzazione che contiene codice modulo di caricamento file HTML di base piuttosto semplice.
• application / views / file_upload_result.php: È un file di visualizzazione che mostra il risultato di un file caricato dall'utente; fondamentalmente ti dice se il file è stato decompresso con successo.
• application / librerie / Extractor.php: Questo file dimostra il concetto di una libreria personalizzata in CodeIgniter.

Con tutto ciò che è in atto, siamo pronti per passare alla nostra prossima sezione!

Come comprimere i file?

Vai avanti e crea un file application / controller / Zip.php con i seguenti contenuti.

load-> library ( 'zip');  funzione privata _archieve_and_download ($ nomefile) // crea il file zip sul server $ this-> zip-> archive (FCPATH. '/ uploads /'.$ filename); // richiede all'utente di scaricare il file zip $ this-> zip-> download ($ filename);  public function data () $ this -> _ load_zip_lib (); $ this-> zip-> add_data ('name.txt', 'Sajal Soni'); $ this-> zip-> add_data ('profile.txt', 'Web Developer'); $ This -> _ archieve_and_download ( 'my_info.zip');  public function data_array () $ this -> _ load_zip_lib (); $ files = array ('name.txt' => 'Sajal Soni', 'profile.txt' => 'Web Developer'); $ This-> archivio zip> add_data ($ file); $ This -> _ archieve_and_download ( 'my_info.zip');  public function data_with_subdirs () $ this -> _ load_zip_lib (); $ this-> zip-> add_data ('info / name.txt', 'Sajal Soni'); $ this-> zip-> add_data ('info / profile.txt', 'Web Developer'); $ This -> _ archieve_and_download ( 'my_info.zip');  public function files () $ this -> _ load_zip_lib (); // passa il secondo argomento come TRUE se si desidera preservare la struttura dir $ this-> zip-> read_file (FCPATH. '/ uploads / 1.jpg'); $ This-> archivio zip> read_file (FCPATH '/ uploads / 2.jpg'.); $ This -> _ archieve_and_download ( 'images.zip');  public function dir () $ this -> _ load_zip_lib (); // passa il secondo argomento come FALSE se si desidera ignorare le directory precedenti $ this-> zip-> read_dir (FCPATH. '/ uploads / images /'); $ This -> _ archieve_and_download ( 'dir_images.zip'); 

È un file controller piuttosto standard con cui hai già familiarità. Contiene diversi metodi e ognuno di essi mostra un modo diverso per creare un file zip.

Oltre a ciò, fornisce due metodi privati, _load_zip_lib e _archieve_and_download, che vengono chiamati dal resto dei metodi. Naturalmente, non è necessario implementare questi metodi, ma abbiamo appena rifattorizzato il nostro codice in modo da non finire per ripetere lo stesso codice con altri metodi. Iniziamo con questi due metodi.

Ecco qual è il metodo _load_zip_lib sembra.

funzione privata _load_zip_lib () $ this-> load-> library ('zip'); 

Carica la libreria zip integrata nel framework CodeIgniter in modo da poter utilizzare le funzionalità di tale libreria nel resto del codice. Ora puoi accedere alla libreria zip con $ This-> zip convenzione.

Avanti, c'è il _archieve_and_download metodo.

funzione privata _archieve_and_download ($ nomefile) // crea il file zip sul server $ this-> zip-> archive (FCPATH. '/ uploads /'.$ filename); // richiede all'utente di scaricare il file zip $ this-> zip-> download ($ filename); 

Poiché abbiamo caricato la libreria zip, puoi utilizzare i metodi forniti da essa. Il metodo di archiviazione consente di creare un file zip nel percorso fornito come primo argomento. D'altra parte, il metodo di download richiede all'utente di scaricare il file.

Non ti preoccupare se ti stai chiedendo il contenuto del nostro file zip, come vedremo in un attimo.

Tutto è a posto, quindi siamo pronti a lanciare!

Prendiamo il codice del dati metodo. Questo metodo mostra come creare file al volo e avvolgerli in un file zip.

public function data () $ this -> _ load_zip_lib (); $ this-> zip-> add_data ('name.txt', 'Sajal Soni'); $ this-> zip-> add_data ('profile.txt', 'Web Developer'); $ This -> _ archieve_and_download ( 'my_info.zip'); 

Per cominciare, abbiamo chiamato il _load_zip_lib metodo che carica la libreria zip. Successivamente, abbiamo usato il add_data metodo della classe zip che ti permette di creare un file e riempirlo di contenuti allo stesso tempo! Ovviamente, viene aggiunto anche all'archivio!

Il primo argomento dovrebbe essere il nome del file e il secondo argomento contiene i contenuti che vanno nel file.

Come puoi vedere, abbiamo aggiunto due file, name.txt e profile.txt, con alcuni contenuti dimostrativi. Infine, chiamiamo _archieve_and_download con my_info.zip come argomento di quel metodo. Che cosa fa?

• Creerà un file zip my_info.zip sotto la directory dei tuoi upload.
• Richiederà inoltre all'utente il download dei file e il nome con cui verrà salvato il file my_info.zip.

Quindi assicurati di aver creato un uploads directory nella radice del tuo sito. Inoltre, rendilo scrivibile dall'utente del server web. Ora, vai avanti ed esegui "http: // my-codeingiter-site / zip / data" per vedere le cose in azione!

Se hai problemi, puoi chiedermelo nei commenti!

Avanti, c'è il data_array metodo.

funzione pubblica data_array () $ this -> _ load_zip_lib (); $ files = array ('name.txt' => 'Sajal Soni', 'profile.txt' => 'Web Developer'); $ This-> archivio zip> add_data ($ file); $ This -> _ archieve_and_download ( 'my_info.zip'); 

Questo metodo è identico a quello dell'ultimo che abbiamo appena discusso, tranne per il fatto che abbiamo fornito una serie di file al add_data metodo invece di singoli file!

Quindi, prendiamo il codice di data_with_subdirs metodo.

funzione pubblica data_with_subdirs () $ this -> _ load_zip_lib (); $ this-> zip-> add_data ('info / name.txt', 'Sajal Soni'); $ this-> zip-> add_data ('info / profile.txt', 'Web Developer'); $ This -> _ archieve_and_download ( 'my_info.zip'); 

Nel caso in cui si desidera organizzare i file all'interno di determinate directory, il add_data metodo ti permette anche di crearli. L'output risultante del metodo sopra non sarà diverso, tranne che il name.txt e profile.txt i file verranno inseriti nel file Informazioni elenco.

sebbene il add_data Il metodo fornisce una bella funzionalità che ti consente di creare file al volo, il più delle volte è necessario comprimere i file esistenti sul server. Ad ogni modo, questo è esattamente l'argomento del nostro prossimo paio di metodi.

Diamo un'occhiata veloce a ciò che è il nostro prossimo File il metodo sembra Creerà un file zip sotto il uploads elenco.

file di funzione pubblica () $ this -> _ load_zip_lib (); // passa il secondo argomento come TRUE se si desidera preservare la struttura dir $ this-> zip-> read_file (FCPATH. '/ uploads / 1.jpg'); $ This-> archivio zip> read_file (FCPATH '/ uploads / 2.jpg'.); $ This -> _ archieve_and_download ( 'images.zip'); 

Lo scopo del read_file il metodo è leggere il file esistente sul server e aggiungerlo all'archivio. Quindi, come puoi vedere, abbiamo aggiunto i due file 1.jpg e 2.jpg all'archivio. Naturalmente, questi due file devono essere presenti sotto il uploads directory nella radice del tuo sito.

Se passi VERO come il secondo argomento del read_file metodo, il file zip risultante conserva l'esatta struttura di directory in cui è stato inserito il file.

Prova a eseguire http: // my-codeingiter-site / zip / files e controlla il risultato!

L'ultimo metodo in questo segmento è il dir metodo. Creerà un archivio zip dell'intera directory.

public function dir () $ this -> _ load_zip_lib (); // passa il secondo argomento come FALSE se si desidera ignorare le directory precedenti $ this-> zip-> read_dir (FCPATH. '/ uploads / images /'); $ This -> _ archieve_and_download ( 'dir_images.zip'); 

Puoi usare il read_dir metodo se si desidera creare un archivio zip dell'intera directory anziché determinati file. Nel nostro esempio sopra, creerà a dir_images.zip file che contiene tutti i file sotto il / uploads / images / elenco.

La cosa importante da notare qui è che l'intera struttura della directory sarà preservata di default nel file zip. Ma se vuoi ignorarlo, passa FALSE come il secondo argomento del read_dir metodo. In tal caso, creerà solo un immagini directory nel file zip.

Così finisce la nostra storia di come creare un archivio zip usando vari metodi forniti dalla classe zip integrata.

Come decomprimere i file?

Sfortunatamente, non esiste una libreria CodeIgniter integrata che ci consenta di decomprimere l'archivio zip. Ma l'estensione PHP di ZipArchive lo rende un gioco da ragazzi, come vedremo tra un momento.

Creeremo un semplice esempio che mostra come decomprimere i file caricati dall'utente.

Vai avanti e crea un file application / controller / Unzip.php con i seguenti contenuti.

load-> helper (array ('form', 'url'));  public function index () $ this-> load-> view ('file_upload_form');  public function upload () $ config ['upload_path'] = './uploads/'; $ config ['allowed_types'] = 'zip'; $ this-> load-> library ('upload', $ config); if (! $ this-> upload-> do_upload ('zip_file')) $ params = array ('error' => $ this-> upload-> display_errors ());  else $ data = array ('upload_data' => $ this-> upload-> data ()); $ full_path = $ data ['upload_data'] ['full_path']; / **** senza libreria **** / $ zip = nuovo ZipArchive; se ($ zip-> aperto ($ full_path) === TRUE) $ zip-> extractTo (FCPATH. '/ uploads'); $ Archivio zip> close ();  $ params = array ('success' => 'Estratto con successo!');  $ this-> load-> view ('file_upload_result', $ params); 

Creiamo anche i nostri modelli di visualizzazione, e poi vedremo come funziona del tutto.

Crea un file modello di visualizzazione application / views / file_upload_form.php con i seguenti contenuti.

        
 
Caricare un file
 
 
 
  
  
 
  
  
 
  

Crea un semplice modulo di caricamento file in modo che l'utente possa caricare il file zip! Si prega di notare che l'ho tenuto al minimo per motivi di semplicità.

Successivamente, creiamo un file modello di visualizzazione application / views / file_upload_result.php.

        
 
Carica il risultato del file
 
 
 
 "><< Back to File Uploader 
 
  

Una volta che il file è stato caricato ed estratto, all'utente verrà mostrato il modello sopra.

Ora, torniamo al nostro controller e analizziamo ciascun metodo.

Nel costruttore del nostro controller, abbiamo caricato il built-in modulo e url Aiutanti CodeIgniter, in modo che possiamo usare le funzioni di aiuto come form_open_multipart, indirizzo del sito e simili.

Avanti, diamo un'occhiata al indice metodo.

indice di funzione pubblica () $ this-> load-> view ('file_upload_form'); 

Ha bisogno di spiegazioni? Si chiama la vista file_upload_form e rende la pagina. Quindi, quando accedi a http: // my-codeingiter-site / unzip, dovrebbe visualizzare un semplice modulo di caricamento file come mostrato di seguito.

Inoltre, nota che l'azione della nostra forma è Unzip / upload dove verranno pubblicati i dati. Abbiamo usato il form_open_multipart helper per generare il tag modulo multipart!

Successivamente, dobbiamo implementare il caricare metodo di azione che gestirà il caricamento e l'estrazione di file. Prendi il codice di quello dal Unzip.php controllore.

public function upload () $ config ['upload_path'] = './uploads/'; $ config ['allowed_types'] = 'zip'; $ this-> load-> library ('upload', $ config); if (! $ this-> upload-> do_upload ('zip_file')) $ params = array ('error' => $ this-> upload-> display_errors ());  else $ data = array ('upload_data' => $ this-> upload-> data ()); $ full_path = $ data ['upload_data'] ['full_path']; $ zip = nuovo ZipArchive; se ($ zip-> aperto ($ full_path) === TRUE) $ zip-> extractTo (FCPATH. '/ uploads'); $ Archivio zip> close ();  $ params = array ('success' => 'Estratto con successo!');  $ this-> load-> view ('file_upload_result', $ params); 

Se hai familiarità con il caricamento di file in CodeIgniter, il codice non dovrebbe sembrare estraneo a te. Per coloro che non hanno familiarità, non c'è nulla di cui preoccuparsi, poiché le API di caricamento integrate in CodeIgniter lo rendono un gioco da ragazzi.

Il seguente codice carica la libreria di upload con alcune configurazioni iniziali fornite da $ config variabile dell'array.

$ this-> load-> library ('upload', $ config);

L'abbiamo configurato in modo tale che il file caricato sia posizionato sotto uploads directory nella radice dell'applicazione, e l'utente sarà autorizzato a caricare solo i file zip.

Successivamente, abbiamo verificato se il caricamento del file non è riuscito e, in tal caso, recupereremo un utile messaggio di errore e lo assegneremo a $ params in modo che possiamo mostrarlo nel modello.

$ params = array ('error' => $ this-> upload-> display_errors ());

Nel caso, il file viene caricato correttamente, quindi il passo successivo è ottenere il percorso del file caricato.

$ data = array ('upload_data' => $ this-> upload-> data ()); $ full_path = $ data ['upload_data'] ['full_path'];

Infine, istanziamo un oggetto ZipArchive, apriamo il nostro file zip ed estraiamo il file uploads elenco.

$ zip = nuovo ZipArchive; se ($ zip-> aperto ($ full_path) === TRUE) $ zip-> extractTo (FCPATH. '/ uploads'); $ Archivio zip> close (); 

Non era così semplice?

L'unica cosa che ci rimane è chiamare il file_upload_result vista, ed ecco come dovrebbe apparire!

Quindi, questa è l'altra parte della storia!

Riforma il codice di decompressione in una libreria

Avresti notato che il caricare metodo contiene il codice ZipArchive che estrae il file caricato. Cosa succede se hai bisogno di usare quel codice in più posti? Potresti essere tentato di copiare e incollare il codice secondo necessità.

In effetti, c'è un modo migliore in cui CodeIgniter consente di centralizzare il codice che può essere utilizzato in tutta l'applicazione. Potresti creare una libreria personalizzata.

Vai avanti e crea un file application / librerie / Extractor.php con i seguenti contenuti.

CI = & get_instance (); $ this-> zip = new ZipArchive;  estratto di funzione pubblica ($ source_file, $ dest_dir) if ($ this-> zip-> open ($ source_file) === TRUE) $ this-> zip-> extractTo ($ dest_dir); $ This-> archivio zip> close (); 

Ora, vai avanti e sostituisci il caricare metodo nel tuo Unzip.php controller con il seguente.

public function upload () $ config ['upload_path'] = './uploads/'; $ config ['allowed_types'] = 'zip'; $ this-> load-> library ('upload', $ config); if (! $ this-> upload-> do_upload ('zip_file')) $ params = array ('error' => $ this-> upload-> display_errors ());  else $ data = array ('upload_data' => $ this-> upload-> data ()); $ full_path = $ data ['upload_data'] ['full_path']; $ This-> load-> library ( 'estrattore'); $ this-> extractor-> extract ($ full_path, FCPATH. '/ uploads /'); $ params = array ('success' => 'Estratto con successo!');  $ this-> load-> view ('file_upload_result', $ params); 

Come puoi vedere, abbiamo caricato la nostra libreria personalizzata e l'abbiamo usata per estrarre i contenuti!

$ This-> load-> library ( 'estrattore'); $ this-> extractor-> extract ($ full_path, FCPATH. '/ uploads /');

Molto carino, eh?

E sì, questa è la fine di questo articolo.

Conclusione

Spero che questo articolo ti sia piaciuto, in cui abbiamo iniziato a esplorare la libreria zip principale del framework CodeIgniter e diversi modi per creare un archivio zip. Nella seconda parte, ho spiegato come è possibile decomprimere i file caricati dall'utente utilizzando l'estensione PHP di ZipArchive.

Nel processo, abbiamo anche avuto la possibilità di convertire il nostro codice in una libreria CodeIgniter personalizzata, ed è qualcosa di una ciliegina sulla parte superiore, direi!

Fammi sapere se ti viene in mente qualche domanda o suggerimento che potresti scattare utilizzando il feed di seguito.