Leren werken met GET- en POST-verzoeken. Perl - Bestanden verzenden naar een HTTP-server met een verzoek Perl - Bestanden verzenden naar een HTTP-server met een verzoek

Het is je misschien opgevallen dat je op de meeste sites de volgende adressen kunt zien:

Http://site/index.php?blog=2

Hier kun je, zelfs zonder php te kennen, raden dat we toegang hebben tot een bestand index.php Maar weinig mensen weten wat er na het vraagteken komt. Het is vrij eenvoudig: ?blog=2 Dit is een declaratie van de globale variabele "$_GET["blog"]" met de waarde "2". Daarom geef ik een variabele door aan het script die verantwoordelijk is voor het weergeven van informatie uit de database. Laten we een klein script schrijven waarin je alles duidelijk kunt zien:

if(isset($_GET["blog"])) (
echo $_GET["blog"];
}
?>

We gebruiken de voorwaardeoperator if(); voorwaarde is de volgende regel:

Isset($_GET["blog"])

Met isset() kun je uitzoeken of de variabele die tussen haakjes is opgegeven, bestaat, dat wil zeggen dat de voorwaarde die ik in de code heb beschreven als volgt klinkt: Als de variabele $_GET["blog"] bestaat, geef dan de inhoud van deze variabele weer op het scherm. Dit is wat er gebeurde:

Ik denk dat het duidelijk is dat er een globale variabele wordt gemaakt $_GET met de ID die we in de adresbalk hebben aangegeven ( in dit geval met de identificatie “blog”)

Nu wil ik één punt verduidelijken. Stel dat we twee variabelen moeten declareren, hoe moet dat dan gebeuren? De eerste variabele wordt gedeclareerd na het vraagteken "?" De tweede variabele wordt gedeclareerd na het “&” teken ( Eerlijk gezegd weet ik niet wat dit teken is), hier is een voorbeelddeclaratie van drie variabelen:

Http://site/index.php?a=1&b=2&c=3

Hier is de uitvoercode:

if(isset($_GET["a"]) AND isset($_GET["b"]) AND isset($_GET["c"])) (
echo $_GET["a"]."
";
echo $_GET["b"]."
";
echo $_GET["c"]."
";
}
?>

De toestand klinkt als volgt:

Als er een globale variabele $_GET["a"] en een globale variabele $_GET["b"] en een globale variabele $_GET["c"] is, geef deze dan op het scherm weer, hier is het resultaat:

Formulieren

Voordat we er zijn na verzoeken, moet u begrijpen wat formulieren zijn? Waarom is het nodig? Omdat de globale variabele $_POST[""] via formulieren wordt aangemaakt. Wat is vorm? Dit zijn velden waarin de gebruiker bepaalde informatie kan invoeren. Er zijn velden met één regel, grote velden, maar ook keuzerondjes en selectievakjes. Laten we alles in volgorde bekijken...

Het formulier is een tag:

Het formulier heeft attributen, ik zal de meest voorkomende opsommen:

Laten we een formulier maken:

Ik heb het bestand ingesteld als het handlerbestand test.php omdat ik daarin voorbeelden voor je schrijf. Ik heb de verzendmethode ingesteld op posten, omdat dit de methoden zijn die in 99,9% van de gevallen worden gebruikt. Ik heb ons formulier ook een naam gegeven: formulier

Laten we nu een duik nemen in de wereld van vormelementen. Het eerste dat u moet begrijpen, is dat bijna alle elementen een tag zijn het enige verschil zit in het attribuut type bij deze labels. Ik zal de gebruikte formulierelementen opsommen:

Ik weet zeker dat je dergelijke velden meer dan eens hebt gezien, dus hier is wat ze zeggen: “geen commentaar”

Laten we nu een kleine trainingsvragenlijst maken, waarmee we verder zullen werken. Onze taak is om een kleine vragenlijst te maken die ons de naam vertelt van de persoon die de vragenlijst invult, het geslacht, het land waar hij of zij vandaan komt, de favoriete kleur en een tekstveld waarin de gebruiker iets over zichzelf kan toevoegen. Dit is wat ik heb:

Uw achternaam Voornaam Patroniem:

Uw geslacht:
M
EN

Uit welk land kom je?

Favoriete kleur(en):

Zwart:
Rood:
Wit:
Een andere:

Over mezelf:

