Att lära sig Go-programmering Träningskurs

1. Introduktion till Go

• Vad är Go (Golang)?
• Gos historia och designfilosofi
• Go som språk för webb- och systemprogrammering
• Väsentliga egenskaper:
  • Statisk typisering
  • Enkelhet och läsbarhet
  • Snabb kompileringsprocess
  • Inbyggd konkurrens
  • Garsortering
  • Korsplattformskompilering
• Vanliga användningsområden för Go
• Fördelar och begränsningar med Go
• Go jämfört med C/C++, JavaScript, Ruby, Python och Java
• Förståelse av Gosekosystemet
• Översikt över Go standardbibliotek
• Gomoduler och hantering av beroenden
• Anatomi av en Go-applikation
• Praktik: Granskning och exekvering av ett enkelt Goprogram

2. Ställa in Go-utvecklingsmiljön

• Installera Go
• Förstå Gots verktygskedja
• Konfigurera miljövariabler
• Välja en IDE eller kodeditor
• Använda kommandoraden med Go
• Skapa ett Go-arbetsutrymme
• Förstå Gots projektstruktur
• Initialisera ett projekt med Go-moduler
• Använda go mod init
• Hantera beroenden med go get
• Uppdatera och inspektera beroenden
• Formatera källkoden med gofmt
• Kör program med go run
• Bygg applikationer med go build
• Installera Go-applikationer
• Korskompilera applikationer
• Praktik: Skapa och konfigurera ett Goprojekt i en behållare

3. Go-variabler, konstanter och typer

• Deklarera variabler
• Explicita kontra härledda typer
• Korta variabeldeklarationer
• Konstanter
• Nollvärden
• Scope och livslängd för variabler
• Primära datatyper:
  • Heltal
  • Flottande punktal
  • Komplexa tal
  • Booleska värden
  • Strängar
• Typkonverteringar
• Arbeta med Unicode och UTF-8
• Runes och byte
• Multipel variabeltilldelning
• Förstå typsäkerhet
• Övning: Bygg ett litet kommandoradsprogram för datahantering

4. Operatorer och uttryck

• Arbetiska operatorer
• Jämförelseoperatorer
• Logiska operatorer
• Tilldelningsoperatorer
• Inkrement och dekrement
• Operatorprioritet
• Beräkningar med heltal och decimaltal
• Undvika vanliga fel vid typkonvertering
• Övning: Implementera beräkningar och valideringslogik

5. Datum, tider och formatering

• Använda time-paketet
• Skapa och manipulera datum
• Hämta aktuell tid
• Tidszoner och lägen
• Tolka datum och tider
• Formatera datum och tider
• Beräkna tidsåtgångar
• Arbeta med Unix-tidsstämplar
• Hantera tidsbegränsningar
• Övning: Lägg till tidsstämplar och tidsåtgångsberäkningar i en applikation

6. Arrayer, listor (slices), kartor och strukturer

Arrayer

• Deklarera arrayer
• Initialisera arrayer
• Iterera genom arrayer
• Mångdimensionala arrayer

Listor (Slices)

• Skilj på listor och arrayer
• Skapa listor
• Lägga till element
• Kopiera listor
• Listans längd och kapacitet
• Skära i listor
• Vanliga fallgropar med listor

Kartor

• Skapa kartor
• Lägga till och ta bort poster
• Kontrollera om en nyckel finns
• Iterera genom kartor
• Kartor som innehåller komplexa data

Strukturer

• Definiera strukturer

• Struktfält

• Initialisera strukturer

• Nästashållet strukturer

• Anonyma strukturer

• Strukturmetoder

• JSON-strukturtaggar

• Praktik: Modellera användare, produkter och applikationsdata med strukturer, listor och kartor

7. Villkorad logik och loopar

• if-sats
• else och else if
• Variabeldeklarationer inom villkor
• for-loopar
• Oändliga loopar
• Loops villkor
• break och continue
• Iterera med range
• Nästashållet loopar
• switch-sats
• Uttrycksbaserade switchar
• Flera fall
• Standardfall
• Typswitchar
• Övning: Implementera applikationens validerings- och hanteringslogik

8. Funktioner

• Definiera funktioner
• Funktionsparametrar
• Returvärden
• Flera returvärden
• Bemärkta returvärden
• Variafonka funktioner
• Anonyma funktioner
• Funktionsvärden
• Closures
• Rekursion
• Överlämna funktioner som argument
• Funktioner som returnerar fel
• Designa små, återanvändbara funktioner
• Övning: Refaktorisera befintlig kod till återanvändbara funktioner

9.pekare och minneskoncept

