Artigos PHP Fazendo um upload de arquivos em PHP

O PHP é uma das linguagens mais utilizadas no desenvolvimento web e nesse artigo trataremos do uso de classes no PHP.

Com a necessidade de enviar arquivos em diversos sistemas, é necessário que seja criada uma classe para que realize essa função.

Uma das principais funções de uma classe é a reutilização de código, ou seja, escrever menos e fazer mais e essa é a principal função da orientação a objetos.

Por medidas de segurança, antes de fazermos qualquer coisa, faremos uma verificação para ver se a página que contém a classe está sendo chamada direta pela URL. Por exemplo, se eu tento acessar o arquivo dessa forma: http://www.seuwebsite.com.br/suaClasse.php

Essa verificação vai nos retornar ao index (Página principal), pois não é seguro um usuário conseguir acessar as classes dessa forma.

Para fazer uma verificação desse tipo é preciso usar os comandos abaixo na listagem 1.

Listagem 1: Verificação


 //Verificação de Segurança
 $url = $_SERVER["PHP_SELF"];
 if(preg_match("class.Upload.php", "$url"))
 {
 header("Location: ../index.php");
 }

Explicação do código:

A variável $url recebe o valor da URL atual. Usamos a função preg_match para NÃO fazer diferença entre minúsculas e maiúsculas em nossa comparação. Em seguida, é verificado se a URL digitada tem o mesmo nome do nosso arquivo.

Se positivo, usamos o header para enviar o usuário de volta para o index, ou para qualquer página que queira.

Após feita a verificação, já podemos começar a criação da nossa classe de upload.

Para esta classe, vamos usar 3 atributos, sendo eles: tipo, nome e tamanho.

Então nossa classe ficaria da seguinte forma:

Listagem 2: Classe Upload



 class Upload
 {
 var $tipo;
 var $nome;
 var $tamanho;
 }

Com os atributos criados, podemos recuperar os dados do arquivo enviado. No PHP as variáveis não necessitam de tipagem, ou seja, não é necessário tipar como integer, string ou qualquer outro tipo, basta declará-las.

Nosso próximo passo em nossa classe é criar as funções. Nossa primeira função será a função upload, que apenas será utilizada para instanciarmos o objeto.

Listagem 3: Criando função upload


 function Upload()
 {
 //criando o objeto
 }

Agora que a função está criada, podemos instanciar o objeto, usando o comando $arquivo = new Upload;

Porém, não existe nenhuma ação ainda, vamos criar nossa função principal.

Para esta função, serão necessários 3 atributos também, sendo eles:

  • $arquivo - Arquivo que o nosso form nos enviou.
  • $pasta - Pasta onde será salvo nosso arquivo (Lembre-se de aplicar permissões de escrita na pasta em que o arquivo será salvo).
  • $tipo - O tipo na verdade, será uma lista (Array), contendo todos os tipos de arquivo permitidos.

Quando um arquivo for enviado ao servidor, se já houver outro arquivo com o mesmo nome, ele será substituido.

Iremos fazer então um hash (Um código), usando a encriptação MD5. Esse hash será gerado da junção do nome do arquivo com a data atual, então o nome do arquivo enviado ficará apenas um código extenso.

Por exemplo:

Arquivo Enviado: imagem_teste.jpg
Nome do arquivo depois de enviado ao servidor: 33ea8043909c3726e2eacbf4a82e5227.jpg

Com isso vamos evitar muitos erros a partir de caracteres especiais e nome de arquivos extensos e também evitaremos a substituição de arquivos em nosso servidor.

Vamos criar agora a função UploadImagem

Listagem 4: function UploadImagem


 function UploadImagem($arquivo, $pasta, $tipos)
 {
 
 }

A primeira coisa que iremos fazer, é verificar se algum arquivo foi enviado, pois sem arquivo, não conseguimos fazer nada.

Iremos verificar com o isset, se o arquivo foi enviado, caso não tenha sido enviado nada irá acontecer. Caso o arquivo tenha sido postado, iremos recuperar alguns atributos dele.

Listagem 5: Verificando se o arquivo foi enviado



 function UploadImagem($arquivo, $pasta, $tipos)
 {
 if(isset($arquivo))
 {
 $nomeOriginal = $arquivo["name"]; 
 $nomeFinal = md5($nomeOriginal . date("dmYHis"));
 $tipo = strrchr($arquivo["name"],".");
 $tamanho = $arquivo["size"];
 }
 }

Primeiramente, devemos saber que o arquivo vem em forma de array, contendo assim vários atributos.

A variável $nomeOriginal, que recebe o nome do arquivo é recuperada pela sintaxe $arquivo["name"].

Também é criada uma variável chamada $nomeFinal, que receberá o nome final do arquivo.

Lembre-se que acima falamos de um problema de sobrescrever arquivos e de caracteres especiais no nome do arquivo.

Para corrigir a questão dos novos arquivos sobrescreverem arquivos antigos é necessário utilizar criptografia MD5 e gerar uma hash criptografada md5($nomeOriginal . date("dmYHis"));

Usando isso, nosso arquivo deverá ficar com o nome parecido com: imagem_teste.jpg06012008102755

Criamos uma variável chamada $tipo e utilizamos o strrchr para pegar o último indíce depois do ".", no nome do arquivo. Sendo assim posso obter o tipo do arquivo.

Também criamos uma variável de nome $tamanho atribuímos a ela, o tamanho do nosso arquivo.

Com os dados recuperados, é preciso fazer uma verificação, para saber se o tipo do arquivo que estamos tentando enviar é permitido, ou seja, realizar uma validação no formato do arquivo.

