Salve a tutti lettori di Iba’s blog, oggi vi proponiamo un tutorialo riguardante l’installazione del compilatore ufficiale per il nuovo linguaggio Google Go, gccgo, questa guida è tratta direttamente dal sito ufficiale, buona lettura e spero che questa guida possa esservi d’aiuto nella scoperta di questo nuovo linguaggio.

Go è un progetto open source, distribuito sotto una licenza di tipo BSD.

Ci sono due modi distinti di programmare e compilare programmi con Go. Questo tutorial si concentra sul compilatore Go gc e strumenti 6g 8g ecc.

Variabili d’ambiente

L’ambiente di compilazione Go dipende da tre variabili d’ambiente che è necessario impostare nel .bashrc o equivalente, più una variabile facoltativa:

$GOROOT La radice dell’albero Go. In genere questo è $HOME/go ma può essere qualsiasi directory.

$GOOS e $GOARCH Il nome della destinazione del sistema operativo e l’architettura di compilazione. Scelte per $GOOS sono linux darwin (Mac OS X 10.5 o 10.6), e nacl (Native Client, una porta incompleta). Scelte per $GOARCH sono amd64 (x86 a 64 bit , il porto più maturi), 386 (32-bit x86), e arm (ARM a 32 bit, una porta incompleta). Le combinazioni valide sono linux / amd64 linux / arm linux / 386 darwin / amd64 darwin / 386 e nacl / 386

$GOBIN (optional) Il luogo in cui i binari saranno installati. Se si imposta $GOBIN è necessario assicurarsi che sia nel vostro $PATH . Il valore di default, $HOME/bin potrebbe già essere nel tuo $PATH

Si noti che $GOARCH e $GOOS identificano l’ambiente di destinazione, non l’ambiente in cui si sta lavorando.

Impostare queste variabili nel .bashrc Ad esempio:

export GOROOT=$HOME/go 
export GOARCH=amd64
export GOOS=linux

Double-check them dalla lista il vostro ambiente.

$ env | grep '^GO' 

Ports

I compilatori per Go supportano due sistemi operativi (Linux, Mac OS X) e tre set di istruzioni.

Vi sono importanti differenze nella qualità dei compilatori per le diverse architetture.

amd64 (aka x86-64 ); 6g,6l,6c,6a amd64 (aka x86-64 6g,6l,6c,6a

L’implementazione più mature. Il compilatore è un ottimizzatore molto efficace (registerizer) e genera un buon codice (anche se gccgo può fare decisamente meglio a volte).

386 (aka x86 or x86-32 ); 8g,8l,8c,8a 386 (aka x86 o x86-32 8g,8l,8c,8a

Paragonabile al porto amd64 non è stabile come il primo, ma dovrebbe essere altrettanto solido.

arm (aka ARM ); 5g,5l,5c,5a

Ha ancora un paio di bug in sospeso, ma sta migliorando. Testato su QEMU e su telefoni Android.

Tranne che per cose come il basso livello di codice del sistema operativo di interfaccia, il supporto runtime è la stessa in tutti i porti e include un mark-and-sweep Garbage Collector, array efficiente e string cut, il supporto per la segmentazione delle pile, e una forte implementazione goroutine.

Recuperare il repository

Se non avete installato Mercurial :

$ sudo easy_install mercurial $ Sudo easy_install mercuriale

funziona su molti sistemi. (su Ubuntu, si potrebbe provare apt-get install python-setuptools python-dev prima.) Se non funziona, visitare la pagina Mercurial Download.

Assicurarsi che la directory $GOROOT non esista o sia vuota. Consultate quindi il repository:

$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT $ Hg clone-r https release: / / hg / go.googlecode.com / $ GOROOT

Installare Go

Per installarla, è necessario disporre di GCC, le librerie standard di C, il generatore di parser Bison, made e l’editor di testo ed installato. Su OS X, che può essere installato come parte di Xcode. Su Linux,

$ sudo apt-get install bison gcc libc6-dev ed make $ Sudo apt-get install bison gcc libc6-dev ed effettuare

(o l’equivalente nella vostra distribuzione Linux).

Per costruire la distribuzione Go, assicurarsi $GOBIN (o $HOME/bin se $GOBIN non è impostato) è nel tuo $PATH e quindi eseguire

$ cd $GOROOT/src 
$ ./all.bash

Se all.bash va bene, si concluderà con la stampa

--- cd ../test 
N known bugs; 0 unexpected bugs

dove N è un numero che varia da versione a versione.

Scrivere programmi

Dato un file.go file, compilarlo con

$ 6g file.go

6g è il compilatore Go for amd64 che scriverà l’output in file.6 .Le lettere di identificazione per le 386 e le arm sono 8 e 5 Cioè, se tu fossi la compilazione di 386 si usa 8g e il risultato sarebbe chiamato file.8 .

Per collegare il file, utilizzare

 $ 6l file.6

e per eseguirlo

 $ ./6.out

Un esempio completo:

$ cat >hello.go <<EOF 
package main 

import "fmt" fmt import ""

 funzione main (){
	fmt.Printf ( "ciao, mondo \ n")
} 
 EOF
$ 6G hello.go
$ 6l hello.6
 $ ./6.out
 Ciao, Mondo
$.

Non è necessario elencare hello.6 's dipendenze dei pacchetti (in questo caso, fmt pacchetto) sulla linea di 6l di comando. Il linker impara su di loro con la lettura hello.6

Per costruire programmi più complicati, probabilmente si desidera utilizzare un Makefile. Ci sono esempi in luoghi come $GOROOT/src/cmd/godoc/Makefile e $GOROOT/src/pkg/*/Makefile

Vuoi tutti gli aggiornamenti di IbA's Blog in tempo reale? Abbonati ai nostri Feed RSS.