Dynamische compressie van weergegeven HTML-pagina's inschakelen (

) kan ze met gemiddeld 20-60% comprimeren, waardoor de downloadsnelheid wordt verhoogd en het aantal "hangende" processen wordt verminderd. Heb je een bandbreedtebeperking op je hosting? Dan levert dynamische paginacompressie dubbele voordelen op.

Natuurlijk moet er rekening mee worden gehouden dat bufferen het geheugenverbruik enigszins verhoogt, en compressie - een belasting voor de processor. Maar deze opofferingen worden vaak ruimschoots gecompenseerd door de snelheidswinst. En niet alleen de snelheid van creatie, maar ook de snelheid van het laden van de pagina.

Ten slotte kan een frontend http-server de prestaties van uw PHP-scripts naar een hoger niveau tillen. Het is een feit dat zelfs bij caching de processen die zijn gekoppeld aan het verzoek van de gebruiker "vastlopen" totdat de gebruiker alle gegevens accepteert (of totdat de tijdslimiet is bereikt). De essentie van de frontend server is om direct data te ontvangen, waardoor je de verwerkte processen direct kunt ontladen. Het is een soort verbindende link tussen de gebruiker en een nogal "zware" backend-server - waar je PHP-scripts worden uitgevoerd. Maar vanwege zijn "lichtheid" vermindert de front-end server de verbruikte bronnen aanzienlijk. Nogmaals, dit is een zeer breed onderwerp en we zullen er in de nabije toekomst nader op ingaan.

6) Totaal inclusief

Stel dat je je "engine" in PHP hebt gemaakt, alle voorgaande tips hebt gevolgd. Het zal bijna onvermijdelijk veel verschillende incls bevatten: configuratiebestanden, functies, talen, enz. Het komt erop neer dat zelfs een normale include van hetzelfde bestand met functies veel tijd en geheugen zal vergen, zelfs als er naast de functies in de include geen uitvoerbare code is en geen van de functies wordt aangeroepen.

Maar de functies zijn heel divers en specifiek. Dus het is niet de beste oplossing om de hele lijst met functies in één bestand te plaatsen en elke keer op te nemen. Zo kent de site gebruikersregistratie: hiervoor kun je een aantal speciale functies hebben die alleen tijdens de registratie worden gebruikt. Dus waarom zou u ze in een algemene functie opnemen die wordt verbonden telkens wanneer u de pagina's van de site opent?

Verwaarloos de optimalisatie van insluitsels niet. Haal eruit wat niet universeel wordt toegepast in afzonderlijke, gespecialiseerde insluitsels. Nog een voorbeeld voor verankering. Mijn favoriete nieuwssite-engine. De functies van het toevoegen van nieuws, opmerkingen, hun controle en pre-parsing nemen ongeveer 1/3 van de code van het totale aantal functies in beslag. Maar hoe vaak zijn ze nodig? In 1 op de 100 verzoeken? Of 1 op 200? Of nog minder vaak? Dus waarom ze elke keer laden? Dit kan de prestaties van uw oplossingen zelfs aanzienlijk verminderen.

7) Overbodige functionalisering en OOP-thymisme

Functies mogen alleen worden gebruikt als het echt zinvol is. Laten we het basisdoel van functies onthouden. Dit is niets meer dan een afhaalmaaltijd

delen van de code in een afzonderlijk, gemeenschappelijk deel. In principe is het logisch om de code in een "apart deel" te plaatsen, zelfs wanneer deze wordt uitgevoerd op een relatief onwaarschijnlijke gebeurtenis. Bijvoorbeeld het toevoegen van een foto aan een forumbericht. Het verplaatsen van de handler voor het laden en verwerken van een afbeelding naar een "apart deel" zal een positief effect hebben op de prestaties, zelfs als deze is opgenomen in een voorwaarde (het feit dat een afbeelding wordt geladen). Bovendien, als we dit "aparte deel" maar één keer nodig hebben, is het beter om het gewoon als code (include) uit te voeren en niet als een functie. Functies vereisen altijd wat extra middelen. Hetzelfde geldt voor OOP-programmering in PHP. OOP-code verbruikt iets meer middelen, dus als u niet geïnteresseerd bent in OOP-opmaak van de code, is het beter om deze te verlaten. Ik heb het specifiek over OOP-opmaak, aangezien de OOP-aanpak in PHP weinig te maken heeft met het concept van OOP-programmering. Evenals PHP met een klassiek begrip van programmeertalen en hun taken - waar ik in het begin over schreef.

