Tutoriels
Articles

Accueil / Articles / Présentation de Go pour le développeur PHP

Présentation de Go pour le développeur PHP

Publié le 24 Mars 2025
Go

Go (ou Golang) est un langage de programmation open-source développé dès 2007 au sein de Google par Ken Thompson, Rob Pike et Robert Griesemer, puis publié en 2009. Conçu pour être simple, efficace et adapté aux solutions cloud, il se distingue par sa rapidité d’exécution, une gestion native de la concurrence et un écosystème épuré.

Les caractéristiques principales de Go

Une syntaxe simple et épurée

Go adopte une approche minimaliste avec une syntaxe inspirée du C, tout en supprimant certaines complexités présentes dans des langages orientées objets comme l’héritage ou la gestion explicite des exceptions.

Voici un exemple pour illustrer ceci : 


package main

import "fmt"

type User struct {
   Name   string
   Email    string
   Age       int
}

func main() {
   user1 := User{"Toto", "toto@example.com", 30}
   user1.Name = "Titi" // Modification directe

   fmt.Println("Utilisateur :", user1.Name, "Email :", user1.Email, "Âge :", user1.Age)
}

Le même code en PHP : 


class User {
   private string $name;
   private string $email;
   private int $age;

   public function __construct(string $name, string $email, int $age) {
       $this->name = $name;
       $this->email = $email;
       $this->age     = $age;
   }

   public function setName(string $name): void {
       $this->name = $name;
   }

   public function getName(): string {
       return $this->name;
   }

   public function display(): void {
       echo "Utilisateur : {$this->name}, Email : {$this->email}, Âge : {$this->age}\n";
   }
}

$utilisateur = new User("Toto", "toto@example.com", 30);
$utilisateur->setName("Tutu");
$utilisateur->display();

En Go pas besoin de getters ou setters, les champs sont publics s’ils commencent par une majuscule et sont directement modifiables.

Les mots clés class, private, public, new, etc … disparaissent. En Go, une struct suffit et l’instanciation est plus simple.

Le code est moins verbeux. Pour la même fonctionnalité, on a moins de code à écrire, une simple structure de données suffit.

Compilation rapide

Certes, Go est un langage compilé. Il faut reconstruire un binaire à chaque modification, mais il est plus rapide à l’exécution.

Gestion native de la concurrence

Go utilise des goroutines et des channels pour gérer efficacement la concurrence sans recourir à des threads. Nous reviendrons de manière plus détaillée sur ces concepts dans un article dédié.

Garbage collector optimisé

Go gère la mémoire automatiquement avec un ramasse-miette, comme en PHP. Cependant, le garbage collector de Go est plus performant. En effet en PHP, l’exécution peut être ralentie sur des gros scripts, car le ramasse-miette doit analyser toutes les références. En Go, le ramasse-miette est optimisé pour minimiser l’impact sur les performances, ce qui s’avère très utile sur des applications web à fortes charges.

Un typage statique et fort

Go impose un typage fort et statique, ce qui permet d’éviter des erreurs courantes présentes dans des langages à typage dynamique.

Depuis PHP 7, le typage a été amélioré mais reste optionnel : 


declare(strict_types=1); // Active le typage strict

function addition(int $a, int $b): int {
   return $a + $b;
}

echo addition(10, 5);
echo addition("10", 5);

Si strict_type=1 (qui doit être ajouté dans chaque fichier) n’est pas ajouté, PHP convertira “10” en int.

Voici le même code en Go : 


package main

import "fmt"

func addition(a int, b int) int {
   return a + b
}

func main() {
   fmt.Println(addition(10, 5)) // 15

   fmt.Println(addition("10", 5)) // ERREUR : types incorrects (impossible de compiler)
}

Une librairie standard pertinente

La bibliothèque standard de Go propose des outils intégrés pour le réseau, la manipulation de chaînes de caractères, l’écriture de tests réduisant ainsi l’utilisation de librairies tierces.

La cross-compilation

A partir d’une machine sous un OS et une architecture processeur donnée, il est possible de compiler un programme pour d’autres OS (Windows, Linux, macOS) et architectures.

Pourquoi un développeur PHP devrait s’intéresser à Go ?

