PHP 5.4.33 Released

Carga con el método POST

Esta característica permite que los usuarios envien tanto archivos de texto como binarios. Con la autenticación de PHP y las funciones de manipulación de archivos, se tiene completo control sobre quién está autorizado a cargar y que hay que hacer con el archivo una vez que se ha cargado.

PHP es capaz de recibir cargas de archivos de cualquier navegador compatible con RFC-1867.

Nota: Configuraciones Relacionadas

Ver también las directivas file_uploads, upload_max_filesize, upload_tmp_dir, post_max_size y max_input_time en php.ini

PHP también soporta el método PUT para la carga como lo utilizan los clientes Netscape Composer y Amaya del W3C. Ver el soporte del método PUT para más detalles.

Ejemplo #1 Formulario para la carga de archivos

Una página de carga de archivos puede ser construida mediante la creación de un formulario especial el cual se vería algo como esto:

<!-- El tipo de codificación de datos, enctype, se DEBE especificar como a continuación -->
<form enctype="multipart/form-data" action="__URL__" method="POST">
    <!-- MAX_FILE_SIZE debe preceder el campo de entrada de archivo -->
    <input type="hidden" name="MAX_FILE_SIZE" value="30000" />
    <!-- El nombre del elemento de entrada determina el nombre en el array $_FILES -->
    Enviar este archivo: <input name="userfile" type="file" />
    <input type="submit" value="Send File" />
</form>

El __URL__ en el ejemplo anterior se debe sustituir y apuntar a un archivo PHP.

El campo oculto MAX_FILE_SIZE (medido en bytes) debe preceder al campo de entrada de archivo y su valor es el tamaño máximo de archivo aceptado por PHP. Este elemento del formulario se debe usar siempre, ya que evita a los usuarios la molestia de esperar a que un gran archivo sea transferido sólo para descubrir que era demasiado grande y falló la transferencia. Tener en cuenta: engañar a esta configuración en el lado del navegador es muy fácil, así que nunca se debe confiar en que archivos con un tamaño mayor serán bloqueados por esta característica. Es simplemente una característica de conveniencia para los usuarios en el lado cliente de la aplicación. Sin embargo, la configuración de PHP (en el lado del servidor) para un máximo de tamaño, no puede ser engañada.

Nota:

Asegúrese de que el formulario de subida de archivos tiene el atributo enctype="multipart/form-data" de lo contrario la carga de archivos no funcionará.

El $_FILES global existe a partir de PHP 4.1.0 (Usar $HTTP_POST_FILES en su lugar si se utiliza una versión anterior). Este array contendrá toda la información sobre el archivo cargado.

El contenido de $_FILES del formulario de ejemplo es el siguiente. Tenga en cuenta que esto asume la utilización del nombre del archivo cargado userfile, tal como se utiliza en el script de ejemplo anterior. Este puede ser cualquier nombre.

$_FILES['userfile']['name']

El nombre original del archivo en la máquina cliente.

$_FILES['userfile']['type']

El tipo mime del archivo, si el navegador proporciona esta información. Un ejemplo podría ser "image/gif". Este tipo mime, sin embargo no se verifica en el lado de PHP y por lo tanto no se garantiza su valor.

$_FILES['userfile']['size']

El tamaño, en bytes, del archivo subido.

$_FILES['userfile']['tmp_name']

El nombre temporal del archivo en el cual se almacena el archivo cargado en el servidor.

$_FILES['userfile']['error']

El código de error asociado a esta carga de archivo. Este elemento fue añadido en PHP 4.2.0

Los archivos, por defecto se almacenan en el directorio temporal por defecto del servidor, a menos que otro lugar haya sido dado con la directiva upload_tmp_dir en php.ini. El directorio por defecto del servidor puede ser cambiado mediante el establecimiento de la variable de entorno TMPDIR en el entorno en el cual se ejecuta PHP. Configurarlo usando putenv() desde un script PHP no funcionará. Esta variable de entorno también se puede utilizar para asegurarse de que las demás operaciones están trabajando sobre los archivos cargados.

Ejemplo #2 Validación de la carga de archivos

Ver también las entradas para las funciones is_uploaded_file() y move_uploaded_file() para más información. El siguiente ejemplo procesaría la carga de archivo que vendría de un formulario.

<?php
// En versiones de PHP anteriores a 4.1.0, $HTTP_POST_FILES debe utilizarse en lugar
// de $_FILES.

$uploaddir '/var/www/uploads/';
$uploadfile $uploaddir basename($_FILES['userfile']['name']);