Nu ben je bekend met 7 basisprincipes van productieve PHP-code. Dit is nog maar het allereerste begin. We hebben nog veel interessant, specifieker materiaal over dit onderwerp in het verschiet.

Ik heb de hele httpd.conf bestudeerd, een heleboel highload-gidsen opgegraven (ze zijn oud en met dubieus advies zoals "onnodige modules uitschakelen"

1) Hebben alle VPS een zogenaamde "krachtige" processor die langzamer is dan op sommige zielige hosting, zij het met een VIP-tarief?

2) Zal FastCGI helpen in een dergelijke situatie?

3) Waarom zijn eAccelerator-functies niet populair (AST-caching, enz.)?

Ik weet dat velen van hen zijn verlaten, maar dit is geen oorzaak, maar een gevolg.

4) Wat kan nog meer helpen?

PS Als je de vraag(en) nauwkeuriger formuleert, kan ik preciezere aanbevelingen geven, als je die natuurlijk nodig hebt :)

P.S. Er is een oplossing voor het probleem in het algemeen "frontaal", de moeilijkste en misschien wel de meest productieve in sommige gevallen. Dit is Varnish + fine-tuning, het stelt je in staat om de meeste pagina's uit de cache (RAM) in nanoseconden uit te geven, soms kun je vele duizenden verzoeken per minuut bedienen, terwijl dit niet alleen code caching is of iets dergelijks dat ... dit is caching in zijn geheel pagina's en / of serverreacties. Hiermee kunt u onder andere "de backend helemaal niet aanraken", d.w.z. wanneer een pagina wordt opgevraagd, is er mogelijk geen toegang tot de database of de uitvoering van dezelfde PHP (of een andere) code aan de serverzijde. Het vereist nogal fijnafstemming, is niet erg geschikt voor sites "op CMS", voor sites op frameworks - het vereist een aanvankelijk correcte benadering van ontwikkeling en nadenken over wat en hoe in de cache zal/moet worden opgeslagen. Met een onjuiste benadering - het meest waarschijnlijke resultaat - zal het werken, maar niet zo snel als we zouden willen, en een deel van de site functioneert mogelijk niet meer normaal. Er zijn ook andere oplossingen, maar gezien de nogal algemene formulering van de vraag, is het nogal moeilijk om erover te praten.

