Låt oss nu försöka lägga till detta kodblock till din HTML-kod:

Hej världen!"; ?>

Om du visar detta PHP-dokument i en webbläsare kommer det att se ut ungefär så här:

Men det kommer att vara intressant att se HTML-koden i webbläsaren (välj "visa källa"):

PHP-koder är borta! Från första lektionen kommer du ihåg att endast servern kan se PHP-koder - klienten (webbläsarprogrammet) ser bara resultatet!

Vi får se vad som händer. Vi ber servern att skriva

Hej världen!

Vårt första exempel är uppenbarligen inte särskilt imponerande. Men skynda dig inte! Nu blir det mer intressant. Låt oss titta på ett annat exempel.

Exempel: Nu!

Låt oss tvinga servern att skriva något annat. Vi kan till exempel be den att mata ut aktuellt datum och tid:

I webbläsaren ser vi:

Relevant HTML-kod:

Det blir lite mer intressant, eller hur?

Servern visar datum och tid när PHP-sidan renderas. Observera att när du uppdaterar sidan i din webbläsare kommer den nya tiden att visas. Servern visar aktuellt datum och tid när sidan skickas till klienten.

Observera också att HTML endast innehåller datum och tid, men inte PHP-koder. Därför är detta exempel oberoende av vilken webbläsare som används. I verkligheten utförs all funktionalitet server teknik och alltid fungerar i alla webbläsare!

upd: Var försiktig, texten innehåller satir och kodbrott

PHP-programmeringsspråket går tillbaka till 1995 och är en produkt av eran då moderna webbstandarder föddes, såsom http (version 1.0 - 1996), html (version 2.0 - 1995), javascript (1995), url (1990 - 1994). Ursprungligen stod förkortningen php för Personal Home Page Tools, sedan omvandlad till Hypertext Preprocessor eller "hypertext preprocessor". De kommande styckena kommer att ägnas åt att använda PHP som en förprocessor.

PHP-tolken låter dig infoga speciella taggar i vilken text som helst, med vilken du kan infoga dynamiskt innehåll på sidan, vilket är mycket bekvämt att använda i html-dokument. Det resulterande resultatet skickas omedelbart till standardutgångsenheten, känd som stdout (se för mer information). Det är möjligt att buffra utdata tills det behövs genom ob_start-funktionen, men för vår första html-sida kommer detta inte att behövas. Den senaste html-standarden, nummer 5, introducerade flera nya taggar för att förenkla uppmärkning och göra webben mer läsbar och semantisk (vad det än betyder). Låt oss därför omedelbart dra nytta av HTML5s fulla kraft och skriva en sidmall med inlägg med förbehandlaren i fråga.

Låt oss spara den här sidan i filen index.html. Bloggens funktionalitet i sin första version kommer att innefatta att lagra publikationer i form av html-sidor i en fördefinierad katalog (till exempel sidor/) och en meny som låter dig gå direkt till önskad publikation.

Ett exempel på en publikation som kommer att visas på ett bloggflöde.

Låt oss lägga till en sidor/katalog till projektets rot och spara vår artikel under ett godtyckligt namn, till exempel 2018-trends.html.

Nu behöver vi en webbserver för att behandla inkommande http-förfrågningar från användare och en applikationsserver för affärslogik. För att inte skapa onödiga entiteter kommer vi att skriva ett litet program i programmeringsspråket Go, som kommer att fungera både som webbserver och innehålla bloggkod. För att överföra användarförfrågningar från värdprogrammet till förprocessorn kommer vi att använda standardinmatningsströmmen (stdin) för att serialisera data, vi kommer att använda det populära formatet för dataserialisering - json;

Skript för bearbetning av indata:

Bloggkod:

main.go

paketets huvudimport ("encoding/json" "io/ioutil" "net/http" "os/exec" "strings" "github.com/labstack/echo") func main() ( e:= echo.New() e.GET("/", index) e.GET("/pages/:page", index) e.Start(":8000") ) func index(c echo.Context) error ( outData:= struct ( Menu) string `json:"menu"` Sidsträng `json:"pages"` )() outData.Menu = make(string, 0) outData.Pages = make(string, 0) page:= c.Param("page" ) filer, _ := ioutil.ReadDir("sidor") för _, fil:= intervallfiler ( if !file.IsDir() ( outData.Menu = append(outData.Menu, fil.Namn()) ) if page != "" && page == file.Name() ( fbody, _ := ioutil.ReadFile("pages" + "/" + file.Name()) outData.Pages = append(outData.Pages, string(fbody) )) ) else if page == "" ( fbody, _ := ioutil.ReadFile("pages" + "/" + file.Name()) outData.Pages = append(outData.Pages, string(fbody)) ) ) rendered:= renderContent(outData) return c.HTMBLlob(http.StatusOK, rendered) ) func renderContent(input interface()) byte ( jsonInput, _ := json.Marshal(input) tmplEngine:= exec.Command("php ", "-f", "index.php") tmplEngine.Stdin = strings.NewReader(string(jsonInput)) rendered, _ := tmplEngine.Output() return rendered )

Länkar2 http://localhost:8000

