Journal Portage de TapTempo en Golang

Posté par . Licence CC by-sa
Tags :
21
6
mar.
2018

Après tous les autres portages, voici la version Golang. J’essaye de montrer la simplicité du code, même si je gère une file à la main.

On voit le package simple de gestion d'options de ligne de commande (flag) et la gestion du temps(time). Je montre aussi la gestion d'un slice (issue du make) pour faire la file.

On vois aussi l'usage de init() qui est un fonction des packages exécutées avant la fonction main(). Il n'y a pas d'exemple d'objet ou de typage par les méthodes, le code étant trop simple.

        package main

        import (
            "flag"
            "fmt"
            "time"
            "bufio"
            "os"
        )

        var precision int 
        var reset int 
        var sample int 
        var version bool

        var cur_version = "a02"

        func init() {
            usage := "changer le nombre de décimale du tempo à afficher la valeur par défaut est 0 décimales, le max est 5 décimales" 
            flag.IntVar(&precision, "precision", 2, usage)
            flag.IntVar(&precision, "p", 2, usage + " (shorthand)")
            usage = "changer le nombre d'échantillons nécessaires au calcul du tempo la valeur par défaut est 5 échantillons"
            flag.IntVar(&sample, "sample", 5, usage)
            flag.IntVar(&sample, "s", 5, usage + " (shorthand)")
            usage = "afficher la version"
            flag.BoolVar(&version, "version", false, usage)
            flag.BoolVar(&version, "v", false, usage + " (shorthand)")
        }

        func main() {
            flag.Parse()        
            if version {
                fmt.Printf("Version %v\n",cur_version)
                return
            }
            print("Hit enter key for each beat (q to quit).\n")     
            times := make([]time.Time,sample)
            scanner := bufio.NewScanner(os.Stdin)
            var text string
            for text != "q" {
                scanner.Scan()
                text = scanner.Text()

                copy(times[1:sample],times[0:sample-1])
                times[0] = time.Now()

                var sum float64
                for i := 1; i < sample; i++{
                    sum += times[i-1].Sub(times[i]).Seconds()
                }
                means := sum / float64(sample-1) 
                fmt.Printf("Tempo : %.[2]*[1]f", 60 / means, precision)
            }
        }
  • # bornes ?

    Posté par (page perso) . Évalué à 2.

    Merci pour cette illustration du Golang !

    Comment se comporte le programme si l'utilisateur entre un paramètre hors bornes (genre "precision" négative) ? le module "flag" sait le gérer ?

    • [^] # Re: bornes ?

      Posté par . Évalué à 5.

      Non, ce cas n'est pas géré. Flag reconnait simplement qu'il s'agit d'un entier. Il faudrait une couche de vérification supplémentaire.

      D'ailleurs, j'ai découvert l'usage de errors.Wrap(err, "fonction_en_cours"), il n'y a pas si longtemps que je trouve assez génial : on wrap une erreur pour ajouter de l'information sur la redirection d'une erreur, la fonction ajoute aussi un moyen d’accéder au ligne/fichier. Et l'objet reste du type "error", ce qui permet de réutiliser ou d’injecter ce genre d'erreur sans problème de compatibilité.

      "La première sécurité est la liberté"

      • [^] # Re: bornes ?

        Posté par . Évalué à 4. Dernière modification le 07/03/18 à 13:41.

        Attention, errors.Wrap vient de github.com/pkg/errors ; c’est une lib non officielle de Dave Cheney, mais effectivement très pratique.

  • # Attention, programme bogué

    Posté par . Évalué à 3.

    La valeur de retour de scanner.Scan n’est pas vérifiée, le programme par en boucle infinie si stdin est fermé ;-)

    Par exemple:

    ( for i in $(seq 10) ; do echo ; sleep .2; done) | go run taptempo.go

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.