Oh ja, ik ben een belangrijk detail vergeten ... Waarom gebruikt "hosting" Apache en laat het niet (helemaal) varen? Voornamelijk vanwege het feit dat je met Apache een aantal instellingen aan de gebruiker kunt delegeren via .htaccess. Tegelijkertijd is het voor statica niet ongebruikelijk om dezelfde Nginx te gebruiken, die, zoals u begrijpt, niet toestaat om een ​​deel van de instellingen op deze manier aan de gebruiker te delegeren, waardoor het niet geschikt is voor deze taken en "slaat" dit niet over (in tegenstelling tot Apache "maar inclusief om deze reden hebben we 99% van "hosting" geweigerd (vanwege de aanwezigheid van Apache en het onvermogen om er vanaf te komen of het zelf te configureren, en als gevolg van de "remmen" die bij zo'n benadering horen) ...

Goededag aan iedereen.

1. Als de methode statisch kan zijn, declareer deze dan statisch.
2. echo is sneller dan afdrukken.
3. Geef meerdere parameters door aan echo in plaats van tekenreeksaaneenschakeling te gebruiken.
4. Stel het maximum aantal keren in dat uw for-lussen vóór de lus kunnen passeren, niet terwijl deze wordt uitgevoerd.
5. Verwijder uw variabelen om geheugen vrij te maken, vooral als het grote arrays zijn.
6. Pas op voor magische methoden zoals __set, __get, __autoload.
7. vereisen_once is duur.
8. Specificeer volledige paden in include /vereiste constructies, er zal minder tijd worden besteed aan het zoeken naar het bestand.
9. Als u de tijd wilt bepalen waarop het script is uitgevoerd, gebruikt u $ _SERVER ['REQUEST_TIME'] in plaats van tijd ().
10. Probeer strncasecmp, strpbrk en stripos te gebruiken in plaats van reguliere expressies.
11. str_replace is sneller dan preg_replace, maar strtr is sneller dan str_replace.
12. Als een functie, zoals tekenreeksvervangingsfuncties, zowel arrays als enkele tekens als argumenten kan gebruiken, en als uw lijst met argumenten niet te lang is, overweeg dan om meerdere identieke vervangende uitdrukkingen te schrijven, waarbij u één teken tegelijk doorloopt in plaats van één tekenreeks. waarvoor een array als zoek- en vervangargument nodig is
13. Het is beter om statements te selecteren met een else if-statement dan om meerdere if-statements te gebruiken.
14. Foutonderdrukking bij gebruik van @ is erg traag.
15. Gebruik de Apache mod_deflate-module.
16. Sluit uw DB-verbindingen als u er klaar mee bent.
17. $ row ["id"] is zeven keer sneller dan $ row.
18. Foutrapportage is duur
19. Gebruik geen functies binnen een for-lusvoorwaarde, zoals deze: for ($ x = 0; $ x< count($array); $x). В данном случае функция count() будет вызываться с каждым проходом цикла.
20. Het verhogen van een lokale variabele in een methode gaat het snelst. Het verhogen van een lokale variabele in een functie werkt bijna op dezelfde manier.
21. Het verhogen van een globale variabele gaat twee keer zo langzaam als een lokale.
22. Het verhogen van een objecteigenschap (d.w.z. $ this-> prop ++) is drie keer langzamer dan een lokale variabele.
23. Het verhogen van een ongedefinieerde variabele is 9-10 keer langzamer dan een eerder geïnitialiseerde variabele.
24. Het declareren van een globale variabele zonder deze in een functie te gebruiken, vertraagt ​​ook de zaken (met ongeveer dezelfde hoeveelheid als het verhogen van een lokale variabele). PHP controleert waarschijnlijk op het bestaan ​​van een variabele.
25. De snelheid van het aanroepen van methoden is blijkbaar niet afhankelijk van het aantal methoden dat in de klasse is gedefinieerd. Ik heb 10 methoden toegevoegd aan de testklasse (voor en na de testmethode), geen prestatieverandering.
26. Methoden in afgeleide klassen zijn sneller dan die gedefinieerd in de basisklasse.
27. Een functieaanroep met één parameter en een lege functietekst is gemiddeld 7-8 stappen van de lokale variabele ($ localvar ++). Het aanroepen van een vergelijkbare methode is natuurlijk ongeveer 15 stappen.
28. Uw strings gespecificeerd met "in plaats van" zullen iets sneller worden geïnterpreteerd omdat PHP zoekt naar variabelen binnen "..", maar niet naar "...". Je kunt dit natuurlijk alleen gebruiken als er geen variabelen in je string zitten.
29. Door komma's gescheiden regels worden sneller afgedrukt dan door punten gescheiden regels. Let op: dit werkt alleen met de echo-functie, die meerdere regels als argumenten kan aannemen.
30. PHP-scripts worden minstens 2-10 keer langzamer verwerkt dan statische HTML-pagina's. Probeer meer statische HTML-pagina's en minder scripts te gebruiken.
31. Je PHP-scripts worden elke keer opnieuw gecompileerd als de scripts niet in de cache staan. Scriptcaching verhoogt de prestaties meestal met 25-100% door de compilatietijd te verwijderen.
32. Zoveel mogelijk cachen. Gebruik memcached, een krachtig in-memory objectcachingsysteem dat de snelheid van dynamische webapplicaties verbetert door het gemakkelijker te maken om databases te laden. Microcode in de cache is handig omdat het voorkomt dat uw script voor elk verzoek opnieuw wordt gecompileerd.
33. Als u met strings werkt en u ervoor moet zorgen dat de string een bepaalde lengte heeft, wilt u natuurlijk de functie strlen () gebruiken. Deze functie is erg snel, omdat het geen berekeningen uitvoert, maar alleen de reeds bekende stringlengte teruggeeft die beschikbaar is in de zval-structuur (de interne C-structuur die wordt gebruikt bij het werken met variabelen in PHP). Omdat strlen () een functie is, zal het echter traag zijn bij het aanroepen van sommige bewerkingen, zoals het converteren van een tekenreeks naar kleine letters en het doorzoeken van een hashtabel, waarna de hoofdacties van de functie worden uitgevoerd. In sommige gevallen kunt u uw code versnellen door de isset ()-truc te gebruiken.
    Was: als (strlen ($ foo)< 5) { echo «Foo is too short»; }
    Nu: if (! Isset ($ foo (5))) (echo "Foo is te kort";)
    Isset () is sneller dan strlen () omdat, in tegenstelling tot strlen (), isset () geen functie is, maar een taalconstructie. Dit betekent dat isset () vrijwel geen stringlengte-overhead heeft.
34. Het verhogen of verlagen van een variabele met $ i ++ is iets langzamer dan ++ $ i. Dit is specifiek voor PHP en u hoeft uw C- en Java-code niet op deze manier aan te passen, omdat u denkt dat deze sneller zal werken, dit zal niet gebeuren. ++ $ i zal sneller zijn in PHP, want in plaats van vier commando's, zoals bij $ i ++, heb je er maar drie nodig. Post-increment wordt meestal gebruikt bij het maken van tijdelijke variabelen die vervolgens worden verhoogd. Terwijl de pre-increment de waarde van de oorspronkelijke variabele verhoogt. Dit is een van de manieren waarop Zend Optimizer PHP optimaliseert tot bytecode. Dit is echter een goed idee, aangezien niet alle bytecode-optimizers dit optimaliseren, en er zijn ook nogal wat scripts die zonder optimalisatie naar bytecode draaien.
35. Niet alles hoeft OOP te zijn, het is vaak overkill, aangezien elke methode en elk object veel geheugen in beslag neemt.
36. Definieer niet elke datastructuur als een klasse, arrays kunnen erg handig zijn
37. Overdrijf de methoden niet. Bedenk wat je daadwerkelijk gaat hergebruiken.
38. U kunt de code indien nodig later altijd opsplitsen in methoden.
39. Gebruik talloze voorgedefinieerde functies.
40. Als uw code functies bevat die erg lang duren om te voltooien, overweeg dan om ze als extensie in C te schrijven.
41. Profileer je code. Profilering laat u zien hoe lang het duurt voordat delen van uw code worden uitgevoerd.
42. mod_gzip is een Apache-module waarmee u uw gegevens on-the-fly kunt comprimeren en de hoeveelheid overgedragen gegevens tot 80% kunt verminderen.

Tegenwoordig, wanneer speciale internetbandbreedte de norm is geworden, hoeft u zich geen zorgen te maken over de paginagrootte. Het is echter nog steeds de moeite waard om aandacht aan te besteden. Als u de belasting van de server wilt verminderen, verminder dan het aantal HTTP-verzoeken - hier zijn verschillende technieken voor. Deze tutorial behandelt een paar PHP-trucs (caching, compressie).

1. CSS-bestanden combineren met PHP.

Als webontwikkelaars splitsen we stijlen vaak op over meerdere stylesheets voor een meer logische structuur en gemakkelijke aanpassing later. Dit verhoogt echter het aantal verzoeken aan de server, wat zich vertaalt in langzamer laden van pagina's. Met PHP kunnen we twee vliegen in één klap slaan: meerdere stylesheets hebben en slechts één query gebruiken om ze allemaal te openen.

Voorbereiding

Voordat we de CSS-bestanden optimaliseren, hebben we de stijlen nodig om te werken. Laten we enkele stijlbestanden maken:

// hoofd.css
// CSS bijvoorbeeld

lichaam (
breedte: 800px;
marge: 0 automatisch;
kleur: grijs;
}

#omslag (
marge-top: 30px;
achtergrond: url (../ afbeeldingen / cats.png);
}
// typografie.css
// CSS bijvoorbeeld

