Go er et open source programmeringsspråk utviklet hos Google og designet for å bidra til å bygge enkle, pålitelige programvaresystemer. Kjernestyrken til Go er dens samtidige mekanismer som gjør det enklere å skrive programvare, for å utnytte flere kjernearkitekturer.

Det er et kompilert, sterkt - statisk skrevet, samtidig og søppel-samlet språk.

Det er et veldig interessant, moderne språk på grunn av noen av de valgene som har blitt gjort under utformingen. For eksempel, Type-systemet, selv om Go har metoder og også en OO-stil med programmering, er det ingen type hierarki. Den eneste måten å oppnå det på er gjennom grensesnitt.

Hvordan går det fra andre

Man bør lese språkspesifikasjonen for å få bedre forståelse av designelementene i språket. Det er veldig konsistent og hjelper til med å få frem noen veldig interessante detaljer. Måten Go er forskjellig fra andre typiske programmeringsspråk, er at den har funksjoner i motsetning til andre OO-språk:

• Ingen Type Arv
• Ingen overbelastning av metoder og operatører
• Bygget i samtidige primitiver, som gjør det virkelig skiller seg ut fra mengden. Den deler minne ved å kommunisere og ikke omvendt.
• En verktøykjede som bruker en tradisjonell modell for kompilering og lenke for å generere binærfiler uten eksterne avhengigheter.
• Kartene er innebygd.

Kodeorganisasjon

Go-koden holdes under arbeidsområder. Det er bare et kataloghierarki, som følger:

• src - inneholder Go source-filer som pakker
• pkg - inneholder pakkeobjekter
• bin - inneholder kjørbare

Go-verktøyet bygger kildepakker og installerer de resulterende binærene i bin og pkg kataloger.

Et enkelt webprogram ved hjelp av Go

La oss bygge et statisk område og fortsette å forbedre det slik at det oppfører seg mye mer dynamisk, basert på brukerinngang.

Det statiske nettstedet

Kodestrukturen for det statiske nettstedet ser slik ut:

Så, i det vesentlige vil du opprette en struktur som ligner på bildet ovenfor eller som vist i depotet. Denne repo strukturen vil selv være bosatt under arbeidsområde . Les om Go Code Structure for mer informasjon.

Nå er det vi ønsker å gjøre, servere en HTML-fil som er bosatt i den offentlige katalogen.

De index.html innholdet er som følger:

       
Utvikle nettstedet ved hjelp av Go
 
Jeg er en statisk side som blir servert til deg ved hjelp av Go lang.
   

Og her er Go-programmet for å betjene filer statisk fra den offentlige mappen:

pakke viktigste import ("netto / http") func main () fs: = http.FileServer (http.Dir ("public")) http.ListenAndServe (": 8080", fs)

Tillat meg å forklare:

• netto / http - denne pakken gir HTTP klient og server implementeringer.
• FileServer - denne funksjonen returnerer en behandler som serverer HTTP-forespørsler med innholdet i filsystemet.

Det er det. Virkelig enkelt og til poenget. Du kan kjøre koden ved å bruke følgende: gå løp gostatic.go.

En bedre løsning

Imidlertid løsner denne løsningen ikke klart ruting og betjeningshensyn, og derfor vil en bedre løsning være i tråd med:

pakke hovedinnføring ("net / http" "logg") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle ("/", fs) log.Println ...)) err: = http.ListenAndServe (": 8080", null) hvis feil! = Null log.Fatal ("ListenAndServe:", err) 