Merk op dat bijna elke tag een attribuut heeft waarde, waar is het voor? Het registreert de gegevens die u naar een andere pagina gaat overbrengen. Ik hoop dat het duidelijk is

Als we deze code nu in de browser uitvoeren, zien we het volgende:

Voor het formulier heb ik het attribuut gebruikt actie met betekenis test.php dit betekent, zoals ik al zei, dat de gegevens uit het formulier worden overgebracht naar het test.php-bestand.

POST-verzoek

Laten we nu PHP-code schrijven waarmee we de informatie kunnen zien die we hebben ingevoerd. Waar worden de gegevens opgeslagen? In het geval van het get-verzoek bevonden onze gegevens zich in de globale variabele $_GET[""]. Wanneer u een postverzoek doet, worden de gegevens opgeslagen in de globale variabele $_POST[""]. Tussen vierkante haakjes moet u, zoals in het geval van de globale variabele get, een identificatie schrijven. De vraag is: waar kan ik deze identificatie verkrijgen? Daarom hebben we het naamattribuut op formulierelementen nodig! Het zijn deze namen die dienen als onze sleutel in de mondiale postarray. Laten we beginnen met het beschrijven van het script:

if(isset($_POST["verzenden"])) (
echo "Volledige naam: ".$_POST["fio"]."
";
echo "Geslacht: ".$_POST["geslacht"]."
";
echo "Land van verblijf: ".$_POST["stad"]."
";

Echo "Favoriete kleur(en):
";
echo $_POST["kleur_1"]."
";
echo $_POST["kleur_2"]."
";
echo $_POST["kleur_3"]."
";
echo $_POST["kleur_4"]."
";
echo "Over jezelf: ".$_POST["about"]."

";
}
?>

De if-voorwaarde die we schreven luidt: Als er een globale variabele $_POST["submit"] is, geven we de gegevens op het scherm weer. Deze globale variabele wordt gemaakt als we op de verzendknop klikken. Daarom hebben we in dit voorbeeld het naamattribuut in de knop nodig. Je vraagt je misschien af waarom het naamattribuut van de knop optioneel is? Het is heel eenvoudig. Normaal gesproken controleert de programmeur niet de druk op de knop, maar controleert hij eerder de verzonden gegevens. Voor een correcte werking van bijvoorbeeld een contactformulier is het noodzakelijk om niet het klikken op een knop, maar de juistheid van de ingevulde gegevens bij te houden en na te gaan of deze gegevens überhaupt zijn ingevuld. In ons voorbeeld hebben we de verzonden gegevens niet gecontroleerd, maar hebben we eenvoudigweg de druk op de knop bijgehouden, om het voorbeeld te vereenvoudigen... Dit is wat we kregen:

Conclusie

Welnu, vandaag hebben we gekeken naar twee methoden voor het overbrengen van gegevens tussen scripts, en we hebben ook kennis gemaakt met formulieren. Ik hoop echt dat deze informatie op zijn minst ergens nuttig voor je zal zijn. Als u vragen of gedachten heeft, kunt u opmerkingen schrijven. Veel succes, dat is alles voor vandaag!

P.S.: Wil je dat computerspellen nog realistischer worden? directx 11 voor windows 7 kan gratis gedownload worden op windows in! Geniet van prachtige graphics!

2 juli 2009 om 16:05 uur

Perl - Bestanden met een verzoek naar een HTTP-server verzenden

Perl

Eigenlijk is er niets origineels, er is voldoende documentatie, zelfs meer dan dat, al zorgt dat laatste wel voor een hele sterke melancholie. Daarom is het gemakkelijker om in één keer praktisch te laten zien hoe en wat er wordt gedaan, dan tien keer te lezen en op de hark te stappen. Voorwaarde: Er zijn enkele binaire bestanden die zich lokaal bevinden, er is een server waarop we deze bestanden moeten plaatsen, op deze server staat een script (formulierverwerker) dat bestanden uploadt
Taak: Deze bestanden moeten via de webinterface (formulierhandler) aan de server worden toegevoegd, alsof we een browser zijn en de gegevens via het formulier verzenden.

LWP::UserAgent gebruiken

Algoritme voor het genereren van verzoeken:

Maak een verzoek aan (HTTP::Verzoek);
Maak een “browser” (LWP::UserAgent);
We definiëren er headers voor;
Stuur een verzoek;