lichaam (
font-familie: Arial, schreefloos;
lettergewicht: vet;
}

sterk (
lettergrootte: 120%;
}
// formulieren.css
// CSS bijvoorbeeld

formulier (
positie: relatief;
boven: 400px;
z-index: 99;
}

invoer (
hoogte: 50px;
breedte: 400px;
}

We moeten de inhoud van alle bestanden extraheren en ze in een bepaalde volgorde samenvoegen. Dit betekent dat ons script de namen van de stylesheets via de URL-parameters moet krijgen, deze bestanden moet openen en verbinden.

// Definieer variabelen
$ cssPath = "./css/";
if (isset ($ _ GET ["q"])) (
$ bestanden = $ _GET ["q"];
// Krijg een array van bestanden

foreach ($ bestanden als $ key => $ bestand) (
}

$ cssData = "";
foreach ($ bestanden als $ bestand) (

fclose ($ fileHandle);
}
}
// Vertel de browser dat we een CSS-bestand hebben
if (isset ($ cssData)) (
echo $ cssData;
) anders (
}
?>

// Definieer variabelen
// --- OPMERKING: PADEN MOETEN SLECHTE SLASH HALEN ---
$ cssPath = "./css/";
if (isset ($ _ GET ["q"])) (
$ bestanden = $ _GET ["q"];
// Ik heb de reeks bestanden!

// Laten we ervoor zorgen dat er geen enge symbolen in de bestandsnamen staan ​​:).
foreach ($ bestanden als $ key => $ bestand) (
$ bestanden [$ key] = str_replace (array ("/", "\\", "."), "", $ bestand);
}

Deze code stelt het pad in naar de map Styles en controleert op bestanden. Het pad naar de map moet aan het begin en aan het einde van de mapnaam schuine strepen hebben, anders krijgen we veel fouten. Vervolgens controleren we elke bestandsnaam en verwijderen we de puntjes en/of slashes.

$ cssData = "";
foreach ($ bestanden als $ bestand) (
$ cssFileName = $ cssPath. $ bestand. ".css";
$ fileHandle = fopen ($ cssFileName, "r");

$ cssData = "\ n". fread ($ fileHandle, bestandsgrootte ($ cssFileName));
fclose ($ fileHandle);
}
}

