Skip to content

Latest commit

 

History

History
153 lines (101 loc) · 6.11 KB

01.2.md

File metadata and controls

153 lines (101 loc) · 6.11 KB
Raw

#1.2 $GOPATH und Workspaces

$GOPATH

Alle Go-Befehle bauen auf einer wichtigen Umgebungsvariable mit dem Namen $GOPATH. Bedenke, dass es sich nicht um $GOROOT, also den Installationspfad von Go, handelt. Diese Variable verweist vielmehr auf den Go Workspace auf Deinem Computer (Ich benutze den unten stehenden Pfad auf meinem Computer; solltest Du eine andere Ordnerstruktur haben, musst Du den Pfad anpassen).

In UNIX-ähnlichen System sollte die Variable dieser ähnlich sein:

export GOPATH=/home/apple/mygo

In Windows musst Du eine neue Umgebungsvariable mit dem Namen $GOPATH erstellen und ihren Wert auf C:\mygo( Dieser Wert ist abhängig von dem Pfad Deines Workspaces ) setzen.

Es ist in Ordnung, mehr als einen Pfad (bzw. Workspace) im $GOPATH zu speichern, aber bedenke, dass Du die Pfade mit : (oder ; unter Windows) von einander trennen musst. go get wird Pakete stets unter dem ersten, angegebenen Workspace speichern.

IM $GOPATH müssen die drei bestimmte Verzeichnisse vorhanden sein:

  • src für Quellcode mit der Dateiendung .go, .c, .g, .s.
  • pkg für kompilierte Dateien mit der Dateiendung .a.
  • bin für ausführbare Dateien

In diesem Buch ist mygo mein einziger Pfad in $GOPATH.

Paketverzeichnis

Erstelle Quellcodedateien und Ordner wie $GOPATH/src/mymath/sqrt.go (mymath ist der Paketname) ( Der Autor nutzt mymath als Paketnamen und gibt den Verzeichnissen, welche die Quellcodedateien beinhalten, den selben Namen).

Jedes Mal, wenn Du ein neues Paket erstellt, solltest Du einen neuen Ordner im src Verzeichnis erstellen. Diese Ordner haben überlicherweise den selben Namen, wie das Paket, welches Du nutzen möchtest. Die Verzeichnisse können zudem beliebig verschachtelt werden. Erstellst Du beispielsweise das Verzeichnis $GOPATH/src/github.com/astaxie/beedb, dann wäre das entsprechende Paket github.com/astaxie/beedb. Das Paket ist immer das letzte Verzeichnis im Pfad, in diesem Fall beedb.

Führe die Folgenden Befehle aus. ( Nun widmet sich der Autor wieder den praktischen Dingen. )

cd $GOPATH/src
mkdir mymath

Erstelle eine neue Datei mit dem Namen sqrt.go, die folgendes beinhalten soll.

// Quellcode von $GOPATH/src/mymath/sqrt.go
package mymath

func Sqrt(x float64) float64 {
	z := 0.0
	for i := 0; i < 1000; i++ {
		z -= (z*z - x) / (2 * x)
	}
	return z
}

Nun haben wir das Paketverzeichnis und den dazugehörigen Quellcode. Ich empfehle Dir, alle Paketverzeichnisse nach dem Paket selbst zu benennen und den gesamten, dazugehörigen Quellcode dort zu speichern.

Pakete kompilieren

Oben haben wir bereits unser Paket erstellt, aber wie kompilieren wir es, um es nutzen zu können? Dafür gibt es zwei Wege.

  1. Navigiere im Terminal zum Paketverzeichnis und führe den go install Befehl aus.
  2. Führe den oberen Befehl aus, diesmal jedoch mit einem Dateinamen wie go install mymath.

Nach der Kompilierung können wir den folgenden Ordner öffnen.

cd $GOPATH/pkg/${GOOS}_${GOARCH}
// Wie Du siehst, wurde eine neue Datei erstellt
mymath.a

Die Datei mit der Endung .a ist die Binärdatei unseres Pakets. Aber wie nutzen wie diese nun?

Logischerweise müssen wir dafür eine neue Anwendung schreiben, um das Paket zu nutzen.

Erstelle ein neues Paket für die Anwendung mit dem Namen mathapp.

cd $GOPATH/src
mkdir mathapp
cd mathapp
vim main.go

Und der Code:

// Quellcode von $GOPATH/src/mathapp/main.go 
package main

import (
	"mymath"
	"fmt"
)

func main() {
	fmt.Printf("Hallo, Welt. Sqrt(2) = %v\n", mymath.Sqrt(2))
}

Um die Anwendung zu kompilieren, müssen wir zurück in das Verzeichnis, in welchem die Anwendung liegt; in diesem diesem Falle unter $GOPATH/src/mathapp. Führe nun den Befehl go install aus. Nun solltest Du eine neue ausführbare Datei mit dem Namen mathapp im Verzeichnis $GOPATH/bin/ vorfinden. Um das Programm auszuführen, tippe den Befehl ./mathapp ein. Im Terminal solltest Du nun den unteren Text lesen können.

Hallo, Welt. Sqrt(2) = 1.414213562373095

Installation von Paketen Dritter (Remote Packages)

Go umfasst ein Werkzeug zum Installieren von Remote Packages, also Paketen die von anderen Programmierern erstellt wurden. Mit dem Befehl go get kannst Du diese für die eigene Nutzung installieren. Es unterstützt die meisten Open Source Communities wie Github, Google Code, Bitbucket und Launchpad.

go get github.com/astaxie/beedb

Du kannst go get -u … nutzen, um ein Remote Package zu aktualisieren. Zugleich werden auch alle benötigten Abhängigkeiten mit installiert.

Dieser Befehl nutzt verschiedene Versionskontrollsysteme für die verschiedenen Open Source Plattformen. So wird beispielsweise git für Github und hg für Google Code verwendet. Daher musst Du zuerst die entsprechenden Versionskontrollsysteme installieren, ehe Du go get nutzen kannst.

Nach dem Ausführen der oben gezeigten Befehle, sollte die Orderstruktur etwa so aussehen.

$GOPATH
	src
	 |-github.com
	 	 |-astaxie
	 	 	 |-beedb
	pkg
	 |--${GOOS}_${GOARCH}
	 	 |-github.com
	 	 	 |-astaxie
	 	 	 	 |-beedb.a

Im Hintergrund "klont" go get den Quellcode nach $GOPATH/src auf deinem Computer und nutzt dann go install zur Installation der Remote Packages.

Du kannst Remote Packages wie lokale Pakete nutzen.

import "github.com/astaxie/beedb"

Die komplette Verzeichnisstruktur

Wenn Du alle Schritte befolgt hast, sollte Deine Verzeichnisstruktur wie folgt aussehen.

bin/
	mathapp
pkg/
	${GOOS}_${GOARCH}, such as darwin_amd64, linux_amd64
  mymath.a
  github.com/
    astaxie/
      beedb.a
src/
	mathapp
		main.go
	mymath/
		sqrt.go
	github.com/
		astaxie/
			beedb/
				beedb.go
				util.go

Nun kannst Du die Ordnerstruktur klar erkennen. bin beinhaltet alle ausführbaren Dateien, pkg alle compilierten Dateien und src den Quellcode der Pakete.

(Das Format von Umgebungsvariable unter Windows ist %GOPATH%. Da dieses Buch sich jedoch am UNIX-Stil orientiert, müssen Windowsnutzer das Format von Hand ändern.)

Links