Go är ett open source-programmeringsspråk som utvecklats hos Google och utformat för att hjälpa till att bygga enkla pålitliga programvarusystem. Kärnstyrkan hos Go är dess samtidiga mekanismer som gör det enklare att skriva programvara, för att utnyttja multikärnarkitekturer.

Det är ett kompilerat, starkt - statiskt skrivet, samtidigt och soporuppsamlat språk.

Det är ett mycket intressant, modernt språk på grund av några av de val som har gjorts under designen. Till exempel, Typ-systemet, även om Go har metoder och även en OO-typ av programmering, finns det ingen typhierarki. Det enda sättet att uppnå det är genom gränssnitt.

Hur går det från andra

Man bör läsa språkspecifikationen för att få en bättre förståelse för språkets designelement. Det är verkligen koncist och hjälper till att ta fram några riktigt intressanta detaljer. Det sätt som Go skiljer sig från andra typiska programmeringsspråk är att det har funktioner till skillnad från andra OO-språk:

• Nej Typ Arv
• Ingen överbelastning av metoder och operatörer
• Byggd i parallella primitiva, vilket gör att det verkligen stämmer ut från mängden. Den delar minnet genom att kommunicera och inte tvärtom.
• En verktygskedja som använder en traditionell modell för kompilering och länk för att skapa binärer utan externa beroenden.
• Kartor är inbyggda.

Kod Organisation

Go-koden hålls under arbetsytor. Det är bara en kataloghierarki, enligt följande:

• src - innehåller Go-källfiler som paket
• pkg - innehåller paketobjekt
• bin - innehåller körbara filer

Go-verktyget bygger källkodspaket och installerar de resulterande binärerna i bin och pkg kataloger.

Ett enkelt webbprogram med Go

Låt oss bygga en statisk webbplats och fortsätta så att den förbättras så att den beter sig mycket dynamiskt, baserat på användarinmatning.

Den statiska webbplatsen

Kodstrukturen för den statiska sidan ser ut så här:

Så i huvudsak vill du skapa en struktur som liknar ovanstående bild eller som visas i förvaret. Denna repostruktur borde själv vara bosatt under arbetsyta . Läs om Go Code Structure för mer information.

Nu vad vi vill göra är att servera en HTML-fil bosatt i den offentliga katalogen.

De index.html innehållet är som följer:

       
Utveckla webbplats med Go
 
Jag är en statisk sida som serveras för dig med hjälp av Go lang.
   

Och här är Go-programmet för att betjäna filer statiskt från den offentliga mappen:

paketets huvudsakliga import ("net / http") func main () fs: = http.FileServer (http.Dir ("public")) http.ListenAndServe (": 8080", fs)

Låt mig förklara:

• net / http - det här paketet ger HTTP-klient och server implementeringar.
• FileServer - den här funktionen returnerar en hanterare som serverar HTTP-förfrågningar med innehållet i filsystemet.

Det är allt. Verkligen enkelt och till viss del. Du kan köra koden med följande: gå igång gostatic.go.

En bättre lösning

Denna lösning skiljer emellertid inte tydligt från routing och betjäning, och därför skulle en bättre lösning vara i linje med:

paketets huvudsakliga import ("net / http" "logg") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle ("/", fs) log.Println ...)) err: = http.ListenAndServe (": 8080", nil) om err! = Nil log.Fatal ("ListenAndServe:", err) 