Resultatet presenteras på KDPV.

En nyfiken läsare kanske märker att vi förlorar mycket i prestanda genom att lansera en PHP-process för varje begäran. Denna punkt kan enkelt optimeras med hjälp av mekanismen

I den här artikeln pratade jag om hur man får en uppsättning data från en databastabell som motsvarar sidan som valts av användaren. I den här artikeln ska vi titta på Pagineringsutdata i PHP. Pagineringär en lista över själva sidorna. Det finns olika alternativ på Internet, men de lider alla av en sak - en enorm mängd kod för att skapa ett oändligt antal alternativ. Men behöver du verkligen oändlighet? Du behöver bara 1 alternativ, som kommer att finnas på webbplatsen. I den här artikeln är vi med dig låt oss skapa en relativt komplex paginering, men det kommer inte att finnas mycket kod alls.

Till skapa paginering i PHP, måste vi ha flera parametrar vid ingången:

• count_pages- antal sidor.
• aktiva- aktuell aktiv sida.
• count_show_pages- antal sidor som visas. Till exempel om det finns 1000 sidor, då är det mycket problematiskt att visa dem alla. Därför kommer endast den angivna kvantiteten att visas i denna parameter.
• url- Adressen till sidan för vilken och Paginering skapas.
• url_page- Adress till sidan med parametern sida utan värde i slutet. Till exempel, " /abc.php?func=create&page=".

Nu kan vi skapa paginering, så här ser det ut PHP:

/* Inmatningsparametrar */
$count_pages = 50;
$aktiv = 15;
$count_show_pages = 10;
$url = "/index.php";
$url_page = "/index.php?page=";
if ($count_pages > 1) ( // Allt detta endast om antalet sidor är större än 1
/* Nästa är beräkningen av den första sidan som ska visas och den sista (så att den aktuella sidan är någonstans i mitten, om möjligt, och så att det totala antalet sidor som visas är lika med count_show_pages, eller mindre om antalet sidor räcker inte) */
$left = $active - 1;
$right = $count_pages - $active;
om ($vänster< floor($count_show_pages / 2)) $start = 1;
annars $start = $active - floor($count_show_pages / 2);
$end = $start + $count_show_pages - 1;
if ($end > $count_pages) (
$start -= ($end - $count_pages);
$end = $count_pages;
if ($start< 1) $start = 1;
}
?>

Jag ska genast säga att även om koden är liten är den ganska komplex för nybörjare. 3 år sedan Jag ägnade mycket tid åt att göra något sånt här och sedan visade sig koden 2 gånger mer.

Och då kan du göra det här Paginering via CSS dekorera som du vill. Du kan också ändra layouten om så önskas (till exempel istället för vinkelparenteser " Föregående sida"och liknande, lägg vackra bilder), det viktigaste är att inte röra PHP-kod.

Den här är väldigt bekväm Paginering implementeras på den här webbplatsen, såväl som på några av mina andra webbplatser.

Skapa en fil med namnet hello.php och lägg den i din webbservers rotkatalog (DOCUMENT_ROOT) med följande innehåll:

Exempel #1 Vårt första PHP-skript: hello.php

Hej världen

Använd din webbläsare för att komma åt filen med din webbservers URL, som slutar med /hej.php Filreferens. När du utvecklar lokalt kommer denna URL att vara något liknande http://localhost/hello.php eller http://127.0.0.1/hello.php men detta beror på webbserverns konfiguration. Om allt är korrekt konfigurerat kommer denna fil att tolkas av PHP och följande utdata kommer att skickas till din webbläsare:

Hej världen

Detta program är extremt enkelt och du behövde verkligen inte använda PHP för att skapa en sida som denna. Allt det gör är att visa: Hej världen använder PHP eko påstående. Observera att filen behöver inte vara körbar eller speciell på något sätt. Servern får reda på att den här filen måste tolkas av PHP eftersom du använde tillägget ".php", som servern är konfigurerad att skicka vidare till PHP. Se det här som en vanlig HTML-fil som råkar ha en uppsättning speciella taggar tillgängliga för dig som gör många intressanta saker.

Om du provade det här exemplet och det inte matade ut någonting, det bad om nedladdning, eller om du ser hela filen som text, är chansen stor att servern du är på inte har PHP aktiverat eller inte är korrekt konfigurerad. Be din administratör att aktivera det åt dig med hjälp av installationskapitlet i manualen. Om du utvecklar lokalt, läs även installationskapitlet för att se till att allt är korrekt konfigurerat. Se till att du kommer åt filen via http med servern som ger dig utdata. Om du bara tar fram filen från ditt filsystem kommer den inte att tolkas av PHP. Om problemen ändå kvarstår, tveka inte att använda något av de många alternativen.

Poängen med exemplet är att visa det speciella PHP-taggformatet. I det här exemplet använde vi för att indikera början av en PHP-tagg. Sedan lade vi PHP-satsen och lämnade PHP-läget genom att lägga till den avslutande taggen, ?> . Du kan hoppa in och ut ur PHP-läge i en HTML-fil som denna var du vill. För mer information, läs avsnittet i manualen om den grundläggande PHP-syntaxen.