Go Academy · Lektion

Paket: organisera Go-kod

Paketdeklarationer, importer och exporterade namn

Lektion 1 av 412 steg

Paket: organisera Go-kod är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Go Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad är ett paket?

Varje Go-källfil tillhör ett paket. Paketnamnet står högst upp i varje fil. Paket grupperar relaterad kod och styr synligheten:

// file: math/calc.go
package math

// Exported — accessible from other packages (capital letter)
func Add(a, b int) int { return a + b }

// Unexported — package-private (lowercase)
func helper() int { return 42 }

Paketdeklaration och importsökväg

Det korta paketnamnet skiljer sig från importsökvägen (den fullständiga modulsökvägen/katalogen):

// Import path: github.com/myapp/util/stringutil
// Package name: stringutil (last segment by convention)
package stringutil

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

Importera paket

Använd import för att ta in andra paket. Go kräver att alla importer används:

package main

import (
    "fmt"                         // standard library
    "strings"                     // standard library
    "github.com/myapp/util/math"  // third-party or local
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
    fmt.Println(math.Add(1, 2))
}

Exporterade och oexporterade identifierare

Identifierare som börjar med en versal är exporterade (publika). Identifierare som börjar med en gemen är oexporterade (paketspecifika):

package server

// Exported: accessible from other packages
type Server struct {
    Addr    string   // exported field
    timeout int      // unexported field
}

// Exported method
func (s *Server) Start() error { return nil }

// Unexported helper
func (s *Server) listen() {}

Paketet main och funktionen func main

Paketet main är speciellt – det definierar ett körbart program. Funktionen main är programmets startpunkt:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
    // Program starts here and ends here
}

// All other packages are libraries — no main() needed

Funktionen init()

Varje paket kan ha en eller flera init()-funktioner som körs före main(), automatiskt och i deklarationsordning:

package config

import "fmt"

var DB string

func init() {
    DB = "localhost:5432/mydb"
    fmt.Println("config package initialized")
}

// init runs once when the package is first imported
// Multiple init() functions per file/package are allowed

Blankimport för sidoeffekter

Importera ett paket enbart för sidoeffekterna från dess init()-funktion med blankidentifieraren:

package main

import (
    "database/sql"
    _ "github.com/lib/pq"  // registers PostgreSQL driver via init()
)

func main() {
    db, err := sql.Open("postgres", "host=localhost dbname=test")
    _ = db
    _ = err
}

Importer med alias

Byt namn på ett paket vid import för att undvika namnkonflikter eller för kortare notation:

package main

import (
    "fmt"
    gomath "math"              // alias to avoid collision
    mymath "github.com/me/math"
)

func main() {
    fmt.Println(gomath.Sqrt(16))     // 4
    fmt.Println(mymath.Add(1, 2))    // 3
}

Namngivningskonventioner för paket

Go:s namngivningskonventioner för paket:

Korta, gemena namn på ett ord: http, json, fmt
Följ katalognamnet: util/stringutil/ → paketet stringutil
Undvik understreck och camelCase i paketnamn
Undvik generiska namn som util, common och helper
Paketnamnet är en del av identifieraren: föredra http.Client framför httplib.HTTPClient

Cirkulära importer

Go tillåter INTE cirkulära importer. Paket A kan inte importera B om B importerar A. Lös problemet genom att flytta gemensam kod till ett tredje paket:

// WRONG: A imports B, B imports A — compile error
// package a imports "myapp/b"
// package b imports "myapp/a"

// SOLUTION: extract shared types to package c
// package a imports "myapp/c"
// package b imports "myapp/c"
// No circular dependency

Snabbtest

Vad gör en identifierare exporterad i Go?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Paket

Viktiga paketbegrepp:

Varje fil börjar med package name
Versal = exporterad (publik), gemen = oexporterad (paketspecifik)
Importera med fullständig sökväg och använd det korta paketnamnet
init() körs automatiskt före main()
Blankimporten _ "pkg" används enbart för sidoeffekter
Inga cirkulära importer tillåts

Gratis att börja

Lär dig Go med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Paket: organisera Go-kod” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”Paket: organisera Go-kod”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Paket: organisera Go-kod”?

Paketdeklarationer, importer och exporterade namn Ni övar på Go Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Go Academy?

Du behöver inga förkunskaper. Utbildningen i Go Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Paket: organisera Go-kod”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Go Academy-lektionen?

Ja. Varje Go Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Go Academy