ListenAndServe startar en HTTP-server på den angivna TCP-adressen och samtalar sedan Server med en hanterare. Denna hanterare är normalt noll, så att standardrutern (i Go's case the DefaultServerMux kan ta över).

Nu med avseende på DefaultServeMux - Låt oss ta en kort omväg för att förstå hur Go gör HTTP-bearbetning. Det gör det med hjälp av två primära saker.

• ServerMuxes - (Router) Det är en multiplexer - i huvudsak en HTTP-router, som jämför inkomna förfrågningar mot den definierade listan och sedan samtalar den tillhörande hanteraren.
• Handlar - Dessa är ansvariga för att "hantera" förfrågan, som att svara med lämpliga rubriker, kroppar etc. Varje objekt som lyssnar på Handler-gränssnittet kan fungera som en.

Fortsätt och kör provprogrammets webbapplikation som gjort tidigare och du bör se produktionen!

Dynamiska platser - Lägga till en tidstämpel vid varje uppdatering

Låt oss sedan skriva applikationen så att den skriver ut den aktuella tiden, vilket innebär att vid varje uppdatering får du en annan produktion. Go-koden skulle se ut så här:

paketet huvudimport ("fmt" "net / http" "tid") func main () http.HandleFunc ("/", hanteraren) log.Println ("listening ...") err: = http.ListenAndServe (": 8080 ", nil) om err! = nil panic (err) func handler (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Hej. Tiden är: "+ time.Now ) .Format (tid.RFC850)) 

Här har vi importerat fmt att arbeta med vissa utskriftsfunktioner. Fmt implementerar formaterade I / O-funktioner i linje med C: s stdio bibliotek.

Vi har också utnyttjat HandleFunc som registrerar URL-sökvägen med handlarfunktionen i DefaultServeMux. Funktionshanteraren är av typen http.HandlerFunc. Det tar en http.ResponseWriter och http.Request som dess argument. Personer som är bekanta med Java servlets skulle komma ihåg att göra detta!

För att skriva ut tid importerar vi "tid" från standardpaketet och använder det för att svara på svarskrivarens objekt. Genom att skriva till http.ResponseWriter objekt vi kan skicka svaret till klienten.

http.Request är strukturen som representerar HTTP-förfrågan och har följaktligen hela förfrågningsdata. För att komma åt webbadressen som vi gör r.URL.path.

När du kör detta och sedan åtkomst localhost: 8080 Du bör se aktuell tid vid varje uppdatering.

Acceptera användarinmatning

Låt oss nu skriva en ansökan som accepterar a Användarnamn på indexsidan och sedan när formuläret skickas, hälsar det användaren på nästa sida.

Här är vår Go-kodstruktur:

Låt oss först skapa en HTML-fil som innehåller formuläret i den offentliga katalogen.

       
Gå Greeter
 
   
   

Denna blankett, vid inlämning, kommer att omdirigera till /hälsa. Låt oss också skriva innehållet i greet.html filen i den offentliga katalogen, som vi skulle göra när begäran kommer till /hälsa.

       
Hej .
   

Go-koden är som följer:

paketet huvudimport ("log" "net / http" "html / mall") func main () http.HandleFunc ("/", root) http.HandleFunc ("/ greet", greeter) log.Println ...)) err: = http.ListenAndServe (": 8080", noll) om err! = Nil log.Fatal ("ListenAndServe:", err) func root (w http.ResponseWriter, r * http.Request) t, _: = template.ParseFiles ("public / index.html") t.execute (w, nil) func greeter (w http.ResponseWriter, r * http.Request) användarnamn: = r.FormValue användarnamn ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.execute (w, användarnamn) om err! = nil http.Error (w, err.Error (), http .StatusInternalServerError) 

Vi har använt html / mall för att hålla HTML-koden i mallar och sedan använda dem för att göra på begäran.

Det är en nyfiken look . i greeter.html fil. De html / mall paketet antar att vanlig text alltid produceras. Det lägger till att flyga när det är nödvändigt för att säkert bädda in den släta strängen i rätt sammanhang. När ett datavärde inte är vanlig text kan vi se till att det inte räddas genom att ange typ. Så väsentligt, Hallå, .! kan åberopas genom att använda tmpl.Execute (ut, HTML ('Nishant')) Att producera Hallå, Nishant!. Fortsätt prova det!

Eftersom den grundläggande applikationen nu fungerar kan vi äntligen distribuera den till Heroku.

Utplacering till Heroku

När du har Heroku-verktygsbälte korrekt inställning och repo hanteras via Git, kan vi distribuera det enligt dessa linjer.

Den enda förändring som vi skulle behöva göra i koden för att distribuera till Heroku är att ändra linjen där vi lyssna på en viss hamn.

Byta:

 http.ListenAndServe (": 8080", ...) 

till:

http.ListenAndServe ( ":" + os.Getenv ( "PORT"), ... .

Heroku Setup

För att kunna distribuera till Heroku behöver du ett Heroku användarkonto. Du behöver också en Heroku kommandoradsklient. Få det genom att installera Heroku Toolbelt om det inte redan är.

När du är installerad, logga in med hjälp av Heroku-kontot genom att säga heroku login, och ladda sedan upp din SSH-nyckel. Med dessa saker på plats borde du vara redo att distribuera till Heroku.

Implementera programmet

För att kunna distribuera till Heroku behöver vi appen lagras i Git.

git init. git add -A. git commit -m 'första heroku go app' 

Vi kommer också att behöva en Procfile för att berätta för Heroku att det kommando som det behöver köras för webbprocessen är vår app.

echo 'web: gogreeter'> Procfile

Go paket beroende beror på Heroku med hjälp av Godep paket.

Installera Godep och spara dina beroenden genom att använda följande:

gå och få github.com/kr/godep godp spara 

Lägg till dessa nya filer till Git:

git add -A. git commit -m 'godep' 

Slutligen skapa programmet Heroku. Det kan göras som så:

heroku skapa -b https://github.com/kr/heroku-buildpack-go.git 

Detta bör skapa en Git-fjärrkontroll i ditt förråd med namnet på Heroku. Du är redo att distribuera nu! Kör följande:

git push heroku master

När det här kommandot har slutförts bör din app vara igång!

Gå till webbadressen genom att säga heroku öppen eller genom att direkt besöka app-webbadressen som du ser i konsolen.

Det är allt. Du har nu ett Go-program igång på Heroku!

Sammanfattning

I denna handledning lärde vi oss hur lätt det är att utveckla ett Go-webbprogram och även distribuera det på Heroku. Dessa dagar är webbutveckling i stor utsträckning beroende av de ramar man använder. För att utforska några av dessa alternativ bör du definitivt kolla några av dessa projekt.

• Hugo
• martini
• Frossa
• Gorilla webbverktyg
• Hastie - Statisk webbplatsgenerator i Go