echo 
'<pre>';
if (
move_uploaded_file($_FILES['userfile']['tmp_name'], $uploadfile)) {
    echo 
"El archivo es válido y fue cargado exitosamente.\n";
} else {
    echo 
"¡Posible ataque de carga de archivos!\n";
}

echo 
'Aquí hay más información de depurado:';
print_r($_FILES);

print 
"</pre>";

?>

El script PHP que recibe el archivo cargado, debe implementar cualquier lógica que sea necesaria para determinar qué se debe hacer con el archivo subido. Se puede, por ejemplo, utilizar la variable $_FILES['userfile']['size'] para descartar cualquier archivo que sea demasiado pequeño o demasiado grande. Se podría utilizar la variable $_FILES['userfile']['type'] para descartar cualquier archivo que no corresponda con un cierto criterio de tipo, pero usando esto sólo como la primera de una serie de verificaciones, debido a que este valor está completamente bajo el control del cliente y no se comprueba en el lado de PHP. A partir de PHP 4.2.0, se puede usar $_FILES['userfile']['error'] y el planear la lógica de acuerdo con los códigos de error. Cualquiera que sea la lógica, se debe borrar el archivo del directorio temporal o moverlo a otra parte.

Si ningún archivo es seleccionado para realizar la carga en el formulario, PHP devolverá $_FILES['userfile']['size'] como 0, y $_FILES['userfile']['tmp_name'] como ninguno.

El archivo será borrado del directorio temporal al final de la solicitud si no se ha movido o renombrado.

Ejemplo #3 Cargando un array de archivos

PHP soporta las funcionalidades array de HTML incluso con archivos.

<form action="" method="post" enctype="multipart/form-data">
<p>Pictures:
<input type="file" name="pictures[]" />
<input type="file" name="pictures[]" />
<input type="file" name="pictures[]" />
<input type="submit" value="Send" />
</p>
</form>
<?php
foreach ($_FILES["pictures"]["error"] as $key => $error) {
    if (
$error == UPLOAD_ERR_OK) {
        
$tmp_name $_FILES["pictures"]["tmp_name"][$key];
        
$name $_FILES["pictures"]["name"][$key];
        
move_uploaded_file($tmp_name"data/$name");
    }
}
?>

Una barra de progreso de carga de archivos puede ser implementada mediante Session Upload Progress.

add a note add a note

User Contributed Notes 10 notes

up
17
daevid at daevid dot com
5 years ago
I think the way an array of attachments works is kind of cumbersome. Usually the PHP guys are right on the money, but this is just counter-intuitive. It should have been more like:

Array
(
    [0] => Array
        (
            [name] => facepalm.jpg
            [type] => image/jpeg
            [tmp_name] => /tmp/phpn3FmFr
            [error] => 0
            [size] => 15476
        )

    [1] => Array
        (
            [name] =>
            [type] =>
            [tmp_name] =>
            [error] => 4
            [size] =>
        )
)

and not this
Array
(
    [name] => Array
        (
            [0] => facepalm.jpg
            [1] =>
        )

    [type] => Array
        (
            [0] => image/jpeg
            [1] =>
        )

    [tmp_name] => Array
        (
            [0] => /tmp/phpn3FmFr
            [1] =>
        )

    [error] => Array
        (
            [0] => 0
            [1] => 4
        )

    [size] => Array
        (
            [0] => 15476
            [1] => 0
        )
)

Anyways, here is a fuller example than the sparce one in the documentation above:

<?php
foreach ($_FILES["attachment"]["error"] as $key => $error)
{
      
$tmp_name = $_FILES["attachment"]["tmp_name"][$key];
       if (!
$tmp_name) continue;

      
$name = basename($_FILES["attachment"]["name"][$key]);

    if (
$error == UPLOAD_ERR_OK)
    {
        if (
move_uploaded_file($tmp_name, "/tmp/".$name) )
           
$uploaded_array[] .= "Uploaded file '".$name."'.<br/>\n";
        else
           
$errormsg .= "Could not move uploaded file '".$tmp_name."' to '".$name."'<br/>\n";
    }
    else
$errormsg .= "Upload error. [".$error."] on file '".$name."'<br/>\n";
}
?>
up
6
eslindsey at gmail dot com
5 years ago
Also note that since MAX_FILE_SIZE hidden field is supplied by the browser doing the submitting, it is easily overridden from the clients' side.  You should always perform your own examination and error checking of the file after it reaches you, instead of relying on information submitted by the client.  This includes checks for file size (always check the length of the actual data versus the reported file size) as well as file type (the MIME type submitted by the browser can be inaccurate at best, and intentionally set to an incorrect value at worst).
up
9
michael
4 years ago
Just a little note, when I was trying to get this to work on my webserver I got error telling me the permissions were wrong, I checked and couldn't see anything wrong then I thought to try "./" for my upload directory instead of the full address which was something like "home/username/public_html/uploaddir". This will save it in the same directory as your script for the program above thats something like