Os tipos de arquivos permitidos são passados através da variável $tipos que é um array.

Vamos fazer um laço para varrer este array e comparar item por item para ver se a extensão do arquivo enviado é válido.

Listagem 6: Validação de tipo de arquivo



 function UploadImagem($arquivo, $pasta, $tipos)
 {
 if(isset($arquivo))
 {
 $nomeOriginal = $arquivo["name"]; 
 $nomeFinal = md5($nomeOriginal . date("dmYHis"));
 $tipo = strrchr($arquivo["name"],".");
 $tamanho = $arquivo["size"];

 for($i=0;$i<=count($tipos);$i++)
 { 
 if($tipos[$i] == $tipo)
 {
 $arquivoPermitido=true;
 }
 }
if($arquivoPermitido==false)
{
 echo "Extensão de arquivo não permitido!!";
 exit;
}
 
 }
 }

Agora que temos as nossas verificações feitas, vamos finalmente fazer o upload do arquivo.

Todo arquivo quando carregado, fica na pasta temporária do seu sistema operacional, sendo assim, temos que recuperar esse valor ao enviá-lo.

Listagem 7: Recuperando arquivo da pasta temporária


 if (move_uploaded_file($arquivo["tmp_name"], $pasta . $nomeFinal . $tipo))
 { 
 $this->nome=$pasta . $nomeFinal . $tipo;
 $this->tipo=$tipo;
 $this->tamanho=number_format($arquivo["size"]/1024, 2) . "KB";
 return true; 
 }else{ 
 return false;
 }

No código acima nós movemos o arquivo de pasta usando o código move_uploaded_file(arquivo, destino); passando os seguintes valores:

  • $arquivo["tmp_name"] que é o nome temporário do arquivo que carregamos.
  • $pasta que recebeu o valor da função uploadArquivo($arquivo, $pasta, $tipos).
  • $nomeFinal que foi a hash que geramos com o MD5.
  • $tipo que é o tipo do arquivo que carregamos.

Quando colocamos o if(move_uploaded_file) estamos fazendo uma verificação. Se caso o arquivo não possa ser movido, retornamos false. Caso possa ser movido, executamos o código.

Ao final de tudo, nossa classe deve estar assim:

Listagem 8: classe Upload.php


 <?php 
 $url = $_SERVER["PHP_SELF"];
 if(preg_match("class.Upload.php", "$url"))
 {
 header("Location: ../index.php");
 }

 
 class Upload
 {
 var $tipo;
 var $nome;
 var $tamanho;
 
 function Upload()
 {
 //Criando objeto
 }
 
 function UploadArquivo($arquivo, $pasta, $tipos)
 { 
 if(isset($arquivo))
 {
 $nomeOriginal = $arquivo["name"]; 
 $nomeFinal = md5($nomeOriginal . date("dmYHis"));
 $tipo = strrchr($arquivo["name"],".");
 $tamanho = $arquivo["size"];
 
 for($i=0;$i<=count($tipos);$i++)
 { 
 if($tipos[$i] == $tipo)
 {
 $arquivoPermitido=true;
 }
 }
 
 if($arquivoPermitido==false)
 {
 echo "Extensão de arquivo não permitido!!";
 exit;
 }
 
 if (move_uploaded_file($arquivo["tmp_name"], $pasta . $nomeFinal . $tipo))
 { 
 $this->nome=$pasta . $nomeFinal . $tipo;
 $this->tipo=$tipo;
 $this->tamanho=number_format($arquivo["size"]/1024, 2) . "KB";
 return true; 
 }else{ 
 return false;
 } 
 }
 } 
 }
 ?>

Com a classe criada, só fica faltando instanciar o objeto na respectiva página e fazer a chamada.

Vamos agora criar uma página de envio de arquivos.

Listagem 9: Criando página formArquivo.html


<html>
<head>
	<title>Enviando arquivos com PHP</title>
</head>
<body>
 <form action="envia_arquivos.php" method="post" enctype="multipart/form-data">
 <input type="hidden" name="MAX_FILE_SIZE" value="300000">
 <input name="userfile" type="file">
 <input type="submit" value="Enviar Arquivo">
 </form>

</body>
</html>

Nosso formulário ficará então da seguinte forma:

Formulário de Envio

Figura 1: Formulário de Envio

Com o nosso formulário criado, vamos então fazer o upload do arquivo. Criaremos uma nova página com o nome de envia_arquivos.php.

Listagem 10: Criando página envia_arquivos.php 


 <?php
 include("class.Upload.php");

 //define os tipos permitidos
 $tipos[0]=".gif";
 $tipos[1]=".jpg";
 $tipos[2]=".jpeg";
 $tipos[3]=".png";
 
 if(isset($HTTP_POST_FILES["userfile"]))
 {
 $upArquivo = new Upload;
 if($upArquivo->UploadArquivo($HTTP_POST_FILES["userfile"], "Imagens/", $tipos))
 {
 $nome = $upArquivo->nome;
 $tipo = $upArquivo->tipo;
 $tamanho = $upArquivo->tamanho;
 }else{
 echo "Falha no envio<br />";
 }
 }
 ?>
 <strong>Nome do Arquivo Enviado:</strong> <?php echo $nome ?><br />
 <strong>Tipo do Arquivo Enviado:</strong> <?php echo $tipo ?><br />
 <strong>Tamanho do Arquivo Enviado:</strong> <?php echo $tamanho ?><br />

Conclusão

Nesse artigo foi mostrado como criar um pequeno sistema de envoi de arquivos em PHP. Espero que tenham gostado e até o próximo artigo.

Leia também