Mumuse avec GOLang …

Depuis pas mal de temps déjà, Google a release un langage qui se veut simple, puissant … et tout et tout.

Pour savoir un peut ce que ça vaut, j’ai donc installé la bête, et fait un test basique : connexion HTTP/parsing regexp.

Pour installer la bestiole (chez moi dans le home/$USER/go) :
Les exports à mettre dans votre .bashrc ou à taper avant chaque compilation/mise à jour :

export GOROOT=~/go
export GOARCH=386 ou amd64 ou arm
export GOOS=linux
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOBIN

Pour l’installation :

apt-get install mercurial bison gcc libc6-dev ed make
hg clone -r release https://go.googlecode.com/hg/ $GOROOT
cd $GOROOT/src
./all.bash

Pour mettre à jour :

cd $GOROOT && hg pull && hg update && cd src && ./all.bash

Pour ensuite compiler un logiciel en go … c’est assez spécial, le nom du compilateur/linkeur change suivant votre architecture :

  • 8g, 8l pour les x86
  • 6g, 6l pour les amd64
  • 5g, 5l pour les arm

Pour ma part étant sur un bon vieux x86, j’obtiens donc ce genre de choses pour compiler :

8g source.go
8l source.8
./8.out

Il vous faudra donc changer le 8 par le chiffre « lié » à votre architecture.

Maintenant la source pour le plaisir des yeux (ou pas ^^), un mini soft récupérant les liens d’une page web fournit en paramètre (sans vérification du paramètre …). C’est mon « hello world » à moi.

package main
import "http"
import "fmt"
import "io"
import "regexp"
import "flag"

func main() {
	flag.Parse();
	if(flag.NArg()!=1){fmt.Printf("Il manque un argument\n");return;}
	resp := new(http.Response);
	resp,_, _ = http.Get(flag.Arg(0));
	b,_:=io.ReadAll(resp.Body);
	resp.Body.Close();
	result:=string(b);
	
	/*REGEXP*/
	re,_:= regexp.Compile("]*>[^<]*");
	mat:= re.AllMatchesString(result,0);
	for i:=range mat {
		fmt.Printf("%s\n",mat[i]);
		re,_=regexp.Compile("href=[\"']([^\"'>]*)[\"'](.*)?>([^<]*)");
		ma:=re.MatchStrings(mat[i]);
		for j:=range ma {
			fmt.Printf("Got[%d] : %s\n",j,ma[j]);
		}
	}
}

La source ne présente rien de complexe, le but étant juste pour ma part de comprendre la « logique » du langage, les retours des fonctions changent pas mal des autres langages (ça autorise juste le retour de plusieurs variables en même temps … les ingénieurs de chez google ne connaissaient pas les tableaux =)), et le style de déclaration des variables (on peut passer par des déclarations typées pour les intellos, et des déclarations alârache via les := …).

Niveau performances c’est sympa (quoiqu’un script en perl/python/php soit aussi rapide pour ce test …), niveau syntaxe ça tiens la route, les retours d’erreurs sont assez explicite ^^.