Afgezien van de gebruikelijke eenvoudige vragen met eenvoudige voorwaarden SQL-taal stelt je in staat om nogal complexe uitdrukkingen samen te stellen, waarvan de hooivork soms eng is om naar te kijken, ze zien er zo onbegrijpelijk uit. Dergelijke zoekopdrachten zijn echter niet erg gebruikelijk, en het volgende niveau van complexiteit na de gebruikelijke SELECT is naar mijn mening het JOIN-commando. Laten we eens kijken hoe we ermee kunnen werken.
Laten we eerst eens kijken naar de eenvoudigste veelgebruikte zoekopdrachten.
SELECTEER AANTAL (*) UIT tabel; // tellen van het aantal records SELECT * FROM tabel LIMIT 5,10; // vanaf het 5e record worden 10 regels geselecteerd. meest gebruikt voor paginanavigatie SELECT * FROM tabel ORDER BY num; // sorteer alle records uit de tabel op veldnummer SELECT * FROM tabel WHERE year = "1990"; // selecteer record / records waarbij het jaar 1990 is SELECTEER * FROM tabel WHERE name LIKE "% ova%"; // zoek in de tabel naar een naam die de reeks "ova" bevat SELECT DISTINCT name FROM tabel; // als er dubbele velden zijn, worden deze slechts één keer geteld SELECT * FROM name WHERE age IN (12,15,18); // geeft de namen weer die overeenkomen met de velden met leeftijd 12,15,18 SELECT MAX (leeftijd) FROM tabel; // MAX / MIN - selecteer het record met de maximale of minimale leeftijdswaarde
Laten we nu direct naar de JOIN-voorbeelden gaan:
Een zeer populaire taak waarbij het JOIN-commando wordt gebruikt, is om verschillende tabellen samen te voegen met een soort van gemeenschappelijk kenmerk... Laten we naar een voorbeeld kijken. Laten we zeggen dat we twee tabellen hebben. De eerste bevat gegevens over de naam en het adres van de gebruiker en heeft ook een kolom user_id. In de tweede kolom hebben we ook een kolom user_id en een kolom met de home-index van de gebruiker.
SELECT naam, adres FROM table1 LEFT JOIN table2 ON table1.user_id = table2.user_id;
Om het nog duidelijker te maken, kan deze query op de klassieke manier worden herschreven:
SELECTEER table1.name, table1.addres, table2.index VAN table1, table2 WAAR table1.user_id = table2.user_id;
U kunt dus gegevens uit verschillende tabellen halen, en als die er is: aanvullende voorwaarde dan voegen we het ook toe:
SELECT naam, adres VAN tabel1 LEFT JOIN table2 ON table1.user_id = table2.user_id WAAR naam = "Vasya";
Als we ons in de theorie storten, dan voegen we toe wat is de volgende opties: MEEDOEN:
Het is gepast om hier de beroemde cirkels te tekenen:
INNERLIJKE JOIN
geeft het snijpunt van twee sets terug
SELECTEER t1.naam, t2.stad UIT Tabel1 t1 INNERLIJKE JOIN Tabel2 t2 OP t1.key2 = t2.key2;
De INNER JOIN weerspiegelt de OUTER JOIN. We zijn voorzien van drie soorten OUTER JOINs - VOL, LINKS en RECHTS. Het woord BUITEN is optioneel.
VOLLEDIGE DEELNEMING
Combineert twee sets
FULL JOIN retourneert ALLE records uit tabellen tabel en tabel2, geen dubbele gegevens. Als er geen gegevens zijn, wordt NULL vervangen.
LINKS DOEN
Retourneert gegevens uit de linkertabel, evenals gegevens van rechts die de linkertabel kruisen.
Als er niet genoeg gegevens uit de juiste tabel zijn, wordt een NULL-waarde vervangen.
RIGHT JOIN - zoals je waarschijnlijk hebt begrepen, retourneert alle waarden uit de rechtertabel en kruisende gegevens van links.
Uitzonderingen
Als we gegevens nodig hebben uit de eerste tabel waarvoor geen gegevens in de juiste staan, dan hoeven we alleen de WHERE-voorwaarde toe te voegen
SELECTEER t1.name, t2.city UIT Tabel1 t1 LEFT JOIN Table2 t2 ON t1.key2 = t2.key2 WAAR t2.key2 NULL IS;
Meerdere JOIN's
Met JOIN kun je niet alleen 2 tafels samenvoegen, maar zoveel als je nodig hebt. Als u 2 tabellen samen wilt voegen, zijn 2 JOIN-commando's vereist. Maar ga niet tot het uiterste en sluit je aan bij een aantal tabellen, dit alles zal een aanzienlijke impact hebben op de prestaties, dus soms is het beter om meerdere subquery's uit te voeren. Een voorbeeld van het samenvoegen van drie tabellen:
SELECTEER t1.Naam, t2.Plaats, t3.Beroep UIT Tabel1 t1 INNER JOIN Tabel2 t2 ON t1.key2 = t2.key2 INNER JOIN Table3 t3 ON t1.key3 = t3.key3;
Nou, ik hoop dat de vermelde eenvoudige JOIN voorbeelden heeft u geholpen om met deze operator om te gaan.
JavaScript is geblokkeerd in uw browser. Schakel JavaScript in om de site te laten werken!
Werken met formulieren
HTML-formulieren worden gebruikt om gegevens van de gebruiker van de webpagina naar de server over te dragen. Er zijn een aantal speciale tools voor het werken met formulieren in PHP.
Vooraf gedefinieerde variabelen
PHP heeft een aantal voorgedefinieerde variabelen die niet veranderen wanneer alle applicaties in een bepaalde omgeving draaien. Ze worden ook wel omgevingsvariabelen of omgevingsvariabelen... Ze weerspiegelen de instellingen van de omgeving Apache-webserver evenals informatie over het verzoek deze browser... Het is mogelijk om de waarden van de URL, querystring en andere elementen van het HTTP-verzoek te krijgen.
Alle vooraf gedefinieerde variabelen bevinden zich in de associatieve array $ GLOBALS. Naast omgevingsvariabelen bevat deze array ook globale variabelen die in het programma zijn gedefinieerd.
voorbeeld 1
"; ?>
Als resultaat toont het scherm een lijst met alle globale variabelen, inclusief: omgevingsvariabelen... De meest gebruikte:
| Variabele | Beschrijving | Inhoud |
|---|---|---|
| $ _SERVER ["HTTP_USER_AGENT"] | Klantnaam en versie | Mozilla / 5.0 (compatibel; Googlebot / 2.1; + http://www.google.com/bot.html) |
| $ _SERVER ["REMOTE_ADDR"] | IP adres | 144.76.78.3 |
| getenv ("HTTP_X_FORWARDED_FOR") | Intern IP-adres van de klant | |
| $ _SERVER ["REQUEST_METHOD"] | Verzoekmethode (GET of POST) | KRIJGEN |
| $ _SERVER ["QUERY_STRING"] | Bij GET-verzoek gecodeerde gegevens doorgegeven samen met de url | |
| $ _SERVER ["REQUEST_URL"] | Het volledige adres van de klant, inclusief de querystring | |
| $ _SERVER ["HTTP_REFERER"] | Adres van de pagina van waaruit het verzoek is gedaan | |
| $ _SERVER ["PHP_SELF"] | Het pad naar het uitvoerbare programma | /index.php |
| $ _SERVER ["SERVER_NAME"] | Domein | site |
| $ _SERVER ["REQUEST_URI"] | Manier | /php/php_form.php |
Gebruikersinvoer verwerken
Het PHP-invoerverwerkingsprogramma kan worden gescheiden van de HTML-tekst die de invoerformulieren bevat, of het kan op een enkele pagina worden geplaatst.
Voorbeeld 2
Er is hier geen knop voor gegevensoverdracht, omdat: een formulier met één veld wordt automatisch verzonden wanneer een toets wordt ingedrukt
Bij het verwerken van een item met een selectie met meerdere waarden, moet u een paar vierkante haken toevoegen aan de itemnaam om toegang te krijgen tot alle geselecteerde waarden. Houd de Ctrl-toets ingedrukt om meerdere items te selecteren.
Voorbeeld 3.1
RESULTAAT VAN VOORBEELD 3.1:
Voorbeeld 3.2
- "; foreach ($ Item als $ waarde) echo"
- $ waarde "; echo"
Voorbeeld 4. Waarden ontvangen van selectievakjes
$ v) (if ($ v) echo "Je kent de programmeertaal $ k!"; else echo" U kent de programmeertaal $ k niet.
"; } } ?>
RESULTAAT VAN VOORBEELD 4:
Voorbeeld 5
"; ?>Het is mogelijk om formulieren te verwerken zonder dat u zich zorgen hoeft te maken over de daadwerkelijke veldnamen.
Hiervoor kunt u (afhankelijk van de overdrachtsmethode) de associatieve array $ HTTP_GET_VARS of $ HTTP_POST_VARS gebruiken. Deze arrays bevatten naam/waarde-paren voor elk element van het ingediende formulier. Als het je niet kan schelen, kun je de associatieve array $ _REQUEST gebruiken.
Voorbeeld 6
"; ?>
Voorbeeld 7. Een klik op een knop afhandelen met behulp van de "@"-operator.
Door de header ()-functie te gebruiken, door de header "Locatie" naar de browser te sturen, kunt u de gebruiker omleiden naar een nieuwe pagina.
Bijvoorbeeld:
Bestandsoverdracht naar de server. Upload bestand. Uploaden
Met PHP kunt u bestanden naar de server overbrengen. Het HTML-formulier voor het indienen van het bestand moet het argument enctype = "multipart / form-data" bevatten.
Bovendien moet er een verborgen veld met de naam max_file_size zijn vóór het veld voor het kopiëren van bestanden in het formulier. Dit verborgen veld moet de maximale grootte van het overgedragen bestand bevatten (meestal niet meer dan 2 MB).
Het veld voor bestandsoverdracht zelf is een normaal INPUT-element met het argument type = "bestand".
Bijvoorbeeld:
Nadat het bestand naar de server is geüpload, krijgt het een unieke naam en wordt het opgeslagen in de tijdelijke map. Het volledige pad naar het bestand wordt geschreven in een globale variabele, waarvan de naam hetzelfde is als de naam van het veld voor het overzetten van dit bestand. Bovendien slaat PHP wat aanvullende informatie over het overgedragen bestand op in andere globale variabelen:
Voorbeeld 8
"; echo" size: ". $ _ FILES [" gebruikersbestand "] [" size "]."
"; echo" type: ". $ _ FILES [" gebruikersbestand "] [" type "]."
"; } ?>
Voorbeelden van het uploaden van bestanden naar de server
Als je problemen hebt met de server die het geüploade bestand transcodeert, het symbool met de code 0x00 vervangen door een spatie (teken met code) 0x20), toevoegen aan het bestand httpd.conf uit de Apache-directory (/usr / local / apache) de volgende regels.
Formulieren maken tegenwoordig deel uit van vrijwel elke webtoepassing. Ze zijn de belangrijkste methode om input te ontvangen van mensen die de applicatie gebruiken. Ze variëren in grootte van opt-in formulieren met één veld waarin u alleen uw e-mailadres invoert, tot zeer lange formulieren met tientallen of zelfs honderden velden.
Om lange formulieren gebruiksvriendelijker te maken, is het een goed idee om het formulier over meerdere pagina's te verdelen. Dit kan het voor de gebruiker gemakkelijker te volgen maken, en we kunnen de gegevens ook opsplitsen in afzonderlijke secties, op basis van de reikwijdte (bijvoorbeeld persoonlijke klantinformatie scheiden van betalingsgegevens in een winkelwagen-afrekenformulier).
Een van de uitdagingen die voortkomen uit het splitsen van het formulier over meerdere pagina's, is het doorgeven van de gegevens van de ene pagina naar de andere, aangezien we op het laatste punt van het formulier alle benodigde gegevens klaar hebben voor verwerking. We gaan kijken naar twee methoden om dit te doen: sessievariabelen en verborgen invoervelden.
Wat zijn sessies eigenlijk?
Een HTML-sessie is een verzameling variabelen die zijn status behoudt terwijl de gebruiker door de pagina's van een bepaalde site navigeert. Het is alleen beschikbaar voor het domein dat het heeft gemaakt en wordt snel verwijderd nadat de gebruiker de site heeft verlaten of zijn browser heeft gesloten.
De sessie heeft dus een semi-permanent karakter en kan worden gebruikt om variabelen door te geven langs verschillende pagina's waarop de bezoeker terechtkomt tijdens een bezoek aan de site.
Formulier met meerdere pagina's met sessies
In ons voorbeeld gaan we een formulier van drie pagina's maken, dat lijkt op een aanmeldings- en betalingsformulier voor een lidmaatschap. Op de eerste pagina wordt gevraagd naar de naam en het adres van de klant, op de tweede pagina is er de keuze voor het lidmaatschapstype en op de derde en laatste pagina moeten de betalingsgegevens worden ingevuld. De laatste stap is het opslaan van de gegevens in MySQL.
Het eerste bestand dat we gaan maken (stap 1 van het formulier) zal slechts een eenvoudig formulier met twee velden bevatten.
Ok, dus niets meer dan 2 invoervelden en een verzendknop om ons naar stap 2 te brengen. Op de volgende pagina hebben we, afgezien van het HTML-formulier om lidmaatschapsgegevens te verzamelen, code nodig om de ingediende gegevens van stap 1 op te slaan in de sessie.
Op naar stap 3, we moeten opnieuw nieuwe sessievariabelen maken, waarden toewijzen die per post zijn ontvangen en het laatste deel van het formulier maken.
Nu we stap 3 van het formulier hebben gemaakt, blijft het laatste verwerkingsscript over dat de gegevens in de MySQL-database invoegt.
En we zijn klaar. Houd er rekening mee dat we in de laatste query gegevens uit de $ _SESSION-array gebruiken, en ook gegevens uit de $ _POST-array, die zijn gepost vanaf de laatste stap van het formulier.
Hoewel het kan worden toegepast op de ontwikkeling van standaard softwareproducten voor lokaal gebruik. Maar daar gaat dit artikel niet over.
Wanneer u met databases in elk van de talen werkt, is het vaak de taak om een selectie van gegevens te maken voor uitvoer naar verschillende rapporten, grafieken, enzovoort. In de regel moet u bij het implementeren van dergelijke taken niet één, maar meerdere tabellen gebruiken, die u in één query combineert, wat het ontwerp aanzienlijk bemoeilijkt. In dit geval moet er rekening mee worden gehouden hoe de gegevens worden weergegeven, hoe de tabellen worden "opgetrokken" en welk resultaat het meest acceptabel is voor de programmeur. Een van de standaard MySQL-taalconstructies, Join, wordt gebruikt om dergelijke problemen op te lossen.
Het concept van het woord Join
Database-ontwikkeltalen, ongeacht het soort taal, zijn gebaseerd op standaardwoorden uit Engelstalige woordenboeken (daarom zal het, op voorwaarde dat u Engels kent, veel gemakkelijker voor u zijn om met tabellen te werken). Om de verbinding van tabellen in de selectie te implementeren, wordt hetzelfde woord gebruikt - Join. In de database-programmeertaal wordt My SQL gebruikt. De vertaling van dit dienstwoord is precies hetzelfde als in de taal zelf - "unie".
De interpretatie van de MySQL - Join-constructie, elk van hen, zal precies hetzelfde zijn. Als we het doel van de structuur ontcijferen, namelijk het schema van zijn werking, dan krijgen we de volgende betekenis: met de structuren kunnen de benodigde velden uit verschillende tabellen of geneste zoekopdrachten in één selectie worden verzameld.
Soorten structuren om te combineren
Als een programmeur een selectie uit meerdere tabellen moet verzamelen en hij weet welke sleutelvelden erin staan en wat voor soort gegevens nodig zijn voor het rapport, dan kun je een van de basis union-constructies gebruiken om het gewenste resultaat te bereiken. Er zijn vier basisconstructies (voor het verbinden van tabellen):
- Innerlijke verbinding.
- Kruis mee.
- Links meedoen.
- Rechts meedoen.
Afhankelijk van de uit te voeren taak geeft elk van de standaardontwerpen verschillende resultaten, waardoor u in korte tijd rapporten over verschillende parameters kunt ontvangen.
Maken en vullen van tabellen voor verder gebruik
Voordat we bijvoorbeeld beginnen met het overwegen van de mechanismen van het werken met data-unieconstructies, is het de moeite waard om verschillende tabellen voor te bereiden, waarmee we in de toekomst zullen werken. Dit zal helpen om alle principes van de werking van operators visueel te tonen, bovendien is het op deze manier gemakkelijker voor beginners om alle basisprincipes van programmeertabellen te leren.
De eerste tabel beschrijft enkele objecten die een persoon zijn hele leven voortdurend tegenkomt.
In de tweede tabel zullen we enkele eigenschappen van objecten uit de eerste tabel beschrijven, zodat u er in de toekomst mee kunt werken.
Over het algemeen zijn twee tabellen voldoende om hun werk met een voorbeeld te illustreren. Nu kunt u beginnen met een praktisch onderzoek van onze ontwerpen.
Inner Join gebruiken
Bij het gebruik van de MySQL - Join Ineer-constructie, is het de moeite waard om enkele van zijn functies te overwegen. Met dit ontwerp kunt u uit beide tabellen alleen die records selecteren die in de eerste en tweede tabel staan. Hoe het werkt? In de eerste tabel hebben we een hoofdsleutel - ID, die het ordinale aantal records in de tabel aangeeft.
Bij het maken van een tweede tabel wordt dezelfde sleutel gebruikt als een serienummer, een voorbeeld is te zien in de afbeeldingen. Bij het selecteren van gegevens zal het Select-statement daarom alleen die records bepalen waarvan het volgnummer samenvalt, wat betekent dat ze zowel in de eerste als in de tweede tabel staan.
Wanneer u de structuur gebruikt, moet u begrijpen wat voor soort gegevens u nodig hebt. De meest voorkomende fout, vooral voor een beginnende programmeur, is het irrationele en onjuiste gebruik van de Inner Join-constructie. Hoe kunnen we een script overwegen dat informatie over items en hun eigenschappen uit de eerder beschreven en gevulde tabellen retourneert. Maar ook hier kunnen er verschillende manieren zijn om de structuur te gebruiken. In dit opzicht is My SQL een zeer flexibele taal. U kunt dus voorbeelden bekijken van het gebruik van MySQL Inner Join.
Aaneenschakeling van tabellen zonder parameters op te geven. In dit geval krijgen we het resultaat van een dergelijk plan:
Als we via het servicewoord Gebruik aangeven dat het absoluut noodzakelijk is om rekening te houden met de belangrijkste sleutels van records in tabellen, dan zal het resultaat van de selectie radicaal veranderen. In dit geval krijgen we een selectie die alleen die rijen retourneert die dezelfde hoofdsleutels hebben.
Er is ook een derde optie om de structuur te gebruiken, wanneer de query de velden specificeert waarmee de tabellen moeten worden samengevoegd met het woord "aan". In dit geval zal de selectie de volgende gegevens retourneren:
Functies van het gebruik van Left Join
Als u een andere manier overweegt om tabellen samen te voegen met behulp van de MySQL - Join-constructie, zult u het verschil merken in de gegevens die worden weergegeven. Dit mechanisme is de linkse constructie.
Het gebruik van de Left Join MySQL heeft enkele eigenaardigheden en vereist, net als Inner, een duidelijk begrip van het te verkrijgen resultaat.
In dit geval worden eerst alle records uit de eerste tabel geselecteerd en worden later records uit de tweede eigenschappentabel eraan gekoppeld. Bovendien, als de eerste tabel een record bevat, bijvoorbeeld "stool", en de tweede tabel heeft er geen enkele eigenschap voor, dan zal de linkeroperator null voor dit record weergeven, wat de programmeur vertelt dat er geen tekenen voor dit type object ...
Met behulp van deze constructie kunt u bepalen welke velden of bijvoorbeeld goederen in de winkel niet geprijsd zijn, enzovoort.
Voorbeeld van het gebruik van Links
Om in de praktijk de operator van de Left Join MySQL-constructie te beschouwen, gebruiken we de eerder beschreven tabellen. U moet bijvoorbeeld de volledige lijst met producten in de winkel selecteren en controleren voor welke er geen tekens of eigenschappen zijn. In dit geval toont de selectie alle producten en worden lege waarden ingesteld voor degenen die geen eigenschap hebben.
Waar in een join-clausule gebruiken
Als parameter kan een join niet alleen het specificeren van de velden bevatten waarmee de tabellen moeten worden verbonden, maar kan ook een Where-componentoperator bevatten.
Overweeg bijvoorbeeld een script dat ons alleen die records moet retourneren waarvoor de vlag niet is ingesteld. In dit geval moet u een condition-operator toevoegen aan de Join-constructie en specificeren wat er precies als resultaat moet worden geretourneerd.
Wanneer u Join - Where in MySQL gebruikt, moet u duidelijk begrijpen dat alleen die records waarop de opgegeven voorwaarde van toepassing is, worden weergegeven en dat de selectie er dan als volgt uitziet:
Met dergelijke zoekopdrachten kunnen selecties worden gemaakt voor specifieke gegevens die betrekking hebben op de door de programmeur geselecteerde conditie. U kunt verschillende van dergelijke voorwaarden specificeren, terwijl u de parameters voor het selecteren van gegevens uit de gecombineerde tabellen maximaliseert.
Join gebruiken om gegevens in tabellen te wijzigen
Het Join-construct is in wezen universeel. Hiermee kunt u niet alleen een verscheidenheid aan selecties maken, maar ook in query's van één tot meerdere tabellen opnemen, om aanvullende voorwaarden in de selectie in te voeren. De constructie kan ook worden gebruikt voor andere gegevensbewerkingen. Join kan bijvoorbeeld worden gebruikt om gegevens in een tabel te wijzigen. In plaats daarvan om de voorwaarden in een tabel te verduidelijken, of in gevallen waarin u gegevens in verschillende tabellen voor dezelfde voorwaarden moet bijwerken.
Denk bijvoorbeeld aan het volgende probleem. Er zijn drie tabellen die enkele gegevens bevatten. U moet de gegevens in beide tabellen met één query wijzigen. Om dit soort taken op te lossen, kunt u de constructie Join gebruiken in de opdracht Update. Het type Join-constructie zelf hangt, zoals in het geval van datasampling, af van het resultaat dat de programmeur wil krijgen.
Laten we eens kijken naar het eenvoudigste voorbeeld. Het is noodzakelijk om de gegevens voor dezelfde voorwaarden met één verzoek bij te werken. Dit soort query's zijn gebouwd om het werk met de database te optimaliseren. Waarom zou u voor elk van de tabellen verschillende query's schrijven als u alle gegevensmanipulatie met één query kunt uitvoeren? Een voorbeeld van Join is in ons geval als volgt:
Complexe query's maken
Bij het werken met een database is het vaak nodig om query's te bouwen, niet alleen door meerdere tabellen samen te voegen, maar ook met behulp van subquery's. Dergelijke taken zijn vrij moeilijk te begrijpen voor een beginnende databaseprogrammeur. De moeilijkheid zit 'm in het feit dat je bij elke stap moet nadenken, bepalen welke gegevens uit welke tabel of query je moet halen en hoe je er in de toekomst mee moet werken.
Voor een meer specifiek begrip kunt u (in MySQL Join) voorbeelden van complexe query's overwegen. Als je een beginner bent en net begint met databases, dan heeft deze training alleen maar voordelen. De ideale optie zou zijn:
Dit verzoek retourneert 58 records van verkoopcontracten waarvoor een saldo van middelen is voltooid of bestaat op de geselecteerde datum. In dit geval is dit de huidige datum. Ook is aan de selectie een voorwaarde toegevoegd dat de naam van het contract symbolen moet bevatten - "123". De informatie (gegevens) die op het scherm wordt weergegeven, wordt gesorteerd - geordend op contractnummer.
In het volgende voorbeeld worden gegevens over alle betalingen weergegeven, waarbij het contractnummer wordt aangegeven.
Subquery's gebruiken
Zoals eerder vermeld, kunt u bij het werken met databases niet alleen tabellen combineren, maar ook een tabel met een query. Dit ontwerp wordt voornamelijk gebruikt om de zoekopdracht te versnellen en te optimaliseren.
Als u bijvoorbeeld slechts twee velden hoeft te selecteren uit een tabel met honderden velden en bijvoorbeeld duizend records, moet u een query gebruiken die alleen de vereiste velden retourneert en deze combineert met de hoofdgegevensset. Als voorbeeld van MySQL Join Select kunt u een query van dit type overwegen:
Dit zijn niet alle manieren om de standaard MySQL-constructies te gebruiken, alleen de standaard. Hoe de Join-constructie te gebruiken en in welke vormen het is aan de programmeur zelf, maar het is de moeite waard om te onthouden en rekening te houden met welk resultaat moet worden verkregen bij het uitvoeren van een query.
Laatst bijgewerkt: 1.11.2015
Een van de belangrijkste manieren waarop gegevens naar een website worden verzonden, is de verwerking van formulieren. Formulieren zijn speciale HTML-opmaakelementen die verschillende invoerelementen bevatten - tekstvakken, knoppen, enzovoort. En met behulp van de formuliergegevens kunnen we wat gegevens invoeren en naar de server sturen. En de server is deze gegevens al aan het verwerken.
Formuliercreatie bestaat uit de volgende aspecten:
Elementen maken
Het attribuut action = "login.php" van het formulierelement geeft aan dat de formuliergegevens door het script worden verwerkt login.php die bij het bestand zal zijn formulier.php in één map. En het kenmerk method = "POST" geeft aan dat de POST-methode zal worden gebruikt als de methode voor gegevensoverdracht.
Laten we nu een bestand maken login.php die de volgende inhoud zal hebben:
Uw wachtwoord: $ wachtwoord ";?>
De globale variabele $ _POST wordt gebruikt om de formuliergegevens op te halen. Het vertegenwoordigt een associatieve reeks gegevens die zijn ingediend met behulp van de POST-methode. Met behulp van de sleutels kunnen we de verzonden waarden ophalen. De sleutels in deze array zijn de waarden van de naamattributen van de formulierinvoervelden.
Aangezien het naamkenmerk van het invoerveld login login ( ), dan vertegenwoordigt de waarde van dit veld in de $ _POST-array de "login" -sleutel: $ _POST ["login"]
En aangezien er situaties zijn waarin het invoerveld niet wordt ingesteld, bijvoorbeeld wanneer u rechtstreeks naar het script gaat: http: // localhost: 8080 / login.php... In dit geval is het raadzaam om de beschikbaarheid van gegevens te controleren met de functie isset () voordat u de gegevens verwerkt. En als de variabele is ingesteld, retourneert de functie isset () waar.
Nu kunnen we naar de vorm gaan:
En door op de knop te klikken, worden de ingevoerde gegevens met de POST-methode naar het script verzonden login.php:
U hoeft de formuliergegevens niet naar een ander script te sturen, u kunt de formuliergegevens in hetzelfde formulierbestand verwerken. Om dit te doen, zullen we het bestand wijzigen formulier.php op de volgende manier:
Ga naar de site
Dataveiligheid
Gegevensbeveiliging is erg belangrijk in PHP. Laten we een paar eenvoudige mechanismen bekijken die de veiligheid van onze website kunnen verbeteren.
Maar laten we eerst het formulier uit het vorige onderwerp nemen en proberen er wat gegevens in in te voeren. Laten we bijvoorbeeld het inlogveld invoeren "", en in het wachtwoordveld de tekst"
wachtwoord
":Nadat de gegevens naar de html-opmaak zijn verzonden, wordt de javascript-code geïnjecteerd, die een berichtvenster weergeeft.
Gebruik de functie htmlentities () om dit soort beveiligingsproblemen te voorkomen:
If (isset ($ _ POST ["login"]) && isset ($ _ POST ["wachtwoord"])) ($ login = htmlentities ($ _ POST ["login"]); $ wachtwoord = htmlentities ($ _ POST ["wachtwoord" ]); echo "Uw login: $ login
Uw wachtwoord: $ wachtwoord ";)
En zelfs na het invoeren van html- of javascript-code, worden alle tags geëscaped en krijgen we de volgende uitvoer:
Een andere functie, de functie strip_tags () stelt je in staat om html-tags volledig te verwijderen:
If (isset ($ _ POST ["login"]) && isset ($ _ POST ["wachtwoord"])) ($ login = strip_tags ($ _ POST ["login"]); $ wachtwoord = strip_tags ($ _ POST ["wachtwoord" ]); echo "Uw login: $ login
Uw wachtwoord: $ wachtwoord ";)
Het resultaat van zijn werk met dezelfde invoer zal de volgende uitvoer zijn.
