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 ^^.

6 réflexions sur « Mumuse avec GOLang … »

  1. Bonjour,

    J’ai voulu faire un test avec votre code mais j’ai une erreur :

    undefined: io.ReadAll sur la ligne:

    b,_ := io.ReadAll(resp.Body)

    ci-dessous le code :

    package main

    import (« http »
    « fmt »
    « io »
    « regexp »
    « 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(« ]*>[^]*)[\ »‘](.*)?>([^<]*)")
    ma:=re.MatchStrings(mat[i])
    for j:=range ma {
    fmt.Printf("Got[%d] : %s\n",j,ma[j])
    }
    }
    }

  2. Moi, ce que je retiens surtout de cet article, c’est qu’en 2010 (ok, 2009), y’a encore des types qui codent sur un 386, et ça, ça impose le respect… A moins que t’es voulu dire x86 :p

  3. En effet ^^ merci pour la remarque … (à ma décharge, google utilise le terme 386 dans l’option de conf ;), mais c’est bien pour les 32bit-x86)

Les commentaires sont fermés.