Share
In questo tutorial, il nostro obiettivo è creare una classe FTP con PHP ben scritta, utile ed espandibile.
È sempre importante innanzitutto delineare esattamente quali funzionalità dovrebbe includere la classe. Nel nostro caso:
Ci sono diversi casi in cui si potrebbe usare questo tipo di classe. Un paio di scenari potrebbero essere:
Nota: È facile imbattersi in problemi con l'FTP a causa di diverse configurazioni del server. Questo codice è stato testato con successo su un certo numero di server FTP.
FTP: "Un protocollo di rete standard utilizzato per copiare un file da un host a un altro."
FTP, o File Transfer Protocol, è, come definito da Wikipedia: "Un protocollo di rete standard utilizzato per copiare un file da un host a un altro su una rete basata su TCP / IP, come Internet."
Essenzialmente, ti permette di copiare un file (s) da un computer all'altro.
Inizieremo nel modo più semplice possibile. Nella root del nuovo progetto, crea due file: index.php e ftp_class.php.
Il index.php file è la nostra pagina principale che crea l'oggetto e chiama i metodi necessari. Il ftp_class.php è proprio questo: la nostra classe ftp.
Nel prossimo passo, creeremo lo scheletro per la nostra classe. Una volta che questo è a posto, sarai in grado di seguire e provare ogni passaggio.
Il punto di forza di Object-Oriented Programming (OOP) è di dare al codice complesso un'interfaccia facile da usare. Creando una classe - pensa a una classe come a un modello - puoi incapsulare i dati, che è semplicemente un gergo per un termine che si riferisce a nascondere i dati. Possiamo quindi riutilizzare questa classe più e più volte senza la necessità di riscrivere alcun codice. Invece, è sufficiente chiamare i metodi appropriati (il termine "metodo" equivale a funzione).
Iniziamo a creare la nostra classe ftp. Apri i tuoi ftp_class.php file e aggiungere il seguente codice. Questa è una struttura scheletrica di base, che ho chiamato 'FTPClient'.
Il costruire la funzione, nota come costruttore, è un metodo di classe speciale che viene automaticamente chiamato dalla classe quando si crea un nuovo oggetto o istanza della classe. Questo è in genere un buon posto per aggiungere alcune inizializzazioni; ma per lo scopo di oggi, non ne abbiamo bisogno. Tuttavia, lo terremo qui per uso futuro.
Classe FTPClient // *** Class variabili public function __construct ()
Si prega di notare che stiamo usando un Doppio sottolineatura per quello costruire metodo.
Successivamente, imposteremo alcune variabili di classe o proprietà.
private $ connectionId; private $ loginOk = falso; private $ messageArray = array ();
Il "privato"prefisso definisce l'ambito della variabile. In questo caso, significa che non è possibile accedere alla variabile da nessuna parte al di fuori della classe.
Il $ connectionId variabile memorizzerà il nostro stream di connessione. Gli altri due memorizzano lo stato e tutti i messaggi. $ loginOk sarà utile per determinare se siamo connessi correttamente.
In quasi tutti i metodi, chiameremo un metodo chiamato 'logMessage. Questo è un gestore di messaggi molto semplice, che ci permetterà di catturare tutti i messaggi creati dalla nostra classe in modo da poter fornire all'utente feedback.
Nota che non lo facciamo
ritornoi messaggi effettivi dai nostri metodi. Invece, torniamoveroofalso, in base al fatto che una determinata operazione abbia avuto o meno esito positivo. Questo ha i suoi vantaggi, ma non descrive in dettaglio all'utente cosa sta succedendo.
Aggiungi i seguenti due metodi, in modo che possiamo determinare cosa ha successo.
Questo metodo accetta una variabile, $ messaggio. I contenuti di questa variabile vengono quindi salvati nel nostro array di classe, grazie alla linea: $ this-> messageArray [] = $ message;
funzione privata logMessage ($ message) $ this-> messageArray [] = $ message;
Perché $ messageArray è una variabile di classe, possiamo accedervi tramite il $ This-> notazione.
All'interno di una classe,
$ questosi riferisce all'oggetto stesso.
Per recuperare il messaggio, chiamiamo getMessages.
funzione pubblica getMessages () return $ this-> messageArray;
Questo metodo è un metodo pubblico. Come menzionato in precedenza, questa attività privata / pubblica si riferisce semplicemente all'ambito della variabile o, in questo caso, al metodo. Non è possibile accedere a un metodo privato (o variabile) al di fuori della classe, mentre un metodo pubblico (o una variabile) può.
Poiché la nostra variabile è privata, abbiamo bisogno di un modo per accedervi. Lo facciamo dando alla nostra classe a pubblico metodo, che possiamo quindi accedere al di fuori della classe. Ci si potrebbe chiedere perché non possiamo semplicemente creare il messageArray pubblico variabile. Noi possiamo; detto questo, non è solo una buona pratica.
Nota: Ci sono molti esempi sul web di gestori di messaggi in piena regola o classi dedicate a loro. Stiamo lavorando a una semplice implementazione ai fini di questo tutorial.
In questo passaggio, aggiungeremo il Collegare metodo. Questo ci permetterà di connetterci a un server FTP.
Accentsconagua
collegare la funzione pubblica ($ server, $ ftpUser, $ ftpPassword, $ isPassive = false) // *** Configurare la connessione di base $ this-> connectionId = ftp_connect ($ server); // *** Login con username e password $ loginResult = ftp_login ($ this-> connectionId, $ ftpUser, $ ftpPassword); // *** Imposta la modalità passiva on / off (default disattivato) ftp_pasv ($ this-> connectionId, $ isPassive); // *** Verifica connessione if ((! $ This-> connectionId) || (! $ LoginResult)) $ this-> logMessage ('Connessione FTP fallita!'); $ this-> logMessage ('Tentativo di connessione a'. $ server. 'per utente'. $ ftpUser, true); restituisce falso; else $ this-> logMessage ('Connesso a'. $ server. ', per utente'. $ ftpUser); $ this-> loginOk = true; ritorna vero; Passiamo nelle nostre informazioni di connessione: il server ($ server), nome utente ($ ftpuser) e password ($ ftpPassword) per permetterci di stabilire una connessione.
La prima riga di codice apre una connessione FTP, con ftp_connect, al server specificato. Salviamo la nostra connessione alla variabile di classe, $ connectionId descritto sopra.
Il codice, ftp_login ci registra alla connessione specificata, passando nel nostro ID di connessione, il nostro nome utente e password.
Potresti aver notato il ftp_pasv linea di codice. Questo, come suggerisce il commento, attiva / disattiva la modalità passiva. Ti suggerisco di lasciarlo spento, tuttavia, se hai problemi di connessione, prova ad accenderlo. La modalità passiva può causare problemi durante la connessione tramite FTP.
Determiniamo se la connessione ha avuto successo. Quindi registriamo i risultati chiamando il nostro semplice metodo di gestione dei messaggi, logMessage (), e passa la stringa per accedere. Ricorda: usiamo $ This-> accedere logMessage (), come è una variabile di classe.
Ora che la nostra classe sta funzionando, possiamo provarlo! Apri i tuoi index.php file e aggiungere il seguente codice.
Avrai bisogno di accedere a un server FTP per giocare insieme. Se desideri impostare il tuo server, prova Filezilla - è anche gratuito.
Noterai che ho aggiunto i dettagli del server FTP qui. Idealmente questi sarebbero immagazzinati nel tuo config file. Cambia questi per abbinare le impostazioni del tuo server FTP.
Dopo aver definito i dettagli del nostro server FTP, includiamo la classe con include ( 'ftp_class.php');. Ciò significa: rendere la classe disponibile all'interno di questa pagina. La riga successiva crea un oggetto della nostra classe FTP e lo memorizza nella variabile, $ ftpObj. $ ftpObj verrà ora utilizzato per accedere a qualsiasi metodo pubblico all'interno della nostra classe. Questo viene fatto usando il -> notazione, proprio come fa la seguente linea chiamando il $ ftpObj -> connetti metodo e passandogli i dettagli del nostro server.
// *** Definisci il tuo host, nome utente e password define ('FTP_HOST', '192.168.1.88'); define ('FTP_USER', 'Blimpf'); define ('FTP_PASS', 'catfish'); // *** Include la classe include ('ftp_class.php'); // *** Crea l'oggetto FTP $ ftpObj = new FTPClient (); // *** Collega $ ftpObj -> connect (FTP_HOST, FTP_USER, FTP_PASS); Come puoi vedere, una volta stabilita la nostra classe, la connessione al nostro server FTP è molto semplice!
Nell'ultimo passaggio potremmo racchiudere la chiamata di connessione in un Se dichiarazione, come dimostrato di seguito. Quindi, se non si riesce a connettersi, il codice dipendente non verrà eseguito. Possiamo quindi inviare tutti i messaggi all'utente, come "connesso" o "fallito".
// *** Connetti if ($ ftpObj -> connect (FTP_HOST, FTP_USER, FTP_PASS)) // *** Quindi aggiungi il codice FTP qui echo 'connected'; else echo 'Failed to connect';
Questo è ok, anche se il nostro codice diventerà presto piuttosto gonfio con le dichiarazioni IF / ELSE, se aggiungiamo questo a tutte le nostre chiamate. Invece, mi piacerebbe offrire un'alternativa che renderà le cose un po 'più pulite e più facili da seguire.
Ricorda i metodi di gestione dei messaggi che abbiamo aggiunto? Se desideri vedere i messaggi prodotti dalla classe - utile per il debug / feedback - puoi aggiungere il seguente codice dopo ogni metodo che chiami.
print_r ($ ftpObj -> getMessages ());
Questo mostrerà il messaggio di classe.
Eccellente, ora è il momento di fare qualcosa di utile. Il primo metodo che stiamo per creare è il MakeDir metodo. Come previsto, questo metodo creerà directory per noi sul server. L'unico parametro che passeremo è il percorso della directory e il nome della cartella; lo chiameremo $ directory. La linea magica qui è la ftp_mkdir funzione integrata. Usa i nostri salvati "connectionId"e il passato $ directory variabile per creare la cartella.
Aggiungi il seguente codice al tuo ftp_class.php file:
funzione pubblica makeDir ($ directory) // *** Se la creazione di una directory ha esito positivo? if (ftp_mkdir ($ this-> connectionId, $ directory)) $ this-> logMessage ('Directory' '. $ directory.' "creato con successo '); ritorna vero; altro // ***? Altro, FAIL. $ this-> logMessage ('Impossibile creare la directory' '. $ directory.' "''); restituisce falso; E, per chiamarlo dal tuo index.php file, aggiungere:
$ dir = 'foto'; // *** Crea directory $ ftpObj-> makeDir ($ dir);
La variabile, $ dir è impostato sul nome della cartella che vogliamo creare sul server. In questo caso: "foto".
La riga successiva chiama il metodo che creerà la cartella.
Se ricevi un errore "Autorizzazione negata", assicurati di poter scrivere nella cartella specificata. Potrebbe essere necessario creare la cartella all'interno di una directory, ad esempio
/ httpdocs.
Continuando, carichiamo una foto, chiamata zoe.jpg. Quando carichi un file, dobbiamo specificare il tipo di file che stiamo caricando - binario o ascii? Fondamentalmente, se stai caricando un file di testo, dovremmo usarlo ascii; altrimenti, dovrebbe essere impostato su binario.
Iniziamo impostando un schieramento con tutte le estensioni che dovremmo usare per un ascii tipo di caricamento.
$ asciiArray = array ('txt', 'csv'); Quindi, recuperiamo l'estensione del nostro file, in modo che possiamo verificare se è uno dei ascii tipi. Determiniamo ciò ottenendo l'estensione del file che stiamo caricando. Il metodo rapido e sporco che ho usato qui è
"esplodendo" il file usando il '.'come il delimitatore. Ciò dividerà il file in pezzi e li memorizzerà come un file schieramento. Usando un'altra funzione PHP integrata, "end", selezioniamo l'ultima schieramento elemento che contiene la nostra estensione. È un piccolo pezzo di codice.
$ extension = end (esplode ('.', $ fileFrom)); Successivamente, verifichiamo se la nostra estensione appare nell'elenco (con in_array) di estensioni di file che dovrebbero essere caricate come tipo ascii. Se appare nell'elenco, impostiamo la variabile modalità $ a FTP_ASCII; altrimenti, assumiamo che sia di tipo binario e assegni modalità $ il valore FTP_BINARY.
in_array ($ extension, $ asciiArray)
ftp_put carica un file dalla tua posizione locale a un file remoto sul server ftp. Lo passiamo nostro "connectionId", il percorso del file che vogliamo caricare ($ fileto), il sentiero
del file che vogliamo caricare ($ fileFrom), e la modalità (modalità $) che abbiamo appena determinato.
Quindi, aggiungi il seguente metodo al tuo ftp_class.php file:
funzione pubblica uploadFile ($ fileFrom, $ fileTo) // *** Imposta la modalità di trasferimento $ asciiArray = array ('txt', 'csv'); $ extension = end (esplode ('.', $ fileFrom)); if (in_array ($ extension, $ asciiArray)) $ mode = FTP_ASCII; else $ mode = FTP_BINARY; // *** Carica il file $ upload = ftp_put ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode); // *** Controlla lo stato del caricamento se (! $ Upload) $ this-> logMessage ('Caricamento FTP fallito!'); restituisce falso; else $ this-> logMessage ('Uploaded' '. $ fileFrom.' "come" '. $ fileTo); return true; Certamente, puoi creare o caricare qualsiasi nome di cartella che desideri! Aggiungi questo snippet di codice successivo al tuo index.php file e regolare di conseguenza.
$ fileFrom = 'zoe.jpg'; $ fileTo = $ dir. '/'. $ FileFrom; // *** Carica il file locale nella nuova directory sul server $ ftpObj -> uploadFile ($ fileFrom, $ fileTo);
A questo punto, dovresti venire a patti con quanto sia facile usare questa lezione! Stiamo semplicemente effettuando chiamate singole per eseguire i nostri compiti, tutto grazie alla programmazione orientata agli oggetti!
Ora confermiamo che il nostro file è nel foto cartella. Possiamo farlo navigando verso l 'foto'cartella sul nostro server, quindi visualizzare i contenuti.
Il changeDir metodo usa "ftp_chdir"per cambiare la directory corrente sul server ftp. Basta passare nella directory in cui passare. Semplice e dolce.
ftp_class.php:
funzione pubblica changeDir ($ directory) if (ftp_chdir ($ this-> connectionId, $ directory)) $ this-> logMessage ('Current directory is now:'. ftp_pwd ($ this-> connectionId)); ritorna vero; else $ this-> logMessage ('Couldn \' t change directory '); restituisce falso; getDirListing mostrerà il contenuto della directory in cui ti trovi utilizzando la funzione "ftp_nlistQuesta funzione restituisce un elenco di file in una determinata directory.La directory corrente è impostata per impostazione predefinita, quindi non è necessario fornire alcun parametro.
Se lo desideri, puoi ignorarlo passando nel $ directory percorso che si desidera visualizzare il contenuto di. Il $ parametri variabile predefinita a '-la'. Questo è un comando di Linux per visualizzare più informazioni sulla directory. Sentiti libero di rimuoverlo o passare una stringa vuota.
funzione pubblica getDirListing ($ directory = '.', $ parameters = '-la') // ottiene il contenuto della directory corrente $ contentsArray = ftp_nlist ($ this-> connectionId, $ parameters. ". $ directory); return $ contentsArray;
Il getDirListing metodo restituisce un schieramento che contiene la nostra lista di directory.
// *** Passa alla cartella $ ftpObj-> changeDir ($ dir); // *** Ottieni contenuto cartella $ contentsArray = $ ftpObj-> getDirListing (); // *** Emetti la nostra matrice di contenuti di cartelle echo ''; print_r ($ contentsArray); eco '';
Il tuo risultato dovrebbe essere così:
Passaggio 10: download di un file
Mentre spingiamo verso la conclusione di questo tutorial, passiamo al download del file. Il metodo inizia con lo stesso codice di
caricare un file, in quanto determina se il file che vogliamo scaricare èasciiobinario.Per questo metodo, è sufficiente passare il nome del file (e possibilmente il percorso, a seconda se si è nella stessa cartella del file che si desidera scaricare) del file da scaricare, e il nome che si desidera che quel file abbia su la tua macchina client.
Per scaricare un file, è necessario chiamare
ftp_get.ftp_get ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode, 0)Questo scarica un file da un server remoto sul nostro computer locale. Accetta il seguente parametro: il nostro id di connessione, il percorso e il nome del file da salvare come localmente (verrà sovrascritto se esso
esiste già) ($ fileto), la posizione e il nome del file sul server remoto ($ fileFrom), e la modalità (modalità $).ftp_class.php
public function downloadFile ($ fileFrom, $ fileTo) // *** Imposta la modalità di trasferimento $ asciiArray = array ('txt', 'csv'); $ extension = end (esplode ('.', $ fileFrom)); if (in_array ($ extension, $ asciiArray)) $ mode = FTP_ASCII; else $ mode = FTP_BINARY; // prova a scaricare $ remote_file e salvalo su $ handle if (ftp_get ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode, 0)) return true; $ this-> logMessage ('file' '. $ fileTo.' "scaricato con successo '); else return false; $ this-> logMessage ('Si è verificato un errore durante il download del file' '. $ fileFrom.' "in" '. $ fileTo.' "'');Stiamo andando a scaricare lo stesso file che abbiamo caricato salvandolo con un nome diverso sul nostro computer client.
Nota: Di nuovo, assicurati che le tue autorizzazioni siano impostate correttamente!
Perché dovremmo essere dentro i nostri
fotocartella, non aggiungiamo un percorso al$ fileFromvariabile - solo il nome del file.index.php
$ fileFrom = 'zoe.jpg'; # La posizione sul server $ fileTo = 'zoe-new.jpg'; # Directory locale da salvare in // *** Scarica il file $ ftpObj-> downloadFile ($ fileFrom, $ fileTo);
Step 11 - Finire
Per completare la nostra classe, aggiungiamo il metodo magico di classe,
__deconstruct. Questo metodo chiude la nostra connessione quando il riferimento al nostro oggetto non esiste più - forse la pagina è stata chiusa. In ogni caso, questo codice viene eseguito e la connessione viene chiusa. È sempre una buona pratica includere questo, anche se non è del tutto necessario.funzione pubblica __deconstruct () if ($ this-> connectionId) ftp_close ($ this-> connectionId);
Conclusione
Bene, lo fa! Spero che ora tu abbia una migliore comprensione di come usare FTP con PHP. Ora dovresti avere le competenze necessarie per espandere ulteriormente questa classe per supportare altre attività comuni, come la ridenominazione o l'eliminazione di file e cartelle.
Assicurati di farci sapere se crei dei fantastici client FTP PHP!