Het is net als XML::LibXML vervelend, maar het is betrouwbaar, dus: Perl-code (1) #!/usr/bin/perl use strict; gebruik waarschuwingen; gebruik LWP::UserAgent; # Dit is het bestand dat naar mijn $file = "./files/some_file.bin"; # Dit is de URI waarnaar we het verzoek zullen sturen my $uri = "http://somedomain.com/form/action/script"; # Verzoekobject my $request = HTTP::Request->new("POST", $uri); # We maken een scheidingsteken, want als we het niet forceren, wordt het met $ua->request($request) niet opgenomen in de hoofdheader # hoewel je eenvoudig $request->as_string kunt maken na het vormen van het headerobject , dan wordt de standaard vervangen, maar we riskeren het niet mijn $boundary = "X"; mijn @rand = ("a".."z", "A".."Z"); for (0..14) ($boundary .= $rand;) # Vorm de header: $request->header("Content-Type" => "multipart/form-data;boundary=".$boundary); $request->header("Gebruiker-Agent" => " Mozilla Firefox 5.0 :-)"); $request->header("Verwijzer" => " http://eendomein.com/form"); $request->protocol("HTTP/1.0"); # Hoewel LWP::UserAgent dit zal doen, is het meteen beter # Reguliere tekstvormparameters genereren my $field = HTTP::Message->new([ "Content -Disposition" => "formuliergegevens; naam=" veldnaam"", "Content-Type" => "text/plain; charset=utf-8", ]); # We vervangen de header HTTP::Headers bij het maken van het HTTP::Message-object $field->add_content_utf8(" enige waarde"); # Zoals u kunt zien, moet er een waarde in UTF-8 $request->add_part($field) staan; # ... En zo verder, voor elk tekstveld... # Vorming van binaire parameters van het formulier open (mijn $fh, "<", $file); # А можно сначала сделать заголовок, а потом уже применить к HTTP::Message my $size = (stat $file); my $header = HTTP::Headers->nieuw; $header->header("Content-Disposition" => "formuliergegevens; naam=" bestand"; bestandsnaam=" eenbestand.bin"); # Hoewel de bestandsnaam kan worden berekend op basis van de bestandsnaam $header->header("Content-Type" => " applicatie/octet-stream"); # Of overeenkomend met het bestandstype my $file_content = HTTP::Message->new($header); $file_content->add_content($_) while<$fh>;

$request->add_part($file_content); sluit $fh; # ... Enzovoort, voor elk bestand... mijn $response = $ua->request($request); if ($response->is_success) ( print $response->content ) else (die $response->status_line )