• Vad är en pekare?
• Adressoperatorer och referensoperatorer
• Pekare och funktionsparametrar
• Pekarmottagare
• Pekare till strukturer
• Nil-pekare
• När ska man använda pekare
• Värdesemantik kontra referenssemantik
• Förstå Gots minneshantering och garsortering
• Vanliga pekarfel
• Praktik: Ändra applikationsdata med hjälp av pekare

10. Skapa en webbapplikation i Go

• Översikt över Gos webbfunktioner
• Introduktion till net/http-paketet
• Skapa en HTTP-server
• HTTP-anförslningar och svar
• HTTP-metoder
• Anslät URL:er och frågeparametrar
• HTTP-rubriker
• HTTP-statuskoder
• Routings grundläggande
• Skapa hanterare
• Hantera formulärdata
• Tillhandahålla statiska filer
• Arbeta med HTML-mallar
• mallvariabler och kontrollstrukturer
• Strukturera en webbapplikation
• Praktik: Bygg en grundläggande Go-webbserver

11. Bygga en RESTful webbaserad tjänst

• REST-arkitektur grundläggande
• Designa API-slutpunkter
• GET, POST, PUT, PATCH och DELETE
• Arbeta med JSON
• Koda och avkoda JSON
• Validering av anförslningar
• HTTP-statuskoder
• Felsvar
• Frågeparametrar och sökvägsparametrar
• API-svarstruktur
• Skilja på hanterare och affärslogik
• Praktik: Bygg en CRUD REST API

12. Go runtime, kompilering och projektkompilation

• Förstå Gokompilatorn
• Gots byggprocess
• go run
• go build
• go install
• go test
• Byggflaggor
• miljöspecifik konfiguration
• Bygga för olika operativsystem och arkitekturer
• Tillverka självständiga binärfiler
• Hantera applikationskonfiguration
• Övning: Kompilera applikationen för flera plattformar

13. Arbeta med filer och webben

• Öppna och stäng filer
• Läsa filer
• Skriva filer
• Skapa kataloger
• Filemetadata
• Puffrad in-/utmatning
• Arbeta med strömmar
• Läsa och skriva JSON-filer
• HTTP-klienter
• Skicka utgående HTTP-anförslningar
• Hantera HTTP-klientfel
• Tidsbegränsningar och avbrott
• Processa API-svar
• Praktik: Hämta data från en extern API och spara den lokalt

14. Felhantering och felsökning

• Gos syn på fel
• Returnera fel från funktioner
• Kontrollera fel
• Skapa anpassade fel
• Inslå fel
• Lägga till kontext till fel
• errors.Is och errors.As
• Panic och återställning
• När ska man använda panic
• Felsöka vanliga Goproblem
• Logga applikationens aktivitet
• Använda Gots felsökningsverktyg
• Övning: Diagnostisera och åtgärda medvetet introducerade applikationsfel

15. Gränssnitt och abstraktion

• Vad är ett gränssnitt?
• Implicita gränssnittsimplementationer
• Definiera gränssnitt
• Gränssnittsvärden
• Tomma gränssnitt / any
• Typåtgärder
• Typswitchar
• Implementeringar med pekare kontra värde
• Designa små gränssnitt
• Beroendeinversion
• Använda gränssnitt för testning
• Minska applikationskoppling
• Praktik: Inför gränssnitt i exempelwebbapplikationen

16. Paket och projektorganisation

• Skapa paket
• Namnkonventioner för paket
• Exporterade och icke-exporterade identifierare
• Importera paket
• Paketinitialisering
• Organisera applikationslager
• Internt paket
• Hantera beroenden med Go-moduler
• Semantisk versionering
• Använda tredjepartspaket
• Undvika cirkulära beroenden
• Designa underhållbara Goprojekt
• Övning: Refaktorisera applikationen till separata paket

17. Konkurrens med goroutines

• Vad är konkurrens?
• Goroutines
• Starta goroutines
• Förstå lättviktskonkurrens
• Utsynkroniseringsutmaningar
• Delat tillstånd
• Tillståndsconflikter
• Använda sync.WaitGroup
• Mutexar och läs-/skrivmutexar
• Atomära operationer
• Praktik: Konvertera en sekventiell uppgift till konkurrensbaserad hantering

18. Kanaler

• Förstå kanaler
• Skicka och ta emot värden
• Puffrade kontra opuffrade kanaler
• Blokkerande beteende
• Stänga kanaler
• Range över kanaler
• Riktade kanaler
• Kanalbaserad kommunikation
• Select-satser
• Tidsbegränsningar och avbrott
• Arbetspool-mönster
• Producer/konsument-mönster
• Praktik: Bygg ett konkurrensbaserat arbetssystem

19. Kontext och anförslningshantering