<?php
// In PHP versions earlier than 4.1.0, $HTTP_POST_FILES should be used instead
// of $_FILES.

$uploaddir = './';//<----This is all I changed
$uploadfile = $uploaddir . basename($_FILES['userfile']['name']);

echo
'<pre>';
if (
move_uploaded_file($_FILES['userfile']['tmp_name'], $uploadfile)) {
    echo
"File is valid, and was successfully uploaded.\n";
} else {
    echo
"Possible file upload attack!\n";
}

echo
'Here is some more debugging info:';
print_r($_FILES);

print
"</pre>";

?>

I know something trivial but when your new to this, those kind of things elude you.
up
4
Anonymous
1 year ago
Normalizing $_FILES structure:

<?php
    $files
= [];
   
$fix = function (&$files, $values, $prop) use (&$fix) {
        foreach (
$values as $key => $value) {
            if (
is_array($value)) {
               
$fix($files[$key], $value, $prop);
            } else {
               
$files[$key][$prop] = $value;
            }
        }
    };
    foreach (
$_FILES as $name => $props) {
        foreach (
$props as $prop => $value) {
            if (
is_array($value)) {
               
$fix($files[$name], $value, $prop);
            } else {
               
$files[$name][$prop] = $value;
            }
        }
    }
?>
up
2
Age Bosma
3 years ago
"If no file is selected for upload in your form, PHP will return $_FILES['userfile']['size'] as 0, and $_FILES['userfile']['tmp_name'] as none."

Note that the situation above is the same when a file exceeding the MAX_FILE_SIZE hidden field is being uploaded. In this case $_FILES['userfile']['size'] is also set to 0, and $_FILES['userfile']['tmp_name'] is also empty. The difference would only be the error code.
Simply checking for these two conditions and assuming no file upload has been attempted is incorrect.

Instead, check if $_FILES['userfile']['name'] is set or not. If it is, a file upload has at least been attempted (a failed attempt or not). If it is not set, no attempt has been made.
up
0
claude dot pache at gmail dot com
5 years ago
Note that the MAX_FILE_SIZE hidden field is only used by the PHP script which receives the request, as an instruction to reject files larger than the given bound. This field has no significance for the browser, it does not provide a client-side check of the file-size, and it has nothing to do with web standards or browser features.
up
-1
Mark
3 years ago
$_FILES will be empty if a user attempts to upload a file greater than post_max_size in your php.ini

post_max_size should be >= upload_max_filesize in your php.ini.
up
-2
gustavo at roskus dot com
3 years ago
Some hosting does not have permission to use the move_uploaded_file function should replace the copy function
up
-5
zingaburga at hotmail dot com
3 years ago
The documentation is a little unclear about the MAX_FILE_SIZE value sent in the form with multiple file input fields.  The following is what I have found through testing - hopefully it may clarify it for others.

The MAX_FILE_SIZE is applied to each file (not the total size of all files) and to all file inputs which appear after it.  This means that it can be overridden for different file fields.  You can also disable it by sending no number, or sending 0 (probably anything that == '0' if you think about it).

Example:

<form enctype="multipart/form-data" action="." method="POST">
  <!-- no maximum size for userfile0 -->
  <input name="userfile0" type="file" />

  <input type="hidden" name="MAX_FILE_SIZE" value="1000" />
  <!-- maximum size for userfile1 is 1000 bytes -->
  <input name="userfile1" type="file" />
  <!-- maximum size for userfile2 is 1000 bytes -->
  <input name="userfile2" type="file" />

  <input type="hidden" name="MAX_FILE_SIZE" value="2000" />
  <!-- maximum size for userfile3 is 2000 bytes -->
  <input name="userfile3" type="file" />

  <input type="hidden" name="MAX_FILE_SIZE" value="0" />
  <!-- no maximum size for userfile4 -->
  <input name="userfile4" type="file" />
</form>
up
-6
mail at markuszeller dot com
3 years ago
If you want to increase the upload size, it could make sense to allow it only to a specified directory and not in the php.ini for the whole domain or server. In my case it worked very well placing that into the .htaccess file like this:

php_value    upload_max_filesize    100M
php_value    post_max_size    101M

Remember, post_max_size must be bigger than the upload_max_filesize.
To Top