PHP og GET og POST dataoverføringsmetoder. PHP: POST og GET-forespørsler for nybegynnere
HTTP er en hyperteksttransportprotokoll, en av protokollene i TCP/IP-stakken. Protokollen ble opprinnelig laget for å sende og motta HTML-sider, men nå er den godt brukt for distribuert informasjonssystemer. Det er en av de mest brukte protokollene på World Wide Web.
Bilde 1
Basert på en forespørsel/svar-ordning. Når en klient sender en forespørsel til serveren, kan den gjøre det ved å bruke 3 typer forespørsel: GET, PUT og POST.
FÅ HTTP-protokollforespørsel
FÅ er en klientforespørsel om informasjon. Klientens nettleser sender en GET-melding for å hente sider fra den. Forespørselen har to deler:
- spørringsstreng
- overskrifter
En GET-forespørsel har ikke en datakropp, men dette betyr ikke at den ikke kan overføre data til serveren. Ved å bruke spesielle parametere i URL-linjen kan du overføre data til serveren. Skilt ? etter domenet i URL-en betyr at ytterligere parametere vil bli sendt. Figur 2 viser nøyaktig hvilken informasjon nettleseren sender til serveren.
Figur - 2
POST og PUT HTTP-protokollforespørsel
Disse to metodene er implementert for å sende informasjon til webserveren. For eksempel, ved å bruke spesielle nettskjemaer, etter å ha fylt dem ut, sender vi dem til serveren ved å bruke POST-metoden. PUT laster opp ressurser eller data til en webserver (bilde, video).
HTTP er det ikke sikker protokoll, og POST-meldinger kan fanges opp og leses siden de ikke er kryptert. For å sikre dataoverføring ved hjelp av POST-metoden, bruk HTTPS-protokoll. Den krypterer data og kan utføre autentisering. Den implementerer også Tilleggskravå sende informasjon mellom transport- og applikasjonslaget.
Hovedforskjellene mellom POST- og GET-metodene er vist i tabell 1.
Figur 3 viser de grunnleggende reglene som må følges ved valg GET metoden eller POST for å implementere arbeidet på serveren din.
Felles for dem er at de fungerer på samme måte. Det er teknisk ingen forskjell mellom dem. Men det er ideologiske forskjeller.
Jeg skal snakke om dem i sammenheng med PHP. Vær oppmerksom på at HTTP-protokollen er indirekte relatert til PHP fordi den ble opprettet for utvekslingen html sider og PHP utvider rett og slett mulighetene til begge.
GET-forespørsel brukes til å motta data og POST brukes til å sende. (Husk at teknisk sett fungerer de likt).
Derfor, i sammenheng med PHP, basert på denne ideologien, gjorde vi følgende:
1. Hver gang du starter PHP, opprettes superglobale arrays ($_GET, $_POST) som standard.
2. Hvis spørringsstrengen inneholder spørsmålstegn(?). Alt etter det vurderes parametere GET-forespørsel, de presenteres i formatet "key"="value" og og-tegnet (&) brukes som skilletegn.
Eksempel:
FÅ /index.php?name=Andrey&etternavn=Galkin
Dette er en spørringsstreng, det er 2 parametere. disse parameterne vil gå inn i $_GET-matrisen.
3. $_POST fylles ut på en annen måte. innholdet i denne matrisen fylles ut fra "forespørselshodene". Det vil si fra et sted som er tydelig skjult for innsyn. Nettleseren tar seg av alle oppgavene med å lage slike overskrifter. Selv om noen ganger blir noe redigert i overskriftene manuelt.
Oftest brukes en postforespørsel i skjemaer (for å sende data).
For eksempel har vi et påloggingsskjema med 2 felt: pålogging og passord.
La oss forestille oss at vi bruker GET-metoden. Deretter, når vi sender inn skjemaet, vil vi gå til følgende adresse /login.php?login=Andrey&password=123 Du godtar at det ikke er trygt å overføre slik informasjon på denne måten. Hvem som helst kan åpne nettleseren din, og når de begynner å skrive inn nettstedsadressen, kan de se passordene og påloggingene dine fra loggen.
Men hvis vi spesifiserte POST-metoden, ville vi motta følgende forespørsel:
POST /login.php (login=Andrey&password=123) det som står i parentes vil bli skjult og ikke lagret på noen måte i nettleseren.
For å oppsummere:
GET er å få spesifikk side V en viss form(sortering, nåværende side blogg, søkefelt osv.).
POST - for å sende data som ikke påvirker visningen av siden, i den forstand at disse dataene kun påvirker resultatet av skriptet (pålogginger, passord, kredittkortnumre, meldinger osv.).
Og en annen god nyhet er at de for eksempel kan kombineres
POST /index.php?page=login (login=Andrey&password=123) Jeg tror jeg allerede har forklart nok hva som kommer av dette og hvilke parametere som vil gå inn i hvilken array.
I I det siste Jeg ser i økende grad spørsmål på PHPClub-forumet om emnet å lage POST- og GET-forespørsler, samt spørsmål om emnet: "Hvordan kan jeg generere en POST-forespørsel ved å bruke header-funksjonen." Jeg tror at behovet for å prikke "i" er i bruken av denne teknologien, fordi nybegynnere programmerere rett og slett ikke forstår prinsippene nettarbeid, som sådan. Så la oss begynne vår reise gjennom HTTP-protokollens verden.
1. HTTP-protokoll. Introduksjon
Jeg vil gjerne avklare en liten ting med en gang. Det forferdelige ordet protokoll er ikke annet enn en avtale mellom mange mennesker, bare i et fint øyeblikk bestemte folk seg: "La oss gjøre det på denne måten, og da vil alt bli bra." Det er ingenting å være redd for, alt er rett og slett opprørende og vi vil nå avsløre denne skam. Så, hva er HTTP-protokollen og hva brukes den til?
1.1 Klient og server
Det er ingen mirakler i verden, og spesielt i verden av programmering og Internett! Aksepter dette som en urokkelig sannhet. Og hvis programmet ikke fungerer eller ikke fungerer som ønsket, er det mest sannsynlig enten skrevet feil eller inneholder feil. Så hvordan ber nettleseren serveren om å sende den noe? Ja, veldig enkelt! Du trenger bare å slappe av litt og begynne å nyte prosessen :-)
1.2. Skriver vår første HTTP-forespørsel
Hvis du tror at alt er for komplisert, så tar du feil. Mennesket er designet på en slik måte at det rett og slett ikke er i stand til å skape noe komplekst, ellers vil han selv bli forvirret i det :-) Så det er en nettleser og det er en webserver. Nettleseren er alltid initiativtaker til datautveksling. En webserver vil aldri bare sende noe til noen slik at den sender noe til nettleseren - nettleseren må be om det. Den enkleste HTTP-forespørselen kan se slik ut:
FÅ http://www.php.net/ HTTP/1.0\r\n\r\n
- GET (oversatt fra engelsk betyr "få") - en type forespørsel; typen forespørsel kan være forskjellig, for eksempel POST, HEAD, PUT, DELETE (vi vil se på noen av dem nedenfor).
- http://www.php.net/ - URI (adresse) som vi ønsker å motta minst noe informasjon fra (naturligvis håper vi å lære HTML-siden).
- HTTP/1.0 - skriv og protokollversjon, som vi vil bruke når vi kommuniserer med serveren.
- \r\n er slutten av linjen, som må gjentas to ganger; hvorfor vil bli tydelig litt senere.
1.3 Forespørselsstruktur
La oss se på hva en HTTP-forespørsel består av. Alt er ganske enkelt. La oss starte med det faktum at en HTTP-forespørsel er en fullstendig meningsfull tekst. Hva består den av i den generelle saken? Vi vil vurdere HTTP 1.0-protokollen. Så:
Forespørselslinje [General-overskrift | Forespørselshode | Enhetsoverskrift ]\r\n[ Entitetsorgan ]
- Forespørselslinje- spørrestreng
- Metode- Metoden som Request-URI-ressursen vil bli behandlet med kan være GET, POST, PUT, DELETE eller HEAD.
- Forespørsel-URI- en relativ eller absolutt kobling til en side med et sett med parametere, for eksempel /index.html eller http://www.myhost.ru/index.html eller /index.html?a=1&b=qq. I sistnevnte tilfelle vil serveren bli sendt en forespørsel med et sett med variabler a og b med de tilsvarende verdiene, og "&"-tegnet - et og-tegnet - fungerer som en skilletegn mellom parameterne.
- HTTP-versjon- versjon av HTTP-protokollen, i vårt tilfelle "HTTP/1.0".
Format: "Metodeforespørsel-URI HTTP-versjon\r\n"
Vi er ekstremt interessert i GET- og POST-behandlingsmetoder. Med GET-metoden kan du ganske enkelt sende parametere til skriptet, og med POST-metoden kan du emulere skjemainnsending.
For GET-metoden kan Request-URI se slik ut: "/index.html?param1=1¶m2=2".
- Generelt-overskrift- hoveddelen av tittelen.
Format:
Kan bare ha to parametere: Dato eller Pragma. Dato - Greenwich-dato i formatet "Ukedag, Dag Måned År TT:MM:SS GMT", for eksempel "tirs, 15. nov. 1994 08:12:31 GMT" - dato for opprettelse av forespørselen. Pragma kan ha en enkelt no-cache-verdi, som deaktiverer sidebufring. - Forespørselsoverskrift- del av overskriften som beskriver forespørselen.
Request-Header kan ha følgende parametere: Tillat, Autorisasjon, Fra, Hvis-Modifisert-Siden, Referer, Bruker-Agent.
I dette kapittelet vil vi ikke vurdere Autorisasjonsparameteren, siden den brukes til å få tilgang til private ressurser, noe som ikke er nødvendig så ofte. Du kan lære hvordan du oppretter en autorisert tilgangshode selv på www.w3c.org. - Tillate- setter akseptable behandlingsmetoder.
Format: "Tillat: GET | HEAD\n".
Parameteren ignoreres når POST-behandlingsmetoden spesifiseres i Request-Line. Spesifiserer akseptable forespørselsbehandlingsmetoder. Proxy-servere endrer ikke Tillat-parameteren, og den når serveren uendret. - Fra - epostadresse hvem som sendte forespørselen.
Format: "Fra: adderss\r\n".
For eksempel, "Fra: [e-postbeskyttet]\r\n". - Hvis-modifisert-siden- indikerer at forespørselen ikke har blitt endret siden en og annen gang.
Format: "Hvis-modifisert-siden: dato\r\n"
Brukes kun for GET-behandlingsmetoden. Datoen angis i GMT i samme format som for Dato-parameteren i General-Header. - Henviser- en absolutt lenke til siden som forespørselen ble startet fra, dvs. en lenke til siden brukeren kom til vår.
Format: "Referrer: url\n".
Eksempel: "Referrer: www.host.ru/index.html\n". - Bruker agent- nettlesertype.
For eksempel: "Brukeragent: Mozilla/4.0\n" - Enhetsoverskrift- del av overskriften som beskriver Entity-Body-dataene.
Denne delen av forespørselen spesifiserer parametere som beskriver hoveddelen av siden. Entity-Header kan inneholde følgende parametere: Tillat, Content-Encoding, Content-Length, Content-Type, Expires, Last-Modified, extension-header. - Tillate- en parameter som ligner på Tillat fra General-Header.
- Innholdskoding- datakodingstype Entity-Body.
Format: "Innholdskoding: x-gzip | x-compress | annen type\n".
Eksempel: "Innholdskoding: x-gzip\n". Tegnet "|". betyr ordet "eller", det vil si dette eller det eller det osv.
En annen type kan indikere hvordan dataene er kodet, for eksempel for POST-metoden: "Content-Encoding: application/x-www-form-urlencoded\n". - Innhold-lengde- antall byte sendt til Entity-Body. Content-Length-verdien har en helt annen betydning for data som sendes i MIME-format, der den fungerer som en parameter for å beskrive en del av dataene - "external/entity-body". Gyldige tall er heltall fra null og oppover.
Eksempel: "Innhold-lengde: 26457\n". - Innholdstype- type overførte data.
For eksempel: "Content-Type: text/html\n". - Utløper- Tidspunktet for når siden skal fjernes fra nettleserens cache.
Format: "Utløper: dato\n". Datoformatet er det samme som datoformatet for Dato-parameteren fra General-Header. - Sist endret- tidspunktet for siste endring av de overførte dataene.
Format: "Sist endret: dato\n". Datoformatet er det samme som datoformatet for Dato-parameteren fra General-Header. - extension-header- del av overskriften, som for eksempel kan være ment å behandles av en nettleser eller annet program som mottar dokumentet. I denne delen kan du beskrive parameterne dine i formatet "ParameterName: parametervalue\n". Disse parameterne vil bli ignorert hvis klientprogrammet ikke vet hvordan de skal behandles.
For eksempel: "Cookie: r=1\r\n" - setter kjente informasjonskapsler for siden.
Og nå, etter slike forferdelige ord, la oss prøve å roe ned litt og forstå hva vi trenger? Naturligvis vil vi forstå med eksempler.
La oss forestille oss at vi trenger å få en side fra nettstedet ved å sende informasjonskapsler, ellers vil vi ganske enkelt bli sendt som ubudne gjester, og dessuten er det kjent at du har tilgang til denne siden først etter at du har besøkt hovedsiden til nettstedet.
2 GET-metoden
La oss skrive vår forespørsel.
FÅ http://www.site.ru/news.html HTTP/1.0\r\n
Vert: www.site.ru\r\n
Informasjonskapsel: inntekt=1\r\n
\r\n
Denne forespørselen forteller oss at vi ønsker å få innholdet på siden på http://www.site.ru/news.html ved å bruke GET-metoden. Vert-feltet indikerer at denne siden er plassert på www.site.ru-serveren, Referer-feltet indikerer at vi kom for nyheter fra hovedsiden til nettstedet, og informasjonskapsel-feltet indikerer at vi ble tildelt en slik og en slik informasjonskapsel. Hvorfor er verts-, referanse- og informasjonskapselfeltene så viktige? Fordi vanlige programmerere, når du oppretter dynamiske nettsteder, sjekk datafeltene som vises i skript (inkludert PHP) i form av variabler. Hva brukes dette til? For å for eksempel forhindre at siden blir ranet, d.v.s. de satte ikke et program på den for automatisk nedlasting, eller slik at en person som besøker nettstedet alltid skulle komme til det bare fra hovedsiden, etc.
La oss nå forestille oss at vi må fylle ut skjemafeltene på siden og sende en forespørsel fra skjemaet, la det være to felt i dette skjemaet: pålogging og passord (pålogging og passord) - og selvfølgelig vet vi påloggingen og passord.
FÅ http://www.site.ru/news.html?login=Petya%20Vasechkin&password=qq HTTP/1.0\r\n
Vert: www.site.ru\r\n
Henviser: http://www.site.ru/index.html\r\n
Informasjonskapsel: inntekt=1\r\n
\r\n
Vår pålogging er "Petya Vasechkin" Hvorfor skal vi skrive Petya%20Vasechkin? Dette er fordi Spesielle symboler kan gjenkjennes av serveren som tegn på tilstedeværelsen av en ny parameter eller slutten av en forespørsel, etc. Derfor er det en algoritme for å kode parameternavn og deres verdier for å unngå feilsituasjoner i forespørselen. Full beskrivelse av denne algoritmen kan bli funnet, og PHP har rawurlencode og rawurldecode funksjoner for henholdsvis koding og dekoding. Jeg vil merke meg at PHP gjør selve dekodingen hvis kodede parametere ble sendt i forespørselen. Dette avslutter første kapittel av mitt bekjentskap med HTTP-protokoll. I neste kapittel vil vi se på byggeforespørsler som POST (oversatt fra engelsk som "send"), som vil være mye mer interessant, fordi nøyaktig denne typen forespørsler brukes ved sending av data fra HTML-skjemaer.
3. POST metode.
Når det gjelder en HTTP POST-forespørsel, er det to alternativer for å overføre felt fra HTML-skjemaer, nemlig å bruke algoritmen application/x-www-form-urlencoded og multipart/form-data. Forskjellene mellom disse algoritmene er ganske betydelige. Faktum er at den første typen algoritme ble opprettet for lenge siden, når HTML-språk har ennå ikke gitt muligheten til å overføre filer via HTML-skjemaer. Så la oss se på disse algoritmene med eksempler.
3.1 Innholdstype: application/x-www-form-urlencoded.
Vi skriver en forespørsel som ligner på vår GET-forespørsel om å overføre påloggingsinformasjonen og passordet, som ble diskutert i forrige kapittel:
Vert: www.site.ru\r\n
Henviser: http://www.site.ru/index.html\r\n
Informasjonskapsel: inntekt=1\r\n
Innholdstype: application/x-www-form-urlencoded\r\n
Innholdslengde: 35\r\n
\r\n
Her ser vi et eksempel på bruk av overskriftsfeltene Content-Type og Content-Length. Content-Length forteller hvor mange byte dataområdet vil oppta, som er atskilt fra overskriften med et annet linjeskift \r\n. Men parameterne som tidligere ble plassert i Request-URI for en GET-forespørsel er nå i Entity-Body. Det kan sees at de er dannet på samme måte, du trenger bare å skrive dem etter tittelen. Jeg vil påpeke en ting til viktig poeng, ingenting hindrer, samtidig med settet med parametere i Entity-Body, å plassere parametere med andre navn i Request-URI, for eksempel:
POST http://www.site.ru/news.html?type=user HTTP/1.0\r\n
.....
\r\n
login=Petya%20Vasechkin&password=qq
3.2 Innholdstype: multipart/form-data
Så snart internettverdenen innså at det ville være fint å sende filer gjennom skjemaer, satte W3C-konsortiet i gang å avgrense POST-forespørselsformatet. På det tidspunktet, MIME-formatet (Multipurpose Internet Mail Extensions - multi-purpose protokollutvidelser for å lage E-postmeldinger), derfor, for ikke å finne opp hjulet på nytt, bestemte vi oss for å bruke deler av dette meldingsgenereringsformatet for å lage POST-forespørsler i HTTP-protokollen.
Hva er hovedforskjellene mellom dette formatet og typen application/x-www-form-urlencoded?
Hovedforskjellen er at Entity-Body nå kan deles inn i seksjoner, som er atskilt med grenser (grense). Det som er mest interessant er at hver seksjon kan ha sin egen overskrift for å beskrive dataene som er lagret i den, dvs. Du kan overføre data i én forespørsel forskjellige typer(hvordan inn Post brev Du kan overføre filer samtidig med tekst).
Så la oss komme i gang. La oss se på det samme eksemplet igjen med overføring av pålogging og passord, men nå i et nytt format.
POST http://www.site.ru/news.html HTTP/1.0\r\n
Vert: www.site.ru\r\n
Henviser: http://www.site.ru/index.html\r\n
Informasjonskapsel: inntekt=1\r\n
Innholdslengde: 209\r\n
\r\n
--1BEF0A57BE110FD467A \r\n
Innhold-Disposisjon: form-data; name="login" \r\n
\r\n
Petya Vasechkin \r\n
--1BEF0A57BE110FD467A \r\n
Innhold-Disposisjon: form-data; name="passord" \r\n
\r\n
qq \r\n
--1BEF0A57BE110FD467A-- \r\n
La oss nå forstå hva som er skrevet. :-) Jeg har spesielt fremhevet noen \r\n tegn med fet skrift, slik at de ikke smelter sammen med dataene. Hvis du ser nøye etter, vil du legge merke til grensefeltet etter Content-Type. Dette feltet spesifiserer seksjonsseparator - kantlinje. Grensen kan være en streng bestående av latinske bokstaver og tall, samt noen andre symboler (dessverre husker jeg ikke hvilke). I forespørselens brødtekst legges "--" til begynnelsen av grensen, og forespørselen avsluttes med en grense, som også tegnene "--" legges til på slutten. Vår forespørsel har to deler, den første beskriver påloggingsfeltet, og den andre beskriver passordfeltet. Content-Disposition (datatypen i seksjonen) sier at dette vil være data fra skjemaet, og navnefeltet spesifiserer navnet på feltet. Det er her seksjonsoverskriften slutter, og det som følger er seksjonsdataområdet som feltverdien er plassert i (ingen grunn til å kode verdien!).
Jeg vil gjerne gjøre oppmerksom på at du ikke trenger å bruke Content-Length i seksjonsoverskrifter, men i forespørselsoverskriften bør du og verdien er størrelsen på hele Entity-Body, som vises etter den andre \ r\n følgende innholdslengde: 209\ r\n. De. Entity-Body er atskilt fra overskriften med et ekstra linjeskift (som også kan sees i avsnitt).
La oss nå skrive en forespørsel om å overføre en fil.
POST http://www.site.ru/postnews.html HTTP/1.0\r\n
Vert: www.site.ru\r\n
Henviser: http://www.site.ru/news.html\r\n
Informasjonskapsel: inntekt=1\r\n
Content-Type: multipart/form-data; grense=1BEF0A57BE110FD467A\r\n
Innholdslengde: 491\r\n
\r\n
--1BEF0A57BE110FD467A \r\n
Innhold-Disposisjon: form-data; name="news_header" \r\n
\r\n
Eksempel på nyheter \r\n
--1BEF0A57BE110FD467A \r\n
Innhold-Disposisjon: form-data; name="news_file"; filename="news.txt" \r\n
Innholdstype: applikasjon/oktettstrøm \r\n
Content-Transfer-Encoding: binær \r\n
\r\n
Og her er nyhetene, som er i news.txt-filen \r\n
--1BEF0A57BE110FD467A-- \r\n
I i dette eksemplet den første delen sender nyhetstittelen, og den andre delen sender news.txt-filen. Hvis du er oppmerksom, vil du se feltene filnavn og innholdstype i den andre delen. Filnavn-feltet spesifiserer navnet på filen som sendes, og Innholdstype-feltet angir typen til denne filen. Application/octet-stream indikerer at dette er en standard datastrøm, og Content-Transfer-Encoding: binær indikerer at dette er binære data, ikke kodet på noen måte.
Et veldig viktig poeng. De fleste CGI-skript er skrevet smarte folk, så de liker å sjekke typen på den innkommende filen, som er i Content-Type. For hva? Oftest brukes opplasting av filer på nettsider for å motta bilder fra den besøkende. Så, nettleseren prøver selv å finne ut hva slags fil den besøkende vil sende og setter inn riktig innholdstype i forespørselen. Skriptet sjekker det ved mottak, og hvis det for eksempel ikke er en gif eller jpeg, ignorerer det det denne filen. Derfor, når du oppretter en forespørsel "manuelt", ta vare på Content-Type-verdien slik at den er nærmest formatet til den overførte filen.
I vårt eksempel genereres en forespørsel hvor tekstfil. En forespørsel om overføring av en binær fil genereres på samme måte.
4. Etterskrift.
Jeg tror at det ikke er verdt å snakke i detalj om å sende forespørsler til serveren. Dette er et spørsmål om ren RHP-teknologi :-). Det er nok å lese nøye avsnittet om funksjoner for å jobbe med sockets, eller om funksjonene til CURL-modulen i den offisielle PHP-dokumentasjonen.
Fra ovenstående håper jeg det nå er klart hvorfor spørsmålet er: "Hvordan kan jeg generere en POST-forespørsel ved å bruke overskriftsfunksjonen?" - meningsløst. Header(string)-funksjonen legger bare til en oppføring i forespørselshodet, men ikke til forespørselsteksten.
Det er en annen type forespørsel - Content-Type: multipart/mixed, jeg håper etter å ha lest denne artikkelen vil du lett forstå denne typen selv. Du kan studere det i detalj
Moderne nettressurser gir ikke bare informasjon til besøkende, men samhandler også med ham. For å samhandle med brukeren, må du motta noe informasjon fra ham. Det er flere metoder for å skaffe data, veldig vanlige metoder er det FÅ Og POST. Og følgelig i PHP det er støtte for disse dataoverføringsmetodene FÅ Og POST. La oss se hvordan disse metodene fungerer.
GET metoden Data GET metoden sendes ved å legge dem til URL-en til skriptet som påkalles for å behandle den mottatte informasjonen. For avklaring denne metoden ringe inn adressefeltet nettleser-URL for ressursen og legg først til et spørsmålstegn (?) og deretter linjen num=10 . For eksempel
http://domain.ru/script.php?num=10
Hvis du har lokal server da vil vanligvis domenet være localhost, og den forrige oppføringen ser slik ut
http://localhost/script.php?num=10
I dette tilfellet sender vi parameteren num lik 10. For å legge til følgende parametere Skriptet må for eksempel bruke og-sand-skilletegn (&).
http://domain.ru/script.php?num=10&type=new&v=text
I i dette tilfellet vi sendte tre parametere til skriptet: num med verdien 10, skriv med verdien "ny" og v med verdien "tekst".
For å få disse parameterne i skriptet må du bruke den innebygde matrisen $_GET $_GET["num"], $_GET["type"],$_GET["v"]. Disse matriseelementene vil inneholde verdiene til de beståtte parameterne. For å demonstrere dette eksemplet, lag en script.php-fil med følgende innhold
echo ($_GET["num"]."
");
echo ($_GET["type"]."
");
echo ($_GET["v"]);
?>
Og nå kall denne filen i nettleseren
http://path/script.php?num=10&type=new&v=text
og du vil se de beståtte parameterne i nettleservinduet. Men hvis du kaller denne filen uten tilleggsparametere http://path/script.php , vil du se feil som tolken vil produsere PHP, at det ikke finnes slike elementer i $_GET-matrisen. Mer enn én artikkel kan vies til å sjekke dataene mottatt fra brukeren, så i denne artikkelen vil jeg ikke berøre dette punktet.
Som du sikkert forstår, er det ikke veldig bra å tvinge brukeren til å skrive inn data i adressefeltet til nettleseren, og det er helt upraktisk. Derfor, for å motta data fra brukeren, må du bruke html-skjemaer. La oss skrive et enkelt html-skjema.
La meg kommentere litt på det opprettede skjemaet. Skjemaer opprettes med form-taggen. Skjemafelt opprettes ved hjelp av input, select, textarea tags (du kan lese mer). I skjemataggen spesifiserer handlingsattributtet URL-en til skriptet som skal motta skjemadataene. I vårt tilfelle spesifiserte vi vår eksisterende script.php-fil. Metodeattributtet spesifiserer metoden for å sende data. Vi har spesifisert metoden FÅ. Nå vet vi hvilken fil skjemadataene skal overføres til, og på hvilken måte gjenstår det bare å finne ut hvor vi skal lete etter dem?!
Disse skjemadataene sendes til nettressursen av nettleseren ved å legge dem til URL-en: først vil det være et spørsmålstegn (?), deretter vil parametrene bli presentert atskilt med et og-tegn (&). Navnet på parameteren vil bli hentet fra name-attributtet, som må spesifiseres for ethvert skjemafelt. Verdien av parameteren vil avhenge av felttypen. Hvis feltet er et tekstfelt, vil verdien være teksten som er skrevet inn av brukeren. Hvis feltet er en liste, en gruppe med alternativknapper eller avmerkingsbokser, vil verdien til parameteren være verdien til verdiattributtet til det valgte elementet. La meg forklare ved å bruke skjemaet vårt som et eksempel. Hvis brukeren skriver inn tallet 10 i inntastingsfeltet, vil navnet på parameteren være num (verdien til navneattributtet til input-taggen) og verdien vil være 10 (tallet angitt av brukeren). Følgelig vil nettleseren generere et par "num=10". Hvis brukeren velger "Ja" fra listen, vil navnet på parameteren være type (verdien av navneattributtet til select-taggen), og verdien vil være ja (verdien til verdiattributtet) alternativ-tag). Følgelig vil nettleseren generere et "type=ja"-par.
Nå vil vi plassere dette skjemaet på forma.php-siden.
Skriv inn eventuelle verdier i skjemafeltene og klikk på "Send"-knappen. Etter å ha klikket på knappen vil nettleseren åpne en annen side (script.php) og dataene du skrev inn vil vises i nettleservinduet. Jeg tror det er klart hvorfor: nettleseren sender dataene til script.php-skriptet, og i skriptet vil disse dataene bli behandlet og vist på skjermen.
POST metode La oss nå se på hvordan metoden fungerer POST.
For å sende data ved hjelp av POST du må bruke HTML-skjemaer. Som vi husker, er metodeattributtet til skjemataggen ansvarlig for metoden for å sende skjemadata. Derfor må du spesifisere verdien POST i metodeattributtet til form-taggen. Ellers kan skjemaet være det samme som for GET-metoden. La oss endre skjemaet vårt, som vi allerede har brukt til å overføre data ved hjelp av GET-metoden, til å overføre ved hjelp av POST-metoden.
Som du kan se, forblir skjemaet det samme bortsett fra metode- og handlingsattributtene. Dataene vil nå bli sendt til script_post.php-skriptet. La oss legge skjemaet vårt på siden forma_post.php.
Nå må vi skrive et skript som skal behandle skjemadataene våre.
For å motta data i et skript ved å bruke den beståtte metoden POST trenger å bruke innebygd array $_POST. Nøklene til denne matrisen vil være navnene på parameterne. I vårt tilfelle må vi bruke $_POST["num"], $_POST["type"],$_POST["v"]. Disse matriseelementene vil inneholde verdiene til de overførte dataene. Som du kan se, er forskjellen fra å bruke GET-metoden kun uttrykt i bruken av $_POST-matrisen. Derfor vil det ikke være vanskelig for oss å skrive script_post.php-filen:
echo ($_POST["num"]."
");
echo ($_POST["type"]."
");
echo ($_POST["v"]);
?>
Åpne nå forma_post.php-filen i nettleseren din. Skriv inn noen data i skjemafeltene og klikk på "Send"-knappen. Nå har du sannsynligvis lagt merke til forskjellen mellom POST-metoden og GET-metoden - skjemadataene dukket ikke opp i adressefeltet til nettleseren. Data etter metode POST kan ikke overføres gjennom nettleserens adresselinje. Dette er en betydelig forskjell å huske.
I PHP Uansett hvordan dataene ble sendt – POST-metoden eller GET-metoden – kan du motta dataene ved å bruke $_REQUEST-matrisen. Sammenligning av GET- og POST-metoder Ved bruk av GET-metoden overføres data ved å legge til URL-en. Dermed vil de være synlige for brukeren, noe som ikke alltid er bra ut fra et sikkerhetssynspunkt. Den maksimale mengden data som overføres vil også avhenge av nettleseren - av maksimalt tillatt antall tegn i nettleserens adresselinje.
Ved bruk av POST-metoden vil ikke dataene være synlige for brukeren (vises ikke i nettleserens adresselinje). Og derfor er de sikrere, og følgelig er programmet som behandler disse dataene mer beskyttet når det gjelder sikkerhet. Dessuten er volumet av overførte data praktisk talt ubegrenset.
Når du velger en dataoverføringsmetode, må du ta hensyn til funksjonene ovenfor og velge den mest passende metoden.
Første metode for PHP utførelse POST-forespørselen er å bruke file_get_contents . Den andre metoden vil bruke fread i kombinasjon med et par andre funksjoner. Begge alternativene bruker stream_context_create-funksjonen for å fylle ut de nødvendige forespørselshodefeltene.
Kodeforklaring
$sPD-variabelen inneholder dataene som skal overføres. Den må være i HTTP-forespørselsstrengformat, så noen spesialtegn må kodes.
I både file_get_contents-funksjonen og fread-funksjonen har vi to nye parametere. Den første er use_include_path . Siden vi opptrer HTTP-forespørsel, i begge eksemplene vil det være usant . Når satt til sann for å lese en lokal ressurs, vil funksjonen se etter filen på include_path .
Den andre parameteren er kontekst, som er fylt ut med returverdien til stream_context_create, som tar verdien til $aHTTP-matrisen.
Bruker file_get_contents til å lage POST-forespørsler
For å sende en POST-forespørsel ved å bruke file_get_contents i PHP, må du bruke stream_context_create for å manuelt fylle ut overskriftsfeltene og spesifisere hvilken "wrapper" som skal brukes - i dette tilfellet HTTP:
$sURL = "http://brugbart.com/Examples/http-post.php"; // POST URL $sPD = "navn=Jacob&bench=150"; // POST-data $aHTTP = array("http" => // Wrapper som vil bli brukt array("method" => "POST", // Request method // Request header er satt under "header" => "Innhold - type: application/x-www-form-urlencoded", "content" => $sPD)); $context = stream_context_create($aHTTP); $contents = file_get_contents($sURL, false, $context); ekko $innhold;
Bruker fread til å utføre POST-forespørsler
Du kan bruke fread-funksjonen til å lage POST-forespørsler. Følgende eksempel bruker stream_context_create til å komponere de nødvendige HTTP-forespørselshodene:
$sURL = "http://brugbart.com/Examples/http-post.php"; // POST URL $sPD = "navn=Jacob&bench=150"; // POST-data $aHTTP = array("http" => // Wrapper som vil bli brukt array("method" => "POST", // Forespørselsmetode // Forespørselshoder er satt under "header" => "Innhold - type: application/x-www-form-urlencoded", "content" => $sPD)); $context = stream_context_create($aHTTP); $handle = fopen($sURL, "r", falsk, $kontekst); $contents = ""; while (!feof($handle)) ( $contents .= fread($handle, 8192); ) fclose($handle); ekko $innhold;
Gjør GET-forespørsler med PHP
Vi vil nå fokusere på å bruke fread og file_get_contents for å laste ned innhold fra internett via HTTP og HTTPS. For å bruke metodene som er beskrevet i denne artikkelen, må du aktivere alternativet fopen wrappers. For å gjøre dette må du sette parameteren allow_url_fopen til On i php.ini-filen.
Å utføre POST- og GET-forespørsler i PHP brukes til å logge på nettsteder, hente innhold på nettsider eller se etter nye versjoner av applikasjoner. Vi vil dekke hvordan du lager enkle HTTP-forespørsler.
Bruke fread til å laste ned eller motta filer over Internett
Husk at lesing av nettsider er begrenset til den tilgjengelige delen av pakken. Så du må bruke funksjonen stream_get_contents ( ligner på file_get_contents) eller mens loop for å lese innholdet i mindre biter til slutten av filen er nådd:
I dette tilfellet med å behandle en PHP POST-forespørsel, er det siste argumentet til fread-funksjonen lik fragmentstørrelsen. Det bør vanligvis ikke være større enn 8192 ( 8*1024 ).
Husk at den kan være større eller mindre, og kan også være begrenset av innstillingene til systemet som PHP kjører på.
Bruke file_get_contents for å få et nettsteds URL
Det er enda enklere å bruke denne metoden når du leser en fil over HTTP, siden du ikke trenger å bekymre deg for å lese i biter – alt håndteres i PHP.
Oversettelsen av artikkelen "Making POST Requests With PHP" ble utarbeidet av det vennlige prosjektteamet