Nu moeten we een algemeen stijlblad van de bestanden maken. Om dit te doen, voeren we een lus uit die door een reeks bestanden loopt, elk bestand opent en het samenvoegt tot een enkel bestand. "\ n" voegt een nieuwe regel toe voor orde en netheid. De functie filesize () wordt gebruikt om de lengte van een bestand te achterhalen en door te geven aan fread ().

// Vertel de browser dat we een CSS-bestand hebben
header ("Inhoudstype: tekst / css");
if (isset ($ cssData)) (
echo $ cssData;
echo "\ n \ n // Gegenereerd:". datum ("r");
) anders (
echo "// Bestanden niet beschikbaar of geen bestanden opgegeven.";
}
?>

Het laatste deel van de code geeft alle stijlen door aan de browser. Dit betekent dat we PHP moeten vertellen dat we CSS-informatie doorgeven en dat PHP de browser hierover moet informeren. We doen dit met de header () functie, en stellen Content-type: text / css in. Vervolgens geven we de CSS door aan de klant. Maar daarvoor controleren we op de aanwezigheid van CSS-stijlen in het bestand. Als ze er niet zijn, betekent dit dat de namen van de CSS-bestanden niet zijn overgedragen. Als we bestanden hebben, dragen we ze over en voegen we een bericht toe over de generatie.

Inspectie

Dit is het moment om het script te testen. Maak een map en bestanden erin. Bekijk hieronder de mappenstructuur. Als je een andere structuur nodig hebt, vergeet dan niet om de paden te wijzigen.

Upload nu alle bestanden naar de hoofdmap van de site en open het index.php-bestand via uw browser. U zou moeten worden begroet met de zin "Bestanden niet beschikbaar of geen bestanden opgegeven". Dit betekent dat we niet de namen hebben gegeven van de bestanden die moeten worden aangesloten. Het goede nieuws is echter dat alles zonder fouten werkt. Laten we proberen "index.php? Q = main" in de browser af te drukken. U ziet de inhoud van het main.css-bestand op uw scherm. Als we meerdere bestanden moeten extraheren en combineren, moeten we het volgende verzoek sturen "index.php? Q = main & q = forms". Zoals je kunt zien, kunnen we "q =" zo vaak herhalen als we willen. U kunt ten minste 50 stylesheets combineren in één bestand.

Conclusie

Deze methode kan erg handig zijn en heeft veel voordelen. U kunt een gemeenschappelijk stylesheet hebben voor de hele site en een aparte stylesheet, bijvoorbeeld voor pagina's met formulieren.

Een kleine waarschuwing: als je het index.php-bestand in een map plaatst (niet de CSS-map), dan moet je relatieve paden naar achtergrondafbeeldingen schrijven alsof index.php je stylesheet is. Dit is wat de browser zal denken.

2. Lege regels verwijderen uit HTML en CSS

Velen van ons gebruiken veel lege regels bij het schrijven van code. Het goede nieuws is dat lege regels in PHP niet worden doorgegeven aan de browser. Ze worden echter doorgegeven in HTML.

Blanco regels verbruiken verwaarloosbare hoeveelheid verkeer. Als het verkeer naar de sites groot is, kan dit kleine cijfer uitgroeien tot een aanzienlijk aantal. Dit is waar PHP ons te hulp komt.