• Varför kontexter är viktiga i webbapplikationer
• context.Context
• Anförslningskontext
• Avbrott
• Deadlineer
• Tidsbegränsningar
• Propagera kontext genom applikationslager
• Avbryta databas- eller HTTP-operationer
• Undvika felanvändning av kontexter
• Övning: Lägg till anförslningsavbrott och tidsbegränsningar i webbapplikationen

20. Testa Go-applikationer

• Varför automatiserad testning är viktig
• Skriva enhetstester
• testing-paketet
• Testfunktioner
• Namnkonventioner för tester
• Tabellbaserade tester
• Testa fel
• Testa HTTP-hanterare
• HTTP-testserver
• Testfixturer
• Testtäckning
• Benchmarks
• Exempletster
• Testa gränssnitt med mocks eller fakes
• Praktik: Skapa ett testsuite för exempelapplikationen

21. Prestandaoptimering

• Förstå prestandan i Go-applikationer
• Identifiera flaskhalsar
• CPU kontra minnesprestanda
• Effektiva datastrukturer
• Minska onödiga allokeringar
• Strängar, byte och buffertar
• Goroutinehantering
• Undvika onödig konkurrens
• Cachestrategier
• Databas- och nätverksöverväganden
• Profilera applikationer
• Benchmarks och prestandatester
• Använda Gots profileringsverktyg
• Övning: Profilera och optimera en medvetet ineffektiv applikation

22. Säkerhet och robusta webbapplikationssätt

• Validera användarinput
• Säker hantering av HTTP-anförslningar
• Förebygga vanliga webbsårbarheter
• Säker felhantering
• Begrepp för autentisering och auktorisering
• Hantera hemligheter och konfiguration
• Säker HTTP-kommunikation
• Undvika känslig information i loggar
• Hantering och uppdatering av beroenden
• Resursgränser och anslutningstider
• Övning: Granska och härda exemplapi:t

23. Applikationsloggning och observabilitet

• Loggningsgrundläggande
• Strukturerad loggning
• Loggnivåer
• Anslutningsloggning
• Fellloggning
• Korrelation och anslutnings-id:n
• Övervaka applikationens beteende
• Grundläggande metrik
• Hälsokontrollslutpunkter
• Diagnostisera produktionsproblem
• Praktik: Lägg till strukturerad loggning och hälsokontroller

24. Containerisera Go-applikationen

• Varför använda behållare?
• Go-applikationer och containerisering
• Skriva en Dockerfile
• Mångstadias bygg
• Bygga en minimal körningsmiljö
• Hantera konfiguration via miljövariabler
• Behållarnätverk
• Exponera applikationens portar
• Köra applikationen i en behållare
• Testa containeriserade applikationer
• Praktik: Packa den exemplificerade Go-applikationen som en produktionsklar behållare

25. Implementering

• Förbered en applikation för produktion
• Bygg produktionsbinärfiler
• Miljökonfiguration
• Behållarbaserad implementering
• Implementeringsarkitektur
• Omvänd proxy
• HTTPS/TLS överväganden
• Applikationshälsokontroller
• Glad stängning
• Hantera operativsystemssignaler
• Skalning av Go-webbapplikationer
• Horisontell kontra vertikal skalning
• Grundläggande felsökning vid implementering
• Praktik: Implementera den exemplificerade webbapplikationen

26. Avslutande arbete: Komplett Go-webbapplikation

Deltagarna samlar begreppen genom att utveckla en komplett applikation.

Projektet kan innehålla:

• Projektinitiering med Go-moduler
• Paketorganisation
• HTTP-rutning
• REST API-slutpunkter
• JSON-anslans- och svarshantering
• Inputvalidering
• Felhantering
• Gränssnitt
• Konkurrensbaserad hantering
• Kommunikation med externa API:n
• Fil- eller databasspel
• Automatiserade tester
• Loggning
• Prestandaöverväganden
• Containerisering
• Produktionskonfiguration
• Implementering

27. Genomgång och bästa praxis

• Genomgång av Gots kärnsyntax
• Gos kodingskonventioner
• Skriva idiomatiskt Go
• Hålla koden enkel
• Effektiv paketdesign
• Bästa praktiken för felhantering
• Gränssnittsdesignprinciper
• Bästa praktiken för konkurrens
• Teststrategier
• Prestandaöverväganden
• Underhållbarhet och läsbarhet
• Vanliga misstag gjorda av nya Go-utvecklare
• Rekommenderade angreppssätt för fortsatt Go-utveckling

28. Slutsats

• Genomgång av viktiga begrepp
• Genomgång av den färdiga webbapplikationen
• Frågor och diskussion
• Felsökning av vanliga realitetsbaserade scenarioer
• Rekommenderade nästa steg för Go-utveckling
• Ytterligare Gots bibliotek och ekosystemresurser
• Ytterligare möjligheter att bygga produktionskvalitets Go-tjänster