ListenAndServe starter en HTTP-server på den oppgitte TCP-adressen og deretter samtaler Servere med en handler. Denne håndteringen er vanligvis null, slik at standard ruteren (i Go's case the DefaultServerMux kan ta over).

Nå med hensyn til DefaultServeMux - La oss ta en kort omvei for å forstå hvordan Go gjør HTTP-behandling. Det gjør det ved hjelp av to primære ting.

• ServerMuxes - (Router) Det er en multiplexer - hovedsakelig en HTTP-ruter, som sammenligner innkommende forespørsler mot den definerte listen og deretter ringer den tilknyttede handleren.
• handlers - Disse er ansvarlige for å håndtere forespørselen, for eksempel å svare med de aktuelle overskriftene, kroppen etc. Ethvert objekt som overholder Handler-grensesnittet, kan fungere som en.

Gå videre og kjør prøvewebappsappen som gjort tidligere, og du bør se utgangen!

Dynamiske nettsteder - Legge til en tidsstempel på hver oppdatering

Neste, la oss skrive programmet slik at det skriver ut nåværende tid, noe som betyr at ved hver oppdatering får du en annen utgang. Go-koden vil se slik ut:

pakke main import ("fmt" "net / http" "tid") func main () http.HandleFunc ("/", handler) log.Println ("listening ...") err: = http.ListenAndServe (": 8080 "nil) hvis feil! = null panic (err) func handler (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Hei. Tiden er: "+ time.Now ) .Format (tid.RFC850)) 

Her har vi importert FMT å jobbe med noen utskriftsfunksjoner. Fmt implementerer formaterte I / O-funksjoner i tråd med C's stdio bibliotek.

Vi har også gjort bruk av HandleFunc som registrerer URL-banen med håndteringsfunksjonen i DefaultServeMux. Funksjonshåndteringen er av typen http.HandlerFunc. Det tar en http.ResponseWriter og http.Request som sine argumenter. Folk som er kjent med Java servlets vil huske å gjøre dette!

For å skrive ut tid importerer vi "tid" fra standardpakken og bruker den til å svare på svarskriverobjektet. Ved å skrive til http.ResponseWriter objekt vi kan sende svaret til klienten.

http.Request er strukturen som representerer HTTP-forespørselen og dermed har hele forespørseldataene. For å få tilgang til URL-banen vi gjør r.URL.path.

Når du kjører dette og deretter får du tilgang localhost: 8080 Du bør se nåværende tid på hver oppdatering.

Godta brukerinngang

La oss nå skrive et program som aksepterer a brukernavn På indekssiden og deretter når skjemaet er sendt, hilser det brukeren på neste side.

Her er vår Go-kode struktur:

Lar først lage en HTML-fil som inneholder skjemaet inne i den offentlige katalogen.

       
Gå Greeter
 
   
   

Dette skjemaet, på innlevering, vil omdirigere til /hilse på. La oss også skrive innholdet i greet.html fil i den offentlige katalogen, som vi ville gjengi når forespørselen kommer til /hilse på.

       
Hallo .
   

Go-koden er som følger:

pakke main import ("log" "net / http" "html / template") func main () http.HandleFunc ("/", root) http.HandleFunc ("/ greet" greeter) log.Println ...)) err: = http.ListenAndServe (": 8080", null) hvis feil! = Null 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) brukernavn: = r.FormValue brukernavn ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.ekskluder (w, brukernavn) hvis err! = null http.Error (w, err.Error (), http .StatusInternalServerError) 

Vi har brukt html / mal å holde HTML-koden i maler og deretter bruke dem til å gjengi, på forespørsel.

Det er en nysgjerrig utseende . i greeter.html fil. De html / mal pakken antar at ren tekst alltid produseres. Det legger til å rømme hvor det er nødvendig for å sikkert legge inn den enkle strengen i riktig sammenheng. Når en dataværdi ikke er ren tekst, kan vi forsikre oss om at den ikke er rømt ved å spesifisere typen. Så egentlig, Hei, .! kan påberopes ved å bruke tmpl.Execute (ut, HTML ('Nishant')) å produsere Hei, Nishant!. Fortsett, prøv det!

Siden grunnleggende applikasjonen nå fungerer, kan vi endelig distribuere den til Heroku.

Utplassering til Heroku

Når du har heroku-verktøybelte riktig oppsett og repo administrert via Git, kan vi distribuere det på disse linjene.

Den eneste forandringen vi måtte gjøre i koden for distribusjon til Heroku, er å endre linjen der vi lytte på en bestemt port.

Endring:

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

til:

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

Heroku Setup

For å kunne distribuere til Heroku, trenger du en Heroku brukerkonto. Du vil også trenge en Heroku kommandolinjeklient. Få det ved å installere Heroku Toolbelt hvis ikke allerede.

Når du er installert, logg inn med Heroku-kontoen ved å si heroku logg inn, og last deretter opp SSH-nøkkelen din. Med disse tingene på plass, bør du være klar til å distribuere til Heroku.

Implementere programmet

For å kunne distribuere til Heroku, trenger vi appen som skal lagres i Git.

git init. git add -A. git commit -m 'første heroku go app' 

Vi vil også trenge en Procfile for å fortelle Heroku at kommandoen den trenger for å kjøre for webprosessen, er vår app.

ekko 'web: gogreeter'> Procfile

Go pakkeavhengigheter styres på Heroku ved hjelp av Godep pakker.

Installer Godep og lagre dine avhengigheter ved å bruke følgende:

gå github.com/kr/godep godp save 

Legg til disse nye filene til Git:

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

Endelig opprett Heroku-programmet. Det kan gjøres slik:

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

Dette bør opprette en Git-fjernkontroll i oppbevaringsstedet ditt med navnet på heroku. Du er klar til å distribuere nå! Kjør følgende:

git push heroku master

Etter at kommandoen ovenfor er fullført, bør appen din være oppe!

Gå til nettadressen ved å si heroku åpen eller ved å gå direkte til app-nettadressen som du ser i konsollen.

Det er det. Du har nå et Go-program som kjører på Heroku!

Sammendrag

I denne opplæringen lærte vi hvor lett det er å utvikle et Go-webprogram og også distribuere det på Heroku. I disse dager er webutvikling i stor grad avhengig av de rammer man bruker. For å utforske noen av disse alternativene, bør du definitivt sjekke noen av disse prosjektene.

• Hugo
• martini
• Revel
• Gorilla web toolkit
• Hastie - Statisk nettsted generator i Go