Voorbereiding

Hieronder staan ​​de codes voor HTML- en CSS-bestanden.

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

Weergave: blok;
breedte: 100%;
hoogte: 48px;
}
#centrale gedeelte (
lettergewicht: vet;
}

Het voordeel van dit script is dat het tegelijkertijd met zowel HTML als CSS kan werken. Het script laadt het bestand, verwijdert alle lege regels, laat slechts 1 spatie over, zodat de woorden niet worden gecombineerd tot één geheel.

$ fileDirectory = "";
$ bestand = $ _GET ["q"];
$ ext = $ naamExplode;

// Controleer op hackers
sterven ("Hackers ...!");
) anders (
// Laten we beginnen


// Wonderen van reguliere expressies

fclose ($ handvat);
// Gegevens weergeven
if ($ ext == "css") (
header ("Inhoudstype: tekst / css");
}
echo $ nieuweData;
}
?>

Meer informatie over elk deel van de code

We krijgen de naam van het bestand en controleren het type. Vervolgens extraheren we alle gegevens en verwijderen we spaties en lege regels. Deze methode is de meest primitieve en zal niet alle lege regels verwijderen, maar wel de meeste. En dat zijn nog maar een paar regels code.

$ fileDirectory = "";
$ bestand = $ _GET ["q"];
$ nameExplode = explode (".", $ bestand);
$ ext = $ naamExplode;
$ bestandsnaam = $ bestandsdirectory. $ bestand;

Deze code stelt de vereiste variabelen in. Nogmaals, we geven alle gegevens door "q". Hier wordt ook de map voor bestanden gedefinieerd.

If ($ ext! = "Css" EN $ ext! = "Htm" EN $ ext! = "Html") (
// Controleer op hackers
sterven ("Hackers ...!");
) anders (

Hier controleren we of het bestand echt CSS of HTML is.

// Laten we beginnen
$ handvat = fopen ($ bestandsnaam, "r");
$ fileData = fread ($ handvat, bestandsgrootte ($ bestandsnaam));
// Wonderen van reguliere expressies
$ newData = preg_replace ("/ \ s + /", "", $ fileData);
fclose ($ handvat);
// Gegevens weergeven
if ($ ext == "css") (

header ("Inhoudstype: tekst / css");
}
echo $ nieuweData;
}
?>

Deze code opent en leest het bestand - en verwijdert vervolgens alle witruimte zoveel mogelijk. Dit wordt bereikt door het gebruik van reguliere expressies. Alle spaties, tabs, lege regels worden gevonden en vervangen door een spatie.

Werkt het?

Als u "index.php? Q = css.css" in uw browser typt, ziet u één regel CSS. Dus alles werkt! Als u de broncode van de pagina opent, ziet u dezelfde afbeelding. Met deze methode hebben we het CSS-bestand van 314 tekens teruggebracht tot 277 tekens. HTML-bestand met 528 tot 448 tekens. Niet slecht voor 15 regels code.

Conclusie

Dit is een goed voorbeeld van hoe we veel kunnen doen met slechts een paar regels code. Als je de broncode van sites als Google bekijkt, zul je merken dat er bijna geen lege regels zijn.

3. PHP-scripts cachen.

Ik zal je laten zien hoe je caching voor je scripts instelt met behulp van het bovenstaande voorbeeld. Het doel is om de site te versnellen. Het komt erop neer dat het heel eenvoudig is: er worden niet elke keer gegevens gegenereerd wanneer u de site bezoekt. Ze worden opgeslagen in de cache.

Om caching toe te voegen, moeten we drie dingen aan ons script toevoegen. Eerst moeten we alle gegevens in een script verzamelen en een bestand genereren dat uniek is voor deze set ingevoerde gegevens. Ten tweede moeten we het cachebestand vinden en controleren hoe "vers" het is. Ten derde moeten we een kopie in de cache gebruiken of een nieuw cachebestand genereren voor later gebruik.

Meer details

