Share
De eerste PHP 5.5 alpha is publiekelijk vrijgegeven. Na enige tijd te hebben om ermee te testen en ermee te experimenteren, kunnen we nu een gedetailleerd overzicht geven van waar we naar uit moeten kijken!
Als je dit artikel wilt volgen, moet je PHP 5.5 voor jezelf installeren. Je vindt de link naar de bronbundel hier. Als u het binaire Windows-bestand nodig heeft, kunt u het van dezelfde pagina halen.
Zodra je de broncode hebt gedownload, pakt u alles uit in een map en navigeert u ernaar met uw favoriete Terminal-programma. Je kunt PHP installeren waar je maar wilt, maar voor het gemak ga ik een map maken in de root van mijn schijf, genaamd PHP5.5. Als u een nieuwe map wilt maken en vervolgens uw gebruiker de eigenaar van de genoemde map wilt maken, typt u het volgende in uw terminal:
sudo mkdir /PHP5.5 sudo chown gebruikersnaam /PHP5.5
Vervolgens moet u beslissen welke extensies en functies u wilt installeren met uw exemplaar van PHP. Aangezien dit een alfaversie is, bedoeld om alleen te testen, maak ik me geen zorgen over het volledig uitgelicht te krijgen. Voor deze zelfstudie ga ik alleen CURL installeren, maar er kunnen andere dingen zijn die u wilt toevoegen, zoals MySQL of zip-ondersteuning. Ga als volgt te werk om een volledige lijst met configuratie-opties te bekijken:
./ configure -h
Naast de optie om cURL te installeren, zijn er nog twee andere eigenschappen die we moeten instellen: de voorvoegsel en met-config-file-path keuze. Deze twee eigenschappen bepalen de locatie van de PHP-installatie en de .ini bestand, respectievelijk. Dus in de terminal typt u:
./ configure --prefix = / PHP5.5 --with-config-file-path = / PHP5.5 - with-curl = ext / curl make make install
De eerste regel configureert PHP met cURL en stelt de locatie in op de map die we eerder hebben gemaakt. De volgende twee regels bouwen PHP en verplaatsen de bestanden naar de opgegeven map. De volgende stap is om het monster te kopiëren php.ini bestand naar de map PHP. Om dit te doen, voer:
cp php.ini-ontwikkeling /PHP5.5/php.ini
Je zou nu alles correct geïnstalleerd moeten hebben. De eenvoudigste manier om deze nieuwe versie te testen, is door de ingebouwde webserver te gebruiken. Navigeer naar de bak map in de PHP5.5 map (cd / PHP5.5/bin) en typ ./ php -t / Path / To / Directory -S 0.0.0.0:4444.
Accentsconagua
-t optie stelt de rootmap van de server in (d.w.z. de locatie waar u uw PHP-bestanden plaatst) -S property stelt het IP-adres en poortnummer in waar de server zich aan moet binden. Gebruik makend van 0.0.0.0 want het IP-adres vertelt de server om te luisteren op alle IP-adressen (bijvoorbeeld localhost, 127.0.0.1, 192.168.0.100, etc.). Als alles goed gaat, zou u moeten worden begroet met een bericht dat de server luistert naar de opgegeven IP / poort en dat deze u de documentwortel zal vertellen waar deze server voor dient. We kunnen nu beginnen met spelen met de nieuwe functies!
Met generatoren kunt u aangepaste functies maken, die de status tussen runs behouden.
De grootste toevoeging aan PHP 5.5 moet generators zijn. Met generatoren kunt u aangepaste functies maken, die de status tussen runs behouden. Het werkt met een nieuw sleutelwoord, genaamd opbrengst, welke kan worden gebruikt in een functie voor zowel het invoeren als het uitvoeren van gegevens.
Wanneer de functie een regel krijgt die de yield-opdracht bevat, zal PHP de uitvoering van de functie bevriezen en teruggaan naar het uitvoeren van de rest van uw programma. Wanneer u de functie aanroept om door te gaan - hetzij door hem te vertellen om verder te gaan of door hem gegevens te sturen - gaat PHP terug naar de functie en gaat verder waar hij gebleven was, waarbij de waarden van eventuele lokale variabelen werden behouden die daar waren gedefinieerd.
Dit klinkt misschien in eerste instantie een beetje gaaf, maar als je erover nadenkt, opent dit deuren naar een heleboel interessante ontwerpopties. Ten eerste simuleert het de effecten van andere programmeertalen met "Lazy Evaluation", zoals Haskell. Dit alleen stelt u in staat om oneindige gegevenssets te definiëren en wiskundige functies te modelleren na hun eigenlijke definitie. Daarnaast hoeft u niet zoveel globale variabelen te creëren; als een variabele alleen voor een specifieke functie is bedoeld, kunt u deze in een generator opnemen en dingen als items worden automatisch door de generator zelf uitgevoerd in de vorm van de sleutel van het geretourneerde object.
Nou dat is genoeg theorie voor nu; laten we eens kijken naar een generator in actie. Om te beginnen, navigeer naar de documentroot die u hebt gedefinieerd bij het uitvoeren van de PHP-server en maak een bestand aan met de naam "index.php". Open nu het bestand en typ het volgende in:
function fibonacci () $ a = 0; $ b = 1; while (true) $ a = $ a + $ b; $ b = $ a - $ b; opbrengst $ a;
Dit is de "Hello World" -functie van oneindige datasets. Het is een functie die alle fibonacci-nummers uitvoert. Om de generator te gebruiken, hoef je alleen maar het volgende te typen:
$ fib = fibonacci (); $ Fib-> huidige (); $ Fib-> volgende (); $ Fib-> huidige (); // ...
Wat hier gebeurt, is dat we aan het maken zijn $ FIB een generatorobject, en dan heb je toegang tot de onderliggende commando's, zoals stroom() en next (). De stroom() functie retourneert de huidige waarde van de generator; dit is de waarde van alles wat je hebt opgegeven in de functie - in ons geval, $ a. Je kunt deze functie meerdere keren aanroepen en je krijgt altijd dezelfde waarde, omdat de stroom() functie vertelt de generator niet om door te gaan met het evalueren van de code. Dat is waar de next () functie komt binnen; next () wordt gebruikt om de iterator te bevriezen en door te gaan met de functie. Omdat onze functie binnen een oneindig is terwijl loop, het zal gewoon weer bevriezen bij de volgende opbrengst commando, en we kunnen de volgende waarde krijgen met een andere oproep naar stroom().
Het voordeel voor generatoren is dat de lokale variabelen persistent zijn.
Als je in het verleden zoiets moest bereiken, zou je er een soort van moeten plaatsen voor lus die de waarden pre-berekent in een array en stopt na een bepaald aantal iteraties (bijvoorbeeld 100) om PHP niet te overbelasten. Het voordeel voor generatoren is dat de lokale variabelen persistent zijn en u kunt gewoon schrijven wat de functie zou moeten doen, afhankelijk van hoe het zou moeten. Wat ik hiermee bedoel is dat je gewoon de taak schrijft en je geen zorgen maakt over globale variabelen en hoeveel iteraties moeten worden uitgevoerd.
De andere weg opbrengst kan worden gebruikt om gegevens te ontvangen. Het werkt op dezelfde manier als voorheen: wanneer de functie een regel krijgt met de opbrengst sleutelwoord, zal het stoppen, maar in plaats van gegevens lezen met stroom(), we zullen het gegevens geven met de sturen() functie. Hier is een voorbeeld hiervan in actie:
function Logger () $ log_num = 1; while (true) $ f = yield; echo "Log #". $ log_num ++. ":". $ F; $ logger = Logger (); voor ($ i = 0; $ i<10; $i++) $logger->stuur ($ i * 2);
Dit is een eenvoudige generator voor het weergeven van een logbericht. Alle generators starten in een gepauzeerde toestand; een oproep aan sturen (of zelfs stroom) start de generator en gaat door tot hij a raakt opbrengst commando. De sturen commando zal dan de verzonden gegevens invoeren en doorgaan met het verwerken van de functie totdat deze bij de volgende komt opbrengst. Elke volgende oproep aan sturen zal één lus verwerken; het zal de verzonden gegevens invoeren in $ f, en ga dan door totdat het terugloopt naar de volgende opbrengst.
Dus waarom zou je dit niet gewoon in een normale functie stoppen? Nou, dat zou kunnen, maar dan zou je ofwel een aparte globale variabele nodig hebben om het log nummer bij te houden, of je zou een aangepaste klasse moeten maken.
Denk niet aan generatoren als een manier om iets te doen wat nooit mogelijk was, maar eerder als een hulpmiddel om dingen sneller en efficiënter te doen.
Zelfs oneindige sets waren mogelijk, maar het zou de lijst telkens van het begin opnieuw moeten verwerken (d.w.z. de wiskunde doorlopen tot het de huidige index bereikt), of alle gegevens opslaan binnen globale variabelen. Met generatoren is uw code veel schoner en nauwkeuriger.
foreach verklaringenDe volgende update die ik heel nuttig vond, is de mogelijkheid om een geneste array te breken in een lokale variabele in a foreach uitspraak. De lijst construct bestaat al een tijdje (sinds PHP4); het wijst een lijst met variabelen toe aan een array. Dus in plaats van iets schrijven als:
$ data = array ("John", "Smith", "032-234-4923"); $ fName = $ data [0]; $ lName = $ data [1]; $ cell = $ data [2]; Je zou gewoon kunnen schrijven:
$ data = array ("John", "Smith", "032-234-4923"); lijst ($ fName, $ lName, $ cel) = $ gegevens; Het enige probleem was dat als je een array met arrays (een geneste array) met informatie had die je wilde toewijzen, je er niet doorheen kon fietsen met een foreach lus. In plaats daarvan zou u de. Moeten toewijzen foreach resultaat naar een lokale variabele en wijs deze toe met een lijst construeer alleen binnen de lus.
Vanaf versie 5.5 kun je de middelste man verwijderen en je code opschonen. Hier is een voorbeeld van de oude manier, versus de nieuwe:
// - Oude methode - // foreach ($ parentArr as $ childArr) list ($ one, $ two) = $ childArr; // Doorgaan met lus // - Nieuwe methode - // foreach ($ parentArr als lijst ($ one, $ two)) // Doorgaan met lus
De oude manier lijkt misschien niet te veel moeite, maar het is rommelig en maakt de code minder leesbaar.
Op de ingebouwde grafische kaart van mijn Mac kon ik meer dan 200 miljoen hashes per seconde verwerken!
Nu heeft deze een beetje kennis van hashes en encryptie nodig om volledig te kunnen waarderen.
De eenvoudigste manier om een wachtwoord in PHP te hashen is geweest om iets als MD5 of een SHA-algoritme te gebruiken. Het probleem met hash-functies zoals deze is dat ze ongelooflijk eenvoudig te berekenen zijn. Ze zijn niet meer bruikbaar voor de beveiliging. Tegenwoordig zouden ze alleen moeten worden gebruikt voor het verifiëren van de integriteit van een bestand. Ik heb een GPU-hash op mijn computer geïnstalleerd om deze claim te testen. Op de ingebouwde grafische kaart van mijn Mac kon ik meer dan 200 miljoen hashes per seconde verwerken! Als je toegewijd was, en geïnvesteerd in een top-of-the-line opstelling van meerdere grafische kaarten, zou je mogelijk miljarden hashes per seconde kunnen doormaken.
De technologie voor deze methoden was niet bedoeld om lang mee te gaan.
Dus hoe los je dit probleem op? Het antwoord is dat je een instelbare belasting vormt voor het algoritme. Ik bedoel hiermee dat je het moeilijk maakt om te verwerken. Niet dat het een paar seconden per hash zou duren, omdat dat de ervaring van de gebruiker zou verpesten. Maar stel je voor dat je het een halve minuut hebt gekost om te genereren. Dan zou een gebruiker de vertraging waarschijnlijk niet eens beseffen, maar iemand die het probeert te vermorzelen zou miljoenen pogingen moeten doorstaan - zo niet meer - en alle halve seconden zouden oplopen tot tientallen jaren en eeuwen. Hoe zit het met het probleem dat computers in de loop van de tijd sneller worden? Dat is waar het "instelbare" deel in komt: om de zoveel tijd zou je de complexiteit verhogen om een hash te genereren. Op deze manier kunt u ervoor zorgen dat het altijd evenveel tijd kost. Dit is wat de ontwikkelaars van PHP proberen mensen aan te moedigen om te doen.
De nieuwe PHP-bibliotheek is een hashing-"workflow ", waarin mensen eenvoudig hashes en hun respectieve complexiteit in de loop van de tijd kunnen versleutelen, verifiëren en upgraden. Het wordt momenteel alleen geleverd met het bcrypt-algoritme, maar het PHP-team heeft een optie toegevoegd, de standaardnaam, die u kunt gebruiken. Het zal uw hashes automatisch bijwerken naar het meest veilige algoritme, wanneer zij nieuwe toevoegen.
De manier waarop bcrypt werkt, is dat het je wachtwoord uitvoert via blowfish-codering X aantal keren, maar in plaats van het gebruik van kogelvissen met een sleutel, zodat je het later zou kunnen omkeren, passeert het de vorige run als de sleutel tot de volgende iteratie. Volgens Wikipedia loopt het je wachtwoord door 2 naar de X bedrag. Dat is het deel dat je zou kunnen aanpassen. Stel dat je op dit moment een kostenniveau van 5 wilt gebruiken: bcrypt voert je hash uit 2 naar de 5, of 32 keer. Dit lijkt misschien een laag getal, maar omdat de kostenparameter de functie exponentieel aanpast, als u deze hebt gewijzigd in 15, voert de functie 32768 keer uit. Het standaardkostenniveau is 10, maar dit kan worden geconfigureerd in de broncode.
Laten we, met de theorie uit de weg, een volledig voorbeeld bekijken.
$ pass = "Secret_Password"; $ hash = password_hash ($ pass, PASSWORD_BCRYPT, array ('cost' => 12, 'salt' => "twenty.two.letter.salt")); if (password_verify ($ pass, $ hash)) if (password_needs_rehash ($ hash, PASSWORD_DEFAULT, array ('cost' => 15))) $ hash = password_hash ($ pass, PASSWORD_DEFAULT, array ('cost' => 15)); // Doe hier iets met hash. De password_hash functie accepteert drie parameters: het woord naar hash, een constante voor het hash-algoritme en een optionele lijst met instellingen, waaronder het zout en de kosten. De volgende functie, password_verify, zorgt ervoor dat een tekenreeks overeenkomt met de hash na codering en, ten slotte, de password_needs_rehash functie zorgt ervoor dat een hash de opgegeven parameters volgt. In ons geval stellen we bijvoorbeeld de hash-kosten in op twaalf, maar hier specificeren we vijftien, dus de functie zal terugkeren waar, wat betekent dat het opnieuw moet worden gewist.
Misschien heb je dat gemerkt in de password_verify en password_needs_rehash functies, hoeft u niet de gebruikte hashingmethode, het zout of de kosten op te geven. Dit komt omdat deze gegevens zijn toegevoegd aan de hash-reeks.
Zouten worden gebruikt om te voorkomen dat hashes vooraf worden ingevoerd in de regenboogtafel.
De reden waarom het goed is om de kosten en het zout samen met de hasj te bundelen en niet geheim te houden, is vanwege de manier waarop het systeem zijn sterke punten samenbrengt. De kosten hoeven geen geheim te zijn, omdat het bedoeld is als een nummer dat de server te zwaar belast. Wat ik hiermee bedoel is dat, zelfs als iemand je hasj krijgt en bepaalt dat je kostenniveau een halve seconde kost om te berekenen, hij weet op welk niveau hij zich moet concentreren, maar het zal hem te lang duren om te kraken (bijvoorbeeld tientallen jaren) ).
Zouten worden gebruikt om te voorkomen dat hashes vooraf worden ingevoerd in een regenboogtafel.
Een regenboogtabel is in feite een sleutel-waarde winkel met een "woordenboek" van woorden met hun corresponderende hashes als hun sleutels.
Het enige wat iemand hoeft te doen is voldoende veelvoorkomende woorden - of, erger nog, alle tekenreeksmogelijkheden - voor te berekenen en dan kunnen ze het woord voor een bepaalde hash onmiddellijk opzoeken. Hier is een voorbeeld van hoe zouten kunnen helpen: laten we zeggen dat uw wachtwoord het woord 'wachtwoord' is. Normaal gesproken is dit een vrij veel voorkomend woord; het zou waarschijnlijk in hun regenboogtabel zijn. Wat een zout doet, is dat het een willekeurige reeks aan je wachtwoord toevoegt; dus, in plaats van hashing "password", has has has really "passwordRandomSalt524% # $ &." Dit is aanzienlijk minder waarschijnlijk vooraf te worden berekend.
Dus waarom worden zouten gewoonlijk als privé-informatie beschouwd? Traditioneel, met dingen als MD5 en dergelijke, kan iemand, zodra hij je zout kent, terugkeren naar het uitvoeren van zijn brute technieken, behalve dat hij je zout tot het einde toe toevoegt. Dit betekent dat in plaats van je willekeurige wachtwoordreeks bruut te forceren, ze een veel korter standaardwachtwoord brutefororiseren en alleen het zout toevoegen. Maar gelukkig, aangezien we de instelling van de kostenfactor hebben, zou het te lang duren om elke hash te berekenen met het nieuwe zout.
Om samen te vatten: zouten zorgen ervoor dat de precomputting van één hash niet opnieuw op een andere hash kan worden gebruikt, en de parameter cost zorgt ervoor dat het niet haalbaar is om elke hash vanaf nul te berekenen. Beide zijn nodig, maar geen van beide moet geheim zijn.
Dat is de reden waarom de functie ze aan de hash koppelt.
Vergeet niet dat het niet uitmaakt wat uw zout is, zolang het maar uniek is.
Nu, als u begrijpt wat het zout aan het doen is, moet u weten dat het beter is om de functie willekeurig te laten genereren, dan om uw eigen woord in te voeren. Hoewel deze functie wordt geboden, wilt u niet dat al uw hashes hetzelfde zout bevatten. Als dat het geval is, is het voor iemand die erin slaagt om in uw database in te breken, de tabel één keer te berekenen. Omdat ze het zout- en kostenniveau hebben, kan het even duren, maar als er genoeg computers zijn, hebben ze na het verwerken al je hashes ontgrendeld. Als zodanig is het veel beter om er geen één toe te wijzen en in plaats daarvan PHP willekeurig één te laten genereren.
Tot nu toe was er geen gemakkelijke manier om e-mail via SMTP te verzenden.
cURL is een ander gebied, waar het PHP-team een aantal spannende nieuwe toevoegingen en updates heeft toegevoegd. Vanaf versie 5.5 hebben we nu ondersteuning voor onder andere de FTP-richtlijnen, richtlijnen voor het instellen van cookies, richtlijnen voor SSL en accounts en richtlijnen voor de SMTP- en RTSP-protocollen. Het zou te lang duren om ze allemaal te bespreken, maar om de volledige lijst te bekijken, kun je de NIEUWS-pagina raadplegen.
Ik wil echter vooral praten over een reeks die mij het meest interesseerde: de SMTP-reeks richtlijnen. Tot nu toe was er geen gemakkelijke manier om e-mail via SMTP te verzenden. Je zou ofwel het sendmail-programma van je server moeten aanpassen om berichten via een SMTP-server te verzenden, of je zou een bibliotheek van derden moeten downloaden - geen van beide is de beste optie. Met de nieuwe CURL-richtlijnen kunt u rechtstreeks met een SMTP-server praten, zoals Gmail, in slechts een paar korte lijnen.
Om beter te begrijpen hoe de code werkt, is het de moeite waard om iets over het SMTP-protocol te leren. Wat er gebeurt, is dat uw script verbinding maakt met de mailserver, de e-mailserver uw verbinding erkent en u zijn informatie teruggeeft (bijvoorbeeld domein, software). U moet dan antwoorden op de server met uw adres. Omdat het een spraakzaam (maar beleefd) protocol is, zal SMTP je begroeten, zodat je weet dat het is ontvangen.
Op dit moment bent u klaar om opdrachten te verzenden. De benodigde commando's zijn de MAIL VAN en de RCPT AAN; deze verwijzen direct naar de cURL-richtlijnen, CURLOPT_MAIL_FROM en CURLOPT_MAIL_RCPT, respectievelijk. Je hebt er maar één van adres, maar u kunt meerdere opgeven naar adressen. Zodra dit is gebeurd, kunt u gewoon de opdracht bellen, GEGEVENS, en begin met het verzenden van de daadwerkelijke bericht- en berichtkoppen. Om de verzending te beëindigen, moet u een lege regel verzenden, gevolgd door een punt, gevolgd door een andere lege regel. Deze laatste twee delen (dat wil zeggen DATA-commando en de eindsequentie) worden verzorgd door cURL, dus we hoeven ons daar geen zorgen over te maken.
Dus in PHP hoeven we alleen de e-mail op te geven van en naar richtlijnen en verzend vervolgens het eigenlijke bericht - allemaal binnen cURL. Om dingen echt eenvoudig te maken, ga ik een klasse maken, genaamd Gmail, die een gebruikersnaam / wachtwoord en de berichtdetails zal accepteren, en het zal e-mails versturen via uw Gmail-account.
Ik plak de hele klas hieronder, en dan gaan we er regel voor regel doorheen, want het meeste is overzichtelijk.
class Gmail private $ mail; privé $ e-mail; privé $ pas; openbare functie __construct ($ email, $ pass) $ this-> email = $ email; $ this-> pass = $ pass; private function mailGen () $ from = yield; $ tot = opbrengst; $ subject = opbrengst; $ body = opbrengst; opbrengst "VAN: <" . $from . ">\ n "; opbrengst" Naar: <" . $to . ">\ n "; opbrengst" Datum: ". datum (" r ")." \ n "; opbrengst" Onderwerp: ". $ subject." \ n "; yield" \ n "; render $ body; yield" "; openbare functie getLine () $ resp = $ this-> mail-> current (); $ this-> mail-> next (); return $ resp; public function send ($ to, $ subject, $ body) $ this-> mail = $ this-> mailGen (); $ this-> mail-> send ($ this-> email); $ this-> mail-> send ($ to); $ this-> mail- > send ($ subject); $ this-> mail-> send ($ body); $ ch = curl_init ("smtps: //smtp.gmail.com: 465"); curl_setopt ($ ch, CURLOPT_MAIL_FROM, "<" . $this->e-mail. ">"); curl_setopt ($ ch, CURLOPT_MAIL_RCPT, array ("<" . $to . ">")); curl_setopt ($ ch, CURLOPT_USERNAME, $ this-> email); curl_setopt ($ ch, CURLOPT_PASSWORD, $ this-> pass); curl_setopt ($ ch, CURLOPT_USE_SSL, CURLUSESSL_ALL); // curl_setopt ($ ch, CURLOPT_VERBOSE , waar); optioneel als u de transactie curl_setopt ($ ch, CURLOPT_READFUNCTION, array ($ this, "getLine")) wilt zien; return curl_exec ($ ch); Hopelijk was je reactie op deze code iets in de trant van: "Wow, dat is een afkorting voor een complete SMTP-implementatie!" Voor het geval het ingewikkeld lijkt, gaan we er even overheen. We beginnen met het definiëren van drie privévariabelen: één voor de berichtengenerator, één voor het opslaan van de e-mail van de gebruiker en één voor het opslaan van zijn wachtwoord. Vervolgens hebben we de constructor, die de e-mail en het wachtwoord opslaat voor later; dit is zodat we meerdere e-mails kunnen verzenden zonder deze telkens opnieuw in te voeren. De mailGen functie is een PHP 5.5-generator, die wordt gebruikt om het bericht volgens het e-mailprotocol direct in cURL uit te voeren. De reden waarom dit nodig is, is omdat het commando dat in cURL wordt gebruikt om de gegevens in te voeren bedoeld is om regel voor regel uit een bestand te lezen. Dus in plaats van een extra variabele te onthouden op welke regel we aan het spelen waren, heb ik een generator gebruikt, die zijn positie bewaart.
De volgende functie wordt gebruikt om door de generator te fietsen. We kunnen de generator niet rechtstreeks invoeren in cURL; we hebben een tussenpersoon nodig. cURL blijft deze functie aanroepen totdat deze op een lege regel staat. Dit is de reden waarom de laatste regel in de generator een lege tekenreeks retourneert.
De laatste functie in de klas is degene die alles met elkaar verbindt. We initialiseren eerst de generator naar de eerder gedefinieerde privévariabele. Vervolgens sturen we de generator alle vereiste informatie en maken we een nieuwe cURL-variabele. We hebben het al besproken CURLOPT_MAIL_FROM en CURLOPT_MAIL_RCPT; ze koppelen aan de equivalente SMTP-opdrachten. CURLOPT_MAIL_RCPT is een array, zodat u meerdere adressen kunt invoeren. Vervolgens moeten we de inloggegevens toevoegen om in te loggen bij GMail. Ik heb daar de uitgebreide optie achtergelaten; uncomment het, als u de volledige SMTP-transactie wilt zien. De laatste twee regels hebben zojuist de functie ingesteld waar CURL de gegevens voor het bericht zou moeten krijgen en vervolgens retourneren we de resultaten.
Het is een goed aantal regels, maar niets overdreven ingewikkeld. Om deze functie te gebruiken, maakt u een nieuw exemplaar van deze klasse en roept u de verzendfunctie aan. Hier is een voorbeeld van het verzenden van twee e-mails met dit:
$ gmail = nieuwe Gmail ("[email protected]", "wachtwoord"); $ gmail-> send ("[email protected]", "Onderwerp van e-mail", "Hallo jongen, \ n Wat is er aan de hand."); $ gmail-> send ("[email protected]", "Different Subject", "Important message."); Om dit artikel af te maken, ga ik verder met enkele van de kleinere updates voor PHP 5.5.
Een heel cool ding is de toegevoegde ondersteuning voor constante string / string dereferencing. Wat dit betekent is dat je toegang hebt tot individuele tekens in een statische tekenreeks, alsof de tekenreeks een reeks tekens is. Een snel voorbeeld hiervan is het volgende:
echo "Hallo wereld" [1]; // deze regel echo uit 'e' echo ["one", "two", "three"] [2]; // dit echoot "drie"
Vervolgens hebben we de Tenslotte trefwoord. Dit is toegevoegd aan het einde van een try / catch-blok; wat het doet is PHP instrueren dat, ongeacht of het proberen of vangen werd aangeroepen, je het wilt verwerken Tenslotte sectie. Dit is goed voor situaties waarin u de uitkomst van een try / catch-verklaring wilt afhandelen. In plaats van het herhalen van code in beide, kun je gewoon het "riskante" deel in het try / catch-blok plaatsen en alle verwerking in het slotblok.
Een ander gebruik dat de maker als een best practice heeft voorgesteld, is om alle opschooncode in het laatste blok te plaatsen. Hiermee zorgt u ervoor dat u bijvoorbeeld niet meerdere keren probeert dezelfde stream te sluiten (bijvoorbeeld uw code is gecrasht en in het catch-blok is terechtgekomen nadat u deze al had gesloten en probeert u hem opnieuw te sluiten).
Het laatste wat het vermelden waard is, is hoe de MySQL-extensie in deze nieuwe release wordt beëindigd. U moet uw code converteren naar de mysqli of BOB extensies in plaats daarvan. Hoewel het al lang als een anti-patroon wordt beschouwd, is het goed dat het PHP-team het officieel verwerpt.
Hoewel er zeker meer updates zijn om in te graven, vertegenwoordigen de items in dit artikel wat volgens mij het belangrijkste en meest opwindende is.
Bedankt voor het lezen; Ik hoop dat je een beetje hebt geleerd! Zoals altijd, als je opmerkingen of vragen hebt, spring dan in het onderstaande gesprek en laten we praten!
