// guide technique

Convertir du WLangage en Go : méthode, équivalences et pièges

Go est une cible de choix pour les applications WinDev orientées services, outils internes ou backends : compilé, statiquement typé, déployable en binaire unique sans runtime. La syntaxe est plus stricte que le WLangage, mais la traduction est directe une fois qu'on a compris deux idiomes fondamentaux : l'absence d'exceptions et les valeurs de retour multiples.

Prérequis : exporter le code en format texte

Avant toute conversion, enregistrez vos projets en format texte dans WinDev (option de compatibilité Git). Vous obtenez des fichiers WLangage lisibles, base idéale pour une conversion assistée par IA. Notre guide complet sur la préparation : migrer depuis WinDev.

Équivalences de base WLangage → Go

L'idiome Go le plus dépaysant : la gestion d'erreur

WLangage utilise les exceptions et les procédures d'erreur (QUAND EXCEPTION DANS). Go n'a pas d'exceptions : chaque fonction qui peut échouer retourne une valeur d'erreur en second paramètre. C'est verbeux mais explicite — et c'est ce qui rend le code Go si facile à tracer en production.

QUAND EXCEPTION DANS
  OuvreConnexion(sConnexion)
  HExécuteRequêteSQL(reqSQL)
FAIRE
  Erreur("Connexion échouée : " +
        ErreurInfo())
FIN

db, err := sql.Open("postgres", dsn)
if err != nil {
    return fmt.Errorf(
        "connexion échouée : %w", err)
}
_, err = db.Exec(query)
if err != nil {
    return fmt.Errorf(
        "requête échouée : %w", err)
}

Accès aux données : de HFSQL à database/sql

Le parcours de fichier HFSQL — l'idiome central du WLangage — se traduit en requête SQL explicite via le package standard database/sql, ou via un ORM comme GORM pour les projets CRUD denses.

POUR TOUT Commande
  OÙ DateCmd >= DateDébut
  ET Statut = "Validée"
  Total += Commande.MontantHT
FIN

rows, err := db.Query(`
  SELECT MontantHT FROM Commande
  WHERE DateCmd >= $1
    AND Statut = 'Validée'`, dateDebut)
if err != nil { return err }
defer rows.Close()
for rows.Next() {
    var montant float64
    rows.Scan(&montant)
    total += montant
}

Les fonctions HLitRecherche, HAjoute, HModifie deviennent des db.QueryRow, db.Exec, ou des opérations GORM classiques. La migration de la base elle-même est traitée dans notre guide HFSQL vers SQL Server, PostgreSQL, MySQL ou MariaDB.

Tableaux et slices : l'indexation à 0

MonTableau est un tableau
  de chaînes = ["a","b","c"]
Info(MonTableau[1]) // "a"
Info(MonTableau[3]) // "c"

s := []string{"a", "b", "c"}
fmt.Println(s[0]) // "a"
fmt.Println(s[2]) // "c"
// range pour parcourir
for i, v := range s { ... }

Pièges classiques de la conversion WLangage → Go

• Pas d'exceptions — des erreurs retournées — chaque appel susceptible d'échouer doit être suivi d'un if err != nil. Les conversions automatiques par IA oublient parfois ces vérifications : la revue humaine est indispensable.
• Typage strict sans conversions implicites — WLangage convertit silencieusement un réel en entier. Go refuse : var x int = 3.14 est une erreur de compilation. Tous les cast doivent être explicites.
• Variables déclarées mais non utilisées — Go refuse de compiler si une variable locale est déclarée mais jamais lue. Le code WLangage en est souvent plein.
• Le contexte HFSQL implicite — position courante dans un fichier, filtres actifs, HLitSuivant : tout devient des requêtes SQL explicites. Plus verbeux, mais testable et déboguable proprement.
• Variables globales de projet — très courantes dans les projets WX anciens. En Go, elles deviennent des paramètres passés explicitement ou des dépendances injectées via struct, sinon le code devient impossible à tester.
• Pas d'héritage — WLangage supporte les classes héritées. Go n'a pas d'héritage : on compose des structs. La traduction n'est pas mécanique et demande une réflexion architecturale.

Concurrence : goroutines vs WLangage

WLangage gère la concurrence via les threads et tâches asynchrones (LanceTâche, MutexVerrou). Go expose un modèle plus simple avec les goroutines et les channels, qui se prête naturellement à la parallélisation de traitements HFSQL lourds.

// traitement séquentiel d'un lot
POUR TOUT Facture
  TraiterFacture(Facture.ID)
FIN

var wg sync.WaitGroup
for _, id := range ids {
    wg.Add(1)
    go func(fid int) {
        defer wg.Done()
        traiterFacture(fid)
    }(id)
}
wg.Wait()