$ fileDirectory = "";
$ bestand = $ _GET ["q"];
$ nameExplode = explode (".", $ bestand);
$ ext = $ naamExplode;
$ bestandsnaam = $ bestandsdirectory. $ bestand;
// - WE HEBBEN VOLDOENDE GEGEVENS OM HIER EEN CACHE BESTANDSNAAM TE GENEREREN -
if ($ ext! = "css" EN $ ext! = "htm" EN $ ext! = "html") (
// Controleer op slechte mensen ...
sterven ("Hackers ...!");
) anders (

// - WE KUNNEN HIER DE VERSIE IN CACH ONDERSCHEPPEN EN CHECHTEN -

// Terzake
$ handvat = fopen ($ bestandsnaam, "r");
$ fileData = fread ($ handvat, bestandsgrootte ($ bestandsnaam));
// Nu voor wat regex-tovenarij!
$ newData = preg_replace ("/ \ s + /", "", $ fileData);

Fclose ($ handvat);
// Tijd om de gegevens uit te voeren.

// - NU KUNNEN WE DE NIEUWE GEGEVENS OPSLAAN INDIEN NODIG EN DE GEGEVENS UITVOEREN -

Als ($ ext == "css") (
header ("Inhoudstype: tekst / css");
}
echo $ nieuweData;
}
?>

