Er kunnen meerdere bestanden worden geüpload met behulp van verschillende naam voor invoer.
Het is ook mogelijk om meerdere bestanden tegelijk te uploaden en de informatie automatisch in arrays voor u te laten ordenen. Om dit te doen, moet u in het HTML-formulier dezelfde syntaxis voor het indienen van arrays gebruiken als bij meerdere selecties en selectievakjes:
Waarschuwing
Vanaf PHP 5.2.12 fungeert de configuratie-instelling max_file_uploads als een limiet voor het aantal bestanden dat in één verzoek kan worden geüpload. U moet ervoor zorgen dat uw formulier niet probeert meer bestanden in één verzoek te uploaden dan deze limiet.
14 jaar geleden
Bij het uploaden van meerdere bestanden wordt de variabele $_FILES aangemaakt in de vorm:
Array
=> Array
=> foo.txt
=> bar.txt
)
=> Array
=>tekst/gewoon
=>tekst/gewoon
)
=> Array
=> /tmp/phpYzdqkD
=> /tmp/phpeEwEWG
)
=> Array
=> 0
=> 0
)
=> Array
=> 123
=> 456
)
Ik vond dat het voor een beetje schonere code zorgde als ik de geüploade bestanden in het formulier had staan
Array
=> Array
=> foo.txt
=>tekst/gewoon
=> /tmp/phpYzdqkD
=> 0
=> 123
)
=> Array
=> bar.txt
=>tekst/gewoon
=> /tmp/phpeEwEWG
=> 0
=> 456
)
Ik heb een snelle functie geschreven die de array $_FILES naar de schonere (IMHO) array zou converteren.
Functie reArrayFiles (& $file_post ) (
$file_ary = array();
$file_count = count($file_post["naam"]);
$file_keys = array_keys($file_post);
Voor ($i = 0; $i<
$file_count
;
$i
++) {
foreach ($file_keys als $key) (
$file_ary [$i][$key] = $file_post [$key][$i];
}
}
Retourneer $file_ary;
}
?>
Nu kan ik het volgende doen:
If($_FILES["uploaden"]) (
$file_ary = reArrayFiles($_FILES["ufile"]);
Foreach ($file_ary als $file) (
druk "Bestandsnaam: " af. $bestand["naam"];
druk "Bestandstype: " af. $bestand["type"];
druk "Bestandsgrootte: " af. $bestand["grootte"];
}
}
?>
5 jaar geleden
Dit is ook nodig voor elementen.
Dus als je een invoerelement als dit hebt:
Dit moet worden geschreven als
anders kun je maar één van de bestanden krijgen.
9 jaar geleden
Hier is een functie om de indicatoren van een multidimensionaal probleem op te lossen, zodat ze gemakkelijker kunnen worden geparseerd bij het uploaden van bestanden. Er is een enkele veldarray van $_FILES als parameter nodig en elk afzonderlijk geüpload bestand wordt gescheiden op basis van een numerieke sleutel. Dit maakt iteratie mogelijk zoals:
fixFilesArray($_FILES["array_van_bestanden"]);
foreach ($_FILES [ "array_of_files" ] als $position => $file ) (
// zou een array moeten uitvoeren met de indexnaam, het type, de tmp_name, de fout en de grootte
var_dump($bestand);
}
?>
Hier is de code:
/**
* Corrigeert de vreemde indexering van meerdere bestandsuploads vanuit het formaat:
*
* $_FILES["veld"]["sleutel"]["index"]
*
* Naar de meer standaard en toepasselijke:
*
* $_FILES["veld"]["index"]["sleutel"]
*
* @param array $bestanden
* @auteur Corey Ballou
* @link http://www.jqueryin.com
*/
functie fixFilesArray (& $files )
{
$names = array("naam" => 1, "type" => 1, "tmp_name" => 1, "fout" => 1, "grootte" => 1);
Foreach ($bestanden als $key => $part) (
// ga alleen om met geldige sleutels en meerdere bestanden
$sleutel = (tekenreeks) $sleutel ;
if (isset($names [ $key ]) && is_array ($part )) (
foreach ($deel als $position => $value ) (
$bestanden [ $positie ][ $sleutel ] = $waarde ;
}
// verwijder oude sleutelreferentie
unset($bestanden [$sleutel]);
}
}
}
?>
3 jaar geleden
Dit is een heel eenvoudig voorbeeld:
echo "
" ;
$img = $_FILES["img"];als(!leeg($img ))
{
$img_desc = reArrayFiles($img);
print_r($img_desc);Foreach($img_desc als $val )
{
$nieuwenaam = date("YmdHis" , tijd()). mt_rand(). ".jpg";
move_uploaded_file ($val [ "tmp_name" ], "./uploads/" . $newname );
}
}functie reArrayFiles ($bestand)
{
$file_ary = array();
$file_count = count($file["naam"]);
$file_key = array_keys($bestand);For($i = 0 ; $i< $file_count ; $i ++)
{
foreach($file_key als $val)
{
$bestand_ary [ $i ][ $val ] = $bestand [ $val ][ $i ];
}
}
retourneer $file_ary;
}2 jaar geleden
Ooit moest ik onderhoud uitvoeren aan een enorm ERP-systeem met meerdere upload-ingangen in een array. Net als dit:
De $_FILES array wordt als volgt gemaakt:
Array
=> Array
=> Array
=> test.c
=> test
)
=> Array
=> tekst/x-csrc
=> applicatie/octet-stream
)
=> Array
=> /opt/lampp/temp/phpuf3KNj
=> /opt/lampp/temp/php0yPZap
)
=> Array
=> 0
=> 0
)
=> Array
=> 1960
=> 8661
)
=> Array
=> Array
=> jefrey.html
=> notas.txt
)
=> Array
=> tekst/html
=>tekst/gewoon
)
=> Array
=> /opt/lampp/temp/php87nfyu
=> /opt/lampp/temp/phpUBlvVz
)
=> Array
=> 0
=> 0
)
=> Array
=> 583
=> 191
)
Ik ben erin geslaagd om deze array als volgt opnieuw te rangschikken:
Array
=> Array
=> Array
=> test.c
=> tekst/x-csrc
=> /opt/lampp/temp/phpuf3KNj
=> 0
=> 1960
)
=> Array
=> test
=> applicatie/octet-stream
=> /opt/lampp/temp/php0yPZap
=> 0
=> 8661
)
=> Array
=> Array
=> jefrey.html
=> tekst/html
=> /opt/lampp/temp/php87nfyu
=> 0
=> 583
)
=> Array
=> notas.txt
=>tekst/gewoon
=> /opt/lampp/temp/phpUBlvVz
=> 0
=> 191
)
Hier is mijn fragment:
functie reArrayFilesMultiple (& $files ) (
$uploads = array();
foreach($_FILES als $key0 => $FILES ) (
foreach($FILES als $key => $waarde ) (
foreach($waarde als $key2 => $waarde2 ) (
$uploads [ $sleutel0 ][ $sleutel2 ][ $sleutel ] = $waarde2 ;
}
}
}
$bestanden = $uploads;
retourneer $uploads; // misbruikprobleem voorkomen
}
?>
3 jaar geleden
Dit is slechts een wijziging van de code die hier door "phpuser" bovenaan staat. Zijn/haar versie vereist dat de array $file_post die aan de functie wordt doorgegeven, is gemaakt door een formulier dat is ingediend met de set meerdere attributen. Als er meerdere zijn ingesteld in de html-invoertag, is $_FILES["fileInputName"]["name"] een array, ongeacht of er slechts één bestand wordt verzonden of meerdere. Maar wanneer wordt gebruikt zonder het meerdere attribuut, dan is $_FILES["fileInputName"]["name"] geen array, maar bevat het de string met de bestandsnaam. Om deze handige functie te gebruiken met of zonder meerdere sets en om een array terug te krijgen die je in beide gevallen kunt "foreachen", gebruik je deze aanpassing:
functie reArrayFiles(&$file_post)
{
$file_ary = array();
$multiple = is_array($file_post["naam"]);
$file_count = $meerdere ? count($file_post["naam"]): 1;
$file_keys = array_keys($file_post);
Voor ($i=0; $i<$file_count; $i++)
{
foreach ($file_keys als $key)
{
$file_ary[$i][$key] = $meerdere ? $file_post[$key][$i] : $file_post[$key];
}
}
Retourneert $file_ary;
}
3 jaar geleden
Recursieve oplossing voor complexe situaties (ondersteunt alle geneste arrays, inclusief geïndexeerde arrays)
functie getFixedFilesArray() (
$walker = functie ($arr, $fileInfokey, opvraagbare $walker) (
$ret = array();
foreach ($arr als $k => $v) (
als (is_array($v)) (
$ret[$k] = $walker($v, $fileInfokey, $walker);
) anders (
$ret[$k][$fileInfokey] = $v;
}
}
retourneer $ret;
};
$bestanden = array();
foreach ($_FILES als $name => $waarden) (
// init voor array_merge
if (!isset($bestanden[$naam])) (
$bestanden[$naam] = array();
}
if (!is_array($values["fout"])) (
// normale syntaxis
$bestanden[$naam] = $waarden;
) anders (
// HTML-arrayfunctie
foreach ($waarden als $fileInfoKey => $subArray) (
$files[$name] = array_replace_recursive($files[$name], $walker($subArray, $fileInfoKey, $walker));
}
}
}
$ bestanden retourneren;
}
10 jaar geleden
Als u bestanden probeert te uploaden met multidimensionale namen zoals deze:
Je krijgt een onverwacht formaat zoals dit:
array(
"inzending" => array
"name" => array("screenshot" => "monster_wallpaper.jpg" ),
"type" => array("screenshot" => "afbeelding/jpeg" ),
"tmp_name" => array("screenshot" => "/tmp/php48lX2Y" ),
"fout" => array("screenshot" => 0),
"grootte" => array("screenshot" => 223262 ),
),
....
?>
U kunt de volgende functie gebruiken om de array recursief opnieuw te formatteren in het gebruikelijke formaat:
function format_files_array ($files, $name = null, & $new = false, $path = false)(
$names = array("name" => "naam" , "type" => "type" , "tmp_name" => "tmp_name" , "error" => "error" , "size" => "size" ) ;
Foreach($files as $key => & $part )
{
$sleutel = (tekenreeks) $sleutel ;
if(in_array ($sleutel, $names))
$naam = $sleutel;
if(! in_array ($sleutel, $names))
$pad = $sleutel;
if(is_array($deel))
$part = format_files_array ($part, $name, $new, $path);
elseif(! is_array($part))
{
$huidig =& $nieuw ;
foreach($pad als $p)
$huidig =& $huidig [$p];
$huidig [$naam] = $deel;
niet ingesteld($pad);
$naam = nul;
}
}
Retourneer $nieuw;
}
?>
In PHP moet je vaak bestanden naar de server uploaden... het is fijn als je site de mogelijkheid heeft om bestanden naar de site te uploaden: afbeeldingen of andere tekstbestanden of andere formaten... daar zullen we het in dit artikel over hebben ...
We moeten dus leren hoe we een bestand naar de server kunnen uploaden met behulp van PHP. Om dit te doen, moeten we weten dat dergelijke downloads plaatsvinden met behulp van een eenvoudig meerdelige vormen, die een speciaal veld heeft voor het uploaden van een bestand.
De parameter enctype in dit formulier moet worden ingesteld op multipart/form-data. Verzonden met de POST-methode.
Hoe meerdelige formulieren in PHP te verwerken
Nadat u op de knop "Uploaden" hebt geklikt, plaatst PHP het bestand in een tijdelijke map en geeft het bestand een tijdelijke naam (deze verschilt van de naam die wordt geladen - u ziet het hieronder). En onmiddellijk worden er 4 variabelen van de globale array $_FILES aangemaakt:
- $_FILES["uploadbestand"]["naam"]- de naam van het bestand voordat het naar de server werd verzonden (dat wil zeggen het origineel);
- $_FILES["uploadbestand"]["grootte"]- grootte van het ontvangen bestand in bytes;
- $_FILES["uploadbestand"]["type"]- MIME-type van het ontvangen bestand (als de browser het heeft kunnen detecteren), bijvoorbeeld: afbeelding/gif, afbeelding/png, afbeelding/jpeg, tekst/html;
- $_FILES["uploadbestand"]["tmp_name"]- bevat de naam van het bestand in de tijdelijke map, bijvoorbeeld: /tmp/php57Opq2Y;
- $_FILES["uploadfile"]["error"] - Foutcode die kan optreden bij het uploaden van een bestand. Sleutel ["fout"] werd toegevoegd in PHP 4.2.0.
Let op: na het voltooien van het script voor het uploaden van een bestand naar de server, wordt het tijdelijke bestand verwijderd, dus u moet dit bestand vanuit de tijdelijke map naar een bepaalde map kopiëren, bijvoorbeeld bestanden met behulp van de functie kopiëren(); Het is niet nodig om de functie move() te gebruiken, omdat kopiëren op dit moment twee voordelen heeft: het tijdelijke bestand wordt vanzelf verwijderd en als de tijdelijke map zich op een ander medium bevindt, wordt er een foutmelding weergegeven.
Aanwijzing: het proces zou moeten starten op basis van de voorwaarde dat op de knop "Downloaden" wordt gedrukt, dat wil zeggen bijvoorbeeld: if($_POST["submit"])(voer vervolgens de acties uit)
Een afbeelding die duidelijk de 4 gemaakte variabelen van de globale array $_FILES laat zien:
Ik denk dat nu alles duidelijk voor je is, wat waar gaat en wat waar wordt gemaakt... en dan manipuleer ik deze velden, we kunnen met dit formulier in PHP gaan werken
Het script zelf zou er ongeveer zo uit kunnen zien:
if($_POST["verzenden"])(
@mkdir("bestanden", 0777); // maak een map, als deze niet bestaat, zal er geen fout optreden, stel de rechten in
/*echo "
";";*/
print_r($_FILES);
echo "
$uploadmap = "bestanden/";
$uploadfile = $uploaddir.basename($_FILES["uploadbestand"]["naam"]);
If(kopie($_FILES["uploadbestand"]["tmp_naam"], $uploadbestand))(
echo "
Het bestand is succesvol geüpload naar de server
";)anders(
echo "
Kan het bestand niet naar de server uploaden
";Uitgang;
}
//Gegevens over het gedownloade bestand
echo "
Informatie over het bestand dat naar de server is geüpload:
";echo "
Oorspronkelijke naam van het geüploade bestand: ".$_FILES["uploadbestand"]["naam"]."
";echo "
MIME-type van het geüploade bestand: ".$_FILES["uploadbestand"]["type"]."
";echo "
Geüploade bestandsgrootte in bytes: ".$_FILES["uploadbestand"]["grootte"]."
";echo "
Tijdelijke bestandsnaam: ".$_FILES["uploadbestand"]["tmp_name"]."
";}
Dit is hoe het proces van het uploaden van een bestand naar de server met behulp van PHP plaatsvindt.
Ik hoop dat het nuttig was voor iemand!
19KVandaag wil ik je vertellen over verschillende situaties die verband houden met het uploaden van bestanden naar de server met behulp van PHP-scripts. Ik zal proberen voorbeelden te geven van zowel de eenvoudigste bestandsupload als de multi-upload met behulp van het verplaatste geüploade bestand PHP.
Om bestanden naar de server te uploaden. Allereerst moet u een HTML-formulier maken met een bestandsinvoerveld. Voeg er vervolgens een PHP-script aan toe, dat het bestand naar de opgegeven map verplaatst. Volg deze stappen om een bestand naar de server te uploaden met behulp van een PHP-script:
- Maak een eenvoudig HTML-formulier: u hebt een eenvoudig formulier nodig met de mogelijkheid om een bestand op te geven. Het bevindt zich in het basic.php-bestand:
Basisbestand uploaden
De bovenstaande code is vereist om het formulier te maken. Zodra de gebruiker een bestand selecteert en op de knop Uploaden klikt, verzendt het formulier gegevens met behulp van de POST-methode op dezelfde pagina, omdat het bestand basic.php is opgegeven als de handler:
Belangrijk: vergeet niet toe te voegen enctype=”multipart/form-data” in de tag .
- We maken een PHP-script om het downloadformulier te verwerken. In PHP is alle informatie over geüploade bestanden opgenomen in de globale variabele $_FILES. Dat wil zeggen, met $_FILES kunt u controleren of een bestand is gedownload. Als het bestand is geüpload, kunt u het naar de gewenste map verplaatsen met behulp van de PHP-functie move_uploaded_file:
De bovenstaande code controleert of de gebruiker het bestand heeft gedownload. Als het bestand wordt gedownload, verplaatsen we het bestand naar de opgegeven map. In het bovenstaande script verplaatsen we het bestand naar dezelfde map waar het bestand basic.php zich bevindt.
Hieronder vindt u het volledige PHP-versie van voorbeeld van geüpload bestand:
Basisbestand uploaden
Test dit voorbeeld van een PHP-verplaatsing-geupload bestand niet op de server. Het voldoet niet aan de beveiliging en is speciaal gemaakt om te demonstreren hoe u bestanden kunt uploaden met behulp van PHP.
Vraag: Waarom is het bovenstaande script onveilig?
Antwoord: Met behulp van het bovenstaande script kunt u elk type bestand naar de server uploaden. Dat wil zeggen, als u het script in deze vorm op een “live” server gebruikt, kan elke hacker zijn eigen PHP-scripts uploaden en uw site en server hacken.
Even later zullen we meer in detail praten over het beschermen van het script voor het uploaden van bestanden naar de server.
Wat is $_FILES?
$_FILES is een globale variabele in PHP, zoals $_POST of $_GET . Het is een associatieve array die informatie bevat over het geüploade bestand met behulp van de HTTP POST-methode.
Dat wil zeggen, als we print_r($_FILES) uitvoeren voor het bovenstaande script, krijgen we de volgende informatie:
Array ( => Array ( => upload-bestand-php.jpg => afbeelding/jpeg => /Applications/XAMPP/xamppfiles/temp/phpcQiYhh => 0 => 6887))
Dat wil zeggen, voor elk veld er wordt een element in de array gemaakt. Als je creëert , dan wordt de elementnaam ook gewijzigd in test . Bijvoorbeeld:
Array ( => Array ( => upload-bestand-php.jpg => afbeelding/jpeg => /Applications/XAMPP/xamppfiles/temp/phpcQiYhh => 0 => 6887))
Voor elk invoerbestand dat wordt verplaatst met behulp van het geüploade bestand PHP, worden nu vijf elementen gemaakt ( naam, type, tmp_naam, fout, maat). Laten we deze elementen eens nader bekijken:
- naam: bevat de naam van het bestand dat door de gebruiker is geüpload. Als u het bestand abc.txt in de browser laadt, wordt het naamelement abc.txt genoemd;
- type: het type van het geüploade bestand, of mime-type om precies te zijn. Voor een JPG-bestand heeft dit element de waarde image/jpeg . Als u tekst laadt, krijgt het element de waarde text/plain . Het mime-type zal verschillend zijn voor verschillende bestandstypen. Hieronder staan de meest voorkomende mime-typen:
- JPEG: afbeelding/jpeg;
- PNG: afbeelding/png;
- Tekst: tekst/gewoon;
- Woord: applicatie/msword.
- tmp_name: Tijdelijke locatie voor het gedownloade bestand. Dit pad kan worden gewijzigd in de upload_tmp_dir variabele die is opgegeven in het php.ini-bestand.
- fout: foutinformatie. Bevat het type fout dat is opgetreden tijdens het downloadproces. Bijvoorbeeld als de bestandsgrootte het maximum overschrijdt of als er geen bestand is opgegeven om te downloaden. Voor elke fout die optreedt, is er een numerieke waarde en een constante. Hieronder vindt u een volledige lijst met fouten die kunnen optreden in PHP verplaatst voorbeeld van geüpload bestand:
- UPLOAD_ERR_OK (waarde 0). Geeft aan dat het bestand zonder fouten is gedownload;
- UPLOAD_ERR_INI_SIZE (waarde 1). De bestandsgrootte is groter dan gespecificeerd in de upload_max_filesize variabele in het php.ini bestand;
- UPLOAD_ERR_FORM_SIZE (waarde 2). De bestandsgrootte overschrijdt de waarde die is ingesteld in de formuliervariabele MAX_FILE_SIZE;
- UPLOAD_ERR_PARTIAL (waarde 3). Het bestand is niet volledig gedownload;
- UPLOAD_ERR_NO_FILE (waarde 4). Er is geen bestand om te downloaden;
- UPLOAD_ERR_NO_TMP_DIR (waarde 6). De opgegeven map voor tijdelijke opslag bestaat niet;
- UPLOAD_ERR_CANT_WRITE (waarde 7). Het bestand kan niet naar schijf worden geschreven.
- size: grootte van het geüploade bestand in bytes.
Wat is move_uploaded_file?
move_uploaded_file is een functie die een geüpload bestand van een tijdelijke map naar een doelmap verplaatst. Voordat move_uploaded_file wordt verplaatst, controleert PHP of het bestand dat is opgegeven in de post-HTTP-methode is geüpload.
Als het bestand met succes is verplaatst, ontvangt u een waar of onwaar antwoord. In het eerste voorbeeld hebben we de volgende regel code gebruikt:
move_uploaded_file($_FILES["invoerbestand"]["tmp_name"], $destiation_dir)
Laten we het nu netjes doen en de informatie weergeven:
if(move_uploaded_file($_FILES["inputfile"]["tmp_name"], $destiation_dir))( echo "Bestand geüpload" ) else( echo "Bestand niet geüpload" )
De limiet voor de uploadbestandsgrootte wijzigen
Elk bestandsuploadformulier moet een maximale grootte hebben, anders zullen gebruikers uiteindelijk omvangrijke bestanden uploaden. Er zijn twee manieren om een limiet in te stellen voor het verplaatsen van geüploade PHP-bestanden:
- Het PHP.ini-bestand heeft een speciale variabele upload_max_filesize, die verantwoordelijk is voor de maximale grootte van geüploade bestanden. Het volgende is een regel uit php.ini die de grootte van geüploade bestanden beperkt tot 20 MB: upload_max_filesize = 20M.
- Als het geüploade bestand groter is, ontvangt de gebruiker een UPLOAD_ERR_INI_SIZE-fout of de waarde “2” in de $_FILES variabele. Het is belangrijk op te merken dat de waarde van de upload_max_filesize variabele de waarde van de post_max_size variabele, gespecificeerd in php.ini, niet mag overschrijden;
- U kunt de grootte van het geüploade bestand beperken door een verborgen invoerelement met de naam UPLOAD_ERR_INI_SIZE in het uploadformulier te plaatsen. Je kunt het als volgt doen: .
Als u de bestandsgrootte aanzienlijk wilt vergroten, vergeet dan niet de uitvoeringstijd van PHP-scripts te wijzigen.
Hoe u een PHP-bestandsuploadscript kunt beveiligen
Nu weet u hoe u de grootte van geüploade bestanden kunt beperken en hoe u de typen bestanden kunt identificeren die gebruikers uploaden. Het is tijd om te zorgen voor de veiligheid van ons voorbeeld van een PHP-verplaatsing-geupload bestand.
We voorkomen bijvoorbeeld dat gebruikers jpeg-bestanden groter dan 1 MB uploaden. Stel de juiste limiet in in de upload_max_filesize variabele in het php.ini bestand. Hieronder vindt u een verbeterde versie van het script:
Veilige bestandsupload
Meerdere bestanden uploaden met behulp van een PHP-script
Je kunt meerdere bestanden tegelijk uploaden met $_FILES en move_uploaded_file PHP. Hieronder zal ik je vertellen over twee manieren om bestanden meerdere keren te uploaden met behulp van een PHP-script:
- Verschillende invoernamen gebruiken.
- Gebruik dezelfde invoernaam, maar gebruik een array.
1. Verschillende invoernamen gebruiken:
U kunt meerdere bestanden tegelijk uploaden met behulp van meerdere invoerelementen. Zoals eerder vermeld, als we meerdere invoerelementen maken, zullen er verschillende hoofdelementen worden gemaakt in $_FILES. Bijvoorbeeld voor onderstaand formulier:
$_FILES zal een array presenteren met de volgende inhoud:
Array ( => Array ( => 20141002_094257.jpg => image/jpeg => /Applications/XAMPP/xamppfiles/temp/phpoBWrBZ => 0 => 2669096) => Array ( => 20141002_094247.jpg => image/jpeg = > /Applicaties/XAMPP/xamppfiles/temp/phpjwUmVZ => 0 => 2207657))
Het onderstaande voorbeeld van een PHP-verplaatst geüpload bestand moet worden geschreven, rekening houdend met het feit dat het ene element voor een avatar (afbeelding) is en het andere voor het uploaden van een cv ( bestand in .doc-formaat):
Meerdere bestanden uploaden
2. We gebruiken één invoerveld, maar gebruiken een array:
Net als bij andere invoertypen kunnen we voor het verplaatsen van een geüpload bestand PHP een array gebruiken met het invoertype dat is opgegeven in php. Dat is:
Dat wil zeggen dat $_FILES voor de bovenstaande HTML gegevens met de volgende structuur zal leveren:
Array ( => Array ( => Array ( => upload-bestand-php.jpg => variabele-scope-php.jpg => magische constanten.jpg) => Array ( => afbeelding/jpeg => afbeelding/jpeg => afbeelding/jpeg) => Array ( => /Applications/XAMPP/xamppfiles/temp/phpML5kOy => /Applications/XAMPP/xamppfiles/temp/phpNZbuw7 => /Applications/XAMPP/xamppfiles/temp/phpO8VFAk) => Array ( => 0 => 0 => 0) => Array ( => 6887 => 8036 => 9967)))
Download de code die in het artikel wordt gebruikt
Deze publicatie is een vertaling van het artikel “Bestand uploaden met PHP Script”, opgesteld door het vriendelijke projectteam
Maar in het begin zou ik graag een paar woorden willen zeggen over hoe bestanden worden gedownload.
Hiervoor hebben we een html-formulier nodig met een invoerveld zoals . Om bestanden naar de server over te brengen, moet u bovendien het formuliertype instellen op meerdelig. Om dit te doen, als parameter enctype waarde wordt aangegeven meerdelige/formuliergegevens.
Nadat we een formulier met een veld op de html-pagina hebben geplaatst Er verschijnt een veld in het browservenster waarin u een bestand op uw lokale computer kunt selecteren.
Nadat de gebruiker het gewenste bestand heeft geselecteerd en op de knop “Uploaden” heeft geklikt, zal het formulier de gegevens naar het PHP-script overbrengen naar de server die is opgegeven in actie vormen. Als de actie van het formulier leeg is, worden de gegevens overgebracht naar hetzelfde bestand waarin het formulier zich bevindt. Alle informatie over het gedownloade bestand wordt in een array geplaatst $_FILES. Het enige wat we moeten doen is deze informatie extraheren en het bestand verplaatsen naar de locatie die we nodig hebben.
Voordat u begint met het schrijven van het verwerkingsscript meerdelige vormen, moet u het configuratiebestand bewerken php.ini om toe te staan dat bestanden naar de server worden geüpload.
PHP-configuratiebestand php.ini heeft drie parameters met betrekking tot het uploaden van bestanden naar de server:
- file_uploads = Aan - staat toe dat bestanden via HTTP naar de server worden geüpload;
- upoad_tmp_dir = /tmp - stelt de map in voor tijdelijke opslag van gedownloade bestanden;
- upload_max_filesize = 2M - stelt de maximale grootte van geüploade bestanden in.
Maak dus een nieuw bestand met de naam upload.php en kopieer de volgende code erin.