Un développeur PHP expérimenté, à déjà une bonne maîtrise du développement backend, de la gestion des bases de données et de la création d’API. PHP est déjà un très bon langage pour des problématiques web. Cependant, Go peut apporter plusieurs avantages, surtout pour monter en compétences sur des problématiques de performance, de concurrence et de scalabilité.

Une performance accrue

PHP est un langage interprété. Chaque exécution d’un script nécessite d’être analysée et exécutée par l'interpréteur PHP. En GO, le code est compilé pour être transformé en binaire exécutable. De ce fait, le programme en Go s’exécutera plus rapidement qu’en PHP.

Pour illustrer cette notion de performance, en développant une API REST en PHP avec un framework comme Symfony ou Laravel, chaque requête nécessite le chargement de l’environnement PHP, l'initialisation de l’application ou du framework, l’exécution des middlewares et contrôleurs.

Avec Go, un serveur HTTP tourne en continu, ce qui signifie qu’il se charge une fois en mémoire et reste prêt à traiter les requêtes immédiatement.

En termes de performances, un serveur basique en PHP peut gérer en ordre de grandeur quelques centaines de requêtes par seconde. En Go, un serveur peut gérer plusieurs milliers de requêtes par seconde sans aucun problème.

Une concurrence native et efficace

PHP est principalement mono threadé, ce qui signifie qu’il exécute les requêtes les unes après les autres (il existe des extensions pour faire du multi threading mais pas nativement supporté par PHP).

Go introduit les goroutines, qui sont des threads dits “légers” permettant d’exécuter des tâches en parallèle de manière très efficace.

Des tâches gourmandes en ressources comme du traitement d’images, du scrapping, des appels API simultanés deviennent beaucoup plus simple en Go.

Voici un exemple en PHP et Go pour illustrer cela :

PHP exécutant les tâches les unes après les autres, le script suivant prendra 6 secondes à s’exécuter. On dit que le code est bloquant. 


function longTask($id) {
    sleep(2); // Simule une tâche longue
    echo "Tâche $id terminée\n";
}

longTask(1);
longTask(2);
longTask(3);

En Go les goroutines vont rendre le code non bloquant et le script va exécuter les appels de la fonction longTask en parallèle. Le code prend 2 secondes à s’exécuter. 


package main

import (
"fmt"
"time"
)

func longTask(id int) {
   time.Sleep(2 * time.Second)
   fmt.Println("Tâche", id, "terminée")
}

func main() {
   go longTask(1)
   go longTask(2)
   go longTask(3)
   time.Sleep(3 * time.Second) // Attendre que toutes les goroutines finissent
}

Déploiement et scalabilité plus simples

En PHP, pour déployer une application il faut installer PHP et ses extensions, les dépendances avec Composer.

Go compile toute l’application dans un seul binaire sans dépendances externes. Ce binaire peut être exécuté sur n’importe quel serveur.

Meilleure gestion des erreurs

PHP repose sur des exceptions pour signaler les erreurs. Toutefois, une fatal error peut arrêter tout le programme si elle n’est pas correctement gérée.

Pour gérer les erreurs proprement, il faut utiliser des blocs try/catch : 


function divide($a, $b) {
    if ($b == 0) {
        throw new Exception("Division par zéro");
    }
    return $a / $b;
}

try {
    echo divide(10, 0);
} catch (Exception $e) {
    echo "Erreur : " . $e->getMessage();
}

Go ne gère pas les erreurs avec des exceptions, mais avec des valeurs de retour de type error. Le langage Go permet à une fonction de renvoyer plusieurs résultats (par exemple un int et un type error). Ceci oblige les développeurs à gérer les erreurs dès qu’elles apparaissent. 


package main

import (
	"errors"
	"fmt"
)

func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("division par zéro")
	}
	return a / b, nil
}

func main() {
	result, err := divide(10, 0)
	if err != nil {
		fmt.Println("Erreur:", err)
	} else {
		fmt.Println("Résultat:", result)
	}
}

Conclusion

PHP est un très bon langage pour des applications web traditionnelles et dispose d’un écosystème mature avec des frameworks puissants comme Laravel ou Symfony. Cependant, Go apporte plusieurs avantages et permet d’explorer des usages nouveaux ou plus poussés qui viennent compléter les outils d’un développeur PHP.