$ fileDirectory = "";
$ bestand = $ _GET ["q"];
$ nameExplode = explode (".", $ bestand);
$ ext = $ naamExplode;
$ bestandsnaam = $ bestandsdirectory. $ bestand;
$ cacheName = "./cache/". $ naamExplode. $ naamExplode. ".tmp";
if ($ ext! = "css" EN $ ext! = "htm" EN $ ext! = "html") (
// Hackers
print_r ($ ext);
sterven ("Hackers ...!");
) anders (
if (file_exists ($ cacheName) AND filemtime ($ cacheName)> (time () - 86400)) (


fclose ($ cacheHandle);
$ isCached = WAAR;
) anders (
// Laten we beginnen
$ handvat = fopen ($ bestandsnaam, "r");
$ fileData = fread ($ handvat, bestandsgrootte ($ bestandsnaam));
// Wonderen van reguliere expressies
$ newData = preg_replace ("/ \ s + /", "", $ fileData);
fclose ($ handvat);
// Wij cachen


fclose ($ cacheHandle);
$ isCached = ONWAAR;
}
// Gegevens weergeven
if ($ ext == "css") (
header ("Inhoudstype: tekst / css");
als ($ is in cache) (

}
) anders (
als ($ is in cache) (
echo "";

}
}
echo $ nieuweData;

Uitleg

In dit script is de functie toegevoegd om de cache elke 24 uur bij te werken. Het is comfortabel. Als je bijvoorbeeld iets op de site hebt gewijzigd, kun je 24 uur wachten of de cache wissen.

$ cacheName = "./cache/". $ naamExplode. $ naamExplode. ".tmp";

Dit codefragment haalt de bestandsnamen en hun extensies eruit, plakt ze aan elkaar en voegt ze toe aan de cache met de juiste ".tmp"-extensie.

If (file_exists ($ cacheName) AND filemtime ($ cacheName)> (time () - 86400)) (
$ cacheHandle = fopen ($ cacheName, "r");
$ newData = fread ($ cacheHandle, bestandsgrootte ($ cacheName));
fclose ($ cacheHandle);
$ isCached = WAAR;
) anders (

Hier controleren we de aanwezigheid van een opgeslagen cache en of deze in de afgelopen 24 uur is gemaakt (de waarde in seconden kan worden gewijzigd in een andere). Als aan beide voorwaarden is voldaan, opent u het bestand en extraheert u de inhoud om het resultaat van het script ermee te vervangen. We hebben $ isCached ook ingesteld op true om aan het einde extra berichten weer te geven.

// Laten we cachen!
$ cacheHandle = fopen ($ cacheName, "w +");
fwrite ($ cacheHandle, $ newData);
fclose ($ cacheHandle);
$ isCache = ONWAAR;
}

We cachen het resultaat van het script voor gebruik bij verdere aanroepen. We openen het bestand gewoon in de schrijfmodus, dumpen de informatie daar en sluiten af.

// Tijd om de gegevens uit te voeren.
if ($ ext == "css") (
header ("Inhoudstype: tekst / css");
als ($ is in cache) (
echo "// Opgehaald uit cachebestand. \ n";
}
) anders (
als ($ is in cache) (
echo "";
}
}

Dit deel van het script is enigszins aangepast zodat we het resultaat van het werk kunnen zien. Als de inhoud van het bestand uit de cache is gehaald, kunnen we daar een bericht aan toevoegen.

Proberen

Als we het script opnieuw gebruiken, zien we de wijzigingen pas als we de pagina vernieuwen. Hieronder zien we een inscriptie dat het bestand uit de cache is gehaald.

Conclusie

Als u snel eenvoudige caching aan elk script kunt toevoegen, betekent dit dat u in de goede richting gaat. Een script met caching zal de belasting van elke server aanzienlijk verminderen.

Opsommen

In deze tutorial heb ik je verschillende handige en eenvoudige manieren laten zien om je site te versnellen met PHP.

Van de auteur: elke zichzelf respecterende ontwikkelaar maakt zich zorgen over het "lot" van zijn code. Hij probeert de applicatie zo gemakkelijk en snel mogelijk te maken en de fouttolerantie te vergroten. Maar met PHP-optimalisatie kunt u deze hoogten niet altijd bereiken.

Behandel uw hand niet als het been kreupel is!

Sorry voor het Ierse volksaforisme! Maar het weerspiegelt de hele essentie van het probleem in de "roos". Vaker wel dan niet, zal code-optimalisatie u niet toestaan ​​om de prestaties van het gegenereerde script of bron te verbeteren. En in het geval van: alles is extreem ingewikkeld door het grote aantal factoren waar je (als ontwikkelaar) simpelweg geen invloed op hebt.

Wat betreft de fenomenen waar we geen controle over hebben, ik bedoel de snelheid van de internetverbinding, de belasting van de server, de OS-instellingen op de clientcomputer, de kracht van de pc-hardware van de gebruiker. Op al deze componenten kun je geen invloed uitoefenen. En uiteindelijk blijkt dat de optimalisatie van de PHP-code geen volwaardig resultaat zal geven.

Wat blijft onder het gezag van de webontwikkelaar:

Serverinstellingen - beperkt. Door parameters in te stellen via het Apache-configuratiebestand httpd.conf kunt u het aantal onderliggende processen, de time-out van de socketverbinding, de grootte van de uitvoerbuffer voor de TCP/IP-verbinding, de inactieve tijd en andere instellen.

Kerninstellingen voor taal - via de parameters die zijn opgegeven in het php.ini-bestand. Hiermee kunt u bufferwaarden instellen, de maximale uitvoeringstijd van het script, foutafhandeling, logbeheer en andere instellingen wijzigen.

PHP-beeldoptimalisatie - daarover later meer. Optimalisatie van de programmacode - hiermee kunt u bronnen "besparen" en de prestaties verbeteren.

U moet bijvoorbeeld weten dat echo sneller is dan afdrukken. Het is beter om de weergave van foutmeldingen na het debuggen uit te schakelen om bronnen te besparen. Gebruik echo in plaats van tekenreeksaaneenschakeling. Klasseobjecten en -methoden () nemen veel geheugen in beslag.

Werken met afbeeldingen

Ik ben geen voorstander van server-side beeldverwerking. Het leidt ook tot een verspilling van kostbare middelen, die altijd schaars zijn op de hosting. Het blijkt dat door op één te besparen, we andere "reserves" verspillen.

Optimaler is de mogelijkheid om afbeeldingen te uploaden naar een service van derden, van waaruit ze in een geoptimaliseerde vorm in de browser van de gebruiker op een bepaald adres worden geladen. Er zijn veel van dergelijke diensten op het web. Ik wil er maar een paar noemen: kraken.io, TinyPNG

Zoals je kunt zien, is kennis van PHP-zoekmachineoptimalisatie ook belangrijk voor professionele ontwikkelaars.

Bovendien heeft het zijn eigen ingebouwde hulpmiddelen voor het "verlichten" van afbeeldingen. Bijvoorbeeld de functie imagecopyresampled (). Het vermindert het gewicht van de inhoud door de afbeelding opnieuw te samplen en te vergroten/verkleinen. Gebruiksvoorbeeld:

Wat kun je nog meer?

Vergeet ook niet om client-side optimalisatie toe te passen met PHP. Tot op zekere hoogte kan de server de clientbrowser beïnvloeden via de Cache-Control, evenals de attributen van deze header: post-check, max-age en andere.

Bovendien kunt u met de Last-Modified- en ETag-headers de status van de cache op de clientcomputer controleren. Ze stellen een unieke ID in om elk bestand te wijzigen. Hierdoor verstuurt de server geen resources opnieuw, maar slechts 304 reacties met status.

In dit artikel hebben we het probleem van optimalisatie met PHP FPM niet aan de orde gesteld. Maar de overweging ervan vereist een apart artikel. En dat was alles voor vandaag. Tot de volgende keer!