Alles zou in orde zijn, maar als we een groot bestand moeten overbrengen, is het niet het beste vooruitzicht om het volledig naar het geheugen te downloaden om het verzoek te verzamelen. Daarom is het mogelijk om een verzoek via een stream via een socket te verzenden: Perl code (2) #!/usr/bin/perl use strict; gebruik waarschuwingen; gebruik HTTP::Headers; gebruik HTTP::Bericht; gebruik HTTP::Verzoek; gebruik HTTP::Reactie; gebruik IO::Socket::INET; # Dit is het bestand dat naar mijn $file = "./files/some_file.bin"; # Dit is de URI waarnaar we het verzoek zullen sturen my $uri = "http://somedomain.com/form/action/script"; # Omdat we een socket gaan gebruiken, hebben we het domein, de poort en het pad afzonderlijk nodig my ($domain, $port, $path) = $uri =~ m/^(?:https?\:\/\/)?( [^\/\:]+)(?:\:(\d+))?(.+)$/; $poort ||= 80; # Standaard # Een fiets is natuurlijk goed, maar je kunt eenvoudig headers en een niet-binaire verzoektekst maken met behulp van een kant-en-klare module my $header = HTTP::Headers->new; $header->header("Content-Type" => "multipart/form-data"); mijn $request = HTTP::Request->new("POST", $uri, $header); # In plaats van $path hebben we $uri, zo zou het moeten zijn ;-) $request->protocol("HTTP/1.0"); # Vreemd dat HTTP::Request standaard het protocol niet instelt, dus stellen wij dat zelf in # Voor kleine hoeveelheden data, bijvoorbeeld tekstvelden, zal een fiets ook overbodig zijn # (SFCI) De voorwaarden zijn hetzelfde als in de vorige code (1) mijn $ veld = HTTP::Message->new([ "Content-Disposition" => "form-data; name=" veldnaam"", "Content-Type" => "text/plain; charset=utf-8", ]); $field->add_content_utf8(" enige waarde"); # En ook hier utf8 $request->add_part($field); # ... Enzovoort, voor elk tekstveld... # Vervolgens verdelen we ons verzoek, maar zonder bestanden, in de hoofdkop en het eerste deel van de inhoud # We verdelen met een reguliere expressie omdat $request->headers->as_string niet de eerste regel van het verzoek retourneert, namelijk het POST-commando, # en je kunt de regel natuurlijk zelf verzamelen, maar ik ben lui. mijn ($head, $content) = $request->as_string =~ m/^(.+?)\n\n(.+)$/s # We hebben niet genoeg inhoud, dus we hebben het afgekapt -- $content = substr($content, 0, -4); dezelfde grens $content =~ s/(\-\-[^\n]+)$//s; grens = $1; # Bereken de voorlopige lengte van het verzoek my $length = lengte $content # Nu onze bestanden: my $files = ; my $size = (stat $f_header = HTTP::Headers->new). ; $f_header->header("Content-Disposition" => "formuliergegevens; naam=" bestand"; bestandsnaam=" eenbestand.bin"); $f_header->header("Content-Type" => " applicatie/octet-stream"); $f_header = $boundary."\n".$f_header->as_string."\n"; # Voeg toe aan de lengte van het verzoek $length += lengte $f_header; $length += $size; # Eigenlijk , de procedure staat hieronder alleen voor gevallen waarin er veel bestanden zijn # Vervolgens moeten we eerst de lengte van de inhoud berekenen, omdat deze (de lengte) zal worden aangegeven in de hoofdkop push @($files). (header => $f_header, file => $file); # ... En zo verder, voor elk bestand... # Dus we zijn allemaal klaar $length += lengte $boundary."--"; tel ook de eindregel # Open de socket my $socket = IO::Socket: :INET->new($domain.tray.$port) || Naar de lengte van de hoofdheader $head .= "\nContent-Length: ".$length; # Stuur de header en het eerste (tekst) deel van de inhoud print $socket $head; print $socket "\n\n"; bestand (@($files)) ( print $socket $file->(header); (mijn $fh, "<", $file->(bestand)); print $socket $_while<$fh>;<$socket>print $socket "\n";

sluit $fh; ) # Stuur het einde van het bestand naar de socket print $socket $boundary."--"; # Stuur het einde van het bestand naar de socket shutdown($socket, 1); # Ontvang een antwoord van de socket en parseer het mijn $response = HTTP::Response->parse(join ("",

)); if ($response->is_success) ( print $response->content ) else ( die $response->status_line ) Goed gedaan (SFCI) Ik zou willen opmerken dat alles wat cursief in de code staat, moet worden vervangen door de overeenkomstige waarden van de taakvoorwaarde Opmerking: SFCI - Speciaal voor idioten van copipaster.

In deze les bekijken we technieken voor het doorgeven van gegevens tussen formulieren en pagina's. Dergelijke methoden zijn POST en GET. We zullen elk afzonderlijk en in meer detail bespreken. Over het algemeen is dit nodig voor de communicatie tussen formulieren. We vullen bijvoorbeeld enkele velden op een pagina in en moeten deze voor verwerking naar een andere pagina overbrengen.
GET-methode in PHP

Laten we eerst eens kijken naar de GET-methode. Dit is wanneer alle variabelen en hun waarden rechtstreeks door het adres worden doorgegeven. Aan de hand van een voorbeeld zul je alles zien en zelfs begrijpen hoe de meeste sites en forums werken. We hebben bijvoorbeeld een html-pagina zoals deze:

Voorbeeldpagina voor het doorgeven van variabelen met Get
link Zie de link? Het is complex en bestaat uit verschillende delen. Laten we het stuk voor stuk opsplitsen:
index.php https://site
? — domeinadres of, zoals het ook wel wordt genoemd, host.
— een PHP-pagina die het verzoek zal verwerken. & .
— symbool van scheiding tussen het adres en het blok met variabelen. Vervolgens komen de variabelen en hun waarden, gescheiden door het symbool
naam=Sergey- hetzelfde, variabele leeftijd, waarde 22.

We hebben alles uitgezocht, laten we nu eens kijken hoe dit in php wordt verwerkt met behulp van de GET-methode.
Zoals u zich herinnert, zijn we naar de index.php-pagina gegaan:

Allereerst een advies: controleer ALTIJD uw variabelen op juistheid: op leegheid, op naleving van geldige waarden, enzovoort. Omdat alles via de adresbalk wordt verzonden, kunnen de gegevens eenvoudig worden vervangen en de site beschadigen. Nu wat betreft de code zelf: we hebben met behulp van de naam- en leeftijdsvariabelen gecontroleerd op leegheid en als ze niet leeg waren, hebben we ze weergegeven, en als ze leeg waren, hebben we dit eenvoudigweg gerapporteerd.
Het is simpel, ben je het er niet mee eens? U kunt bijvoorbeeld een HTML-pagina maken en koppelingen maken via variabelen in het menu, en in index.php de variabele verwerken en een bepaalde pagina weergeven, afhankelijk van de ontvangen waarde. Welnu, we zullen hier later over praten, in een artikel over het helemaal opnieuw maken van een website in PHP. Om niets te missen, raad ik u aan zich te abonneren op RSS.

POST-methode in PHP

Om te demonstreren hoe deze methode werkt, hebben we iets meer nodig dan een simpele regel met een adres :) We zullen een HTML-pagina moeten maken met een formulier om in te vullen, maar dat is oké, ik geef je een kant-en-klaar voorbeeld:

Voorbeeldpagina voor het doorgeven van variabelen met behulp van Post Vul de velden in om informatie over te dragen:

Voer uw naam in:

Geef uw leeftijd aan:

Daarom hebben we een HTML-pagina gemaakt met een eenvoudig formulier. Houd er rekening mee dat de POST-methode alleen in een formulier kan worden gebruikt.
De eerste parameter van het formulier is “methode”, deze definieert de methode die we voor de overdracht zullen gebruiken. Zoals je misschien al geraden hebt, is dit GET of POST. Als GET is ingesteld, worden bovendien alle veldnamen (in de vorm van namen van variabelen), evenals hun waarden, door verwijzing doorgegeven, zoals in de sectie over de GET-methode. Als POST is ingesteld, worden alle namen en waarden van variabelen als browserverzoek naar de webserver verzonden. Dat wil zeggen dat ze niet zichtbaar zijn in de adresbalk. In veel gevallen is dit erg handig. POST is ook veiliger, wat begrijpelijk is, omdat variabelen met hun waarden niet meer zo eenvoudig te bewerken zijn, hoewel het ook wel mogelijk is.

De tweede vormparameter is ‘actie’. Dit is het pad en de naam van het scriptbestand waaraan we de gegevens doorgeven. In ons geval is dit index.php. Dit pad kan volledig worden verzonden, dat wil zeggen als volgt: action = “https://my_site.ru/index.php”. Als u de waarde van de parameter "action" niet opgeeft, wordt alle informatie overgebracht naar het hoofdscript, dat wil zeggen de indexpagina index.php van uw site, wat vrij logisch is.

Nu halen we de gegevens uit ons formulier. Omdat we het hebben doorgegeven aan index.php, staat hieronder de code van deze specifieke pagina:

"; echo "naam - "; echo $_POST["gebruikersnaam"]; echo "
age - "; echo $_POST["age"]; echo " years"; ) else ( echo "Variabelen zijn niet aangekomen. Controleer alles opnieuw."; ) ?>

Vergeet niet te controleren op leegte en geldige waarden. Vervolgens moeten we verduidelijken waarom onze variabelen gebruikersnaam en leeftijd worden genoemd? En kijk naar de velden van het formulier dat we hierboven hebben gemaakt. Zie daar invoer naam = "gebruikersnaam" type = "tekst"? Dit is waar de naamparameter de naam specificeert van de variabele die we met dit veld zullen krijgen. Hetzelfde geldt voor de leeftijd. Ik hoop dat het duidelijk is. Welnu, het verkrijgen van een variabele en de waarde ervan via POST verschilt bijna niet van GET, wat we hierboven hebben besproken.

Nou, het bleek een grote les te zijn, maar wel een van de nuttigste, omdat het doorgeven van variabelen tussen formulieren en pagina's precies de interactiviteit is waarvoor we PHP gebruiken.