Comment Golang implémente les scripts dans le développement

Golang est un langage de programmation qui a beaucoup attiré l'attention ces dernières années. Sa vitesse de compilation rapide, sa bonne simultanéité et sa facilité de développement et de maintenance ont été largement utilisées dans de nombreux scénarios d'application pratiques. Bien entendu, Golang prend également en charge les caractéristiques des langages de script. Cet article présente principalement comment Golang implémente les fonctions de script dans le développement.

La caractéristique du langage de script est qu'il est interprété et exécuté au moment de l'exécution plutôt que compilé à l'avance en code exécutable. Cela signifie que le langage de script peut générer dynamiquement une logique et présente une flexibilité et une évolutivité plus élevées. Pour les logiciels d'application nécessitant des fonctions d'itération rapides et une dynamique élevée, en particulier les applications Web, le langage de script peut être écrit de manière plus efficace.
Golang prend en charge la compilation en fichiers exécutables depuis ses débuts, mais depuis la version 1.5, Golang a officiellement amélioré la prise en charge de Golang pour les langages de script à un niveau supérieur et a implémenté la commande « go run », qui prend en charge la commande pour exécuter les fichiers source. . En effet, le code Golang ne peut pas être exécuté directement sur l'ordinateur. Go Run compile d'abord le code, puis exécute le code immédiatement, afin que le fichier source Golang puisse être exécuté directement.

Cependant, Golang n'est pas réellement un langage de script natif. Il ne prend pas en charge eval et d'autres fonctions liées à la dynamique, alors comment implémenter les fonctions de script dans Golang ? Ce qui suit sera divisé en deux aspects et introduit séparément.

1. Programmation mixte utilisant Shell + Golang

Un moyen simple d'implémenter des scripts dans Golang consiste à mélanger la programmation Shell et Golang. Cette méthode peut effectuer des tâches de script en appelant des commandes shell dans Golang. Vous pouvez utiliser le package os/exec, qui fournit une API de haut niveau pour appeler des commandes système. Grâce au package os/exec, nous pouvons exécuter des commandes shell, transmettre des paramètres et utiliser ces informations dans des scripts.

Ce qui suit est un exemple de code :

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    out, err := exec.Command("echo", "hello", "world").Output()
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("%s", out)
}

Le code ci-dessus transmet les deux paramètres hello et world en exécutant la commande echo, et le résultat de sortie est "hello world". Lorsque vous appelez des commandes externes, vous devez faire attention aux points suivants :

1. exec.Command() nécessite qu'au moins deux paramètres soient transmis. Le premier paramètre est le nom de la commande et le deuxième paramètre est le paramètre de la commande.
2. Après l'exécution de la commande, deux valeurs sont renvoyées, la première est la sortie lors de l'exécution et la seconde correspond aux erreurs survenues lors de l'exécution.

En mélangeant le shell et Golang, nous pouvons obtenir une méthode d'exécution de script plus flexible dans Golang tout en conservant la maintenabilité et l'évolutivité de Golang.

2. Utilisez le mécanisme de plug-in de Golang

En plus d'utiliser la méthode de mélange de shell, Golang fournit également un mécanisme de plug-in. À l'aide du mécanisme de plug-in, nous pouvons regrouper le code dans une bibliothèque dynamique qui peut être chargée et exécutée, et chargée lorsque le programme est en cours d'exécution. L’avantage de cette approche est la possibilité de charger et décharger dynamiquement du code, ce qui se traduit par une plus grande flexibilité et évolutivité.

Ce qui suit est un exemple de code :

package main

import (
    "plugin"
    "github.com/qfg040304/goplugin/hello"
)

func main() {
    p, err := plugin.Open("plugin.so")
    if err != nil {
        panic(err)
    }
    i, err := p.Lookup("Hello")
    if err != nil {
        panic(err)
    }
    f := i.(func())
    f()
    hello.World()
}

Dans le code ci-dessus, nous utilisons d'abord le package du plugin pour ouvrir la bibliothèque dynamique nommée "plugin.so", puis utilisons la fonction Lookup pour obtenir le symbole nommé "Bonjour". Ici, symbol est ce que nous avons défini précédemment. Ce sera la fonction à exporter dans la bibliothèque dynamique, et le mécanisme du plug-in la liera à la bibliothèque. Après avoir exécuté la fonction, nous appelons le package externe "hello" et y exécutons la fonction "World()".

Le mécanisme du plug-in fournit à Golang un moyen très flexible de charger et décharger dynamiquement du code selon les besoins pendant l'exécution du programme. Puisqu’elle prend en charge toutes les fonctionnalités de Go, cette méthode est également très sûre et fiable.

Résumé

Bien que Golang lui-même ne soit pas un langage de script natif, en mélangeant la programmation shell et Golang et en utilisant le mécanisme de plug-in de Golang, nous pouvons implémenter des fonctions de script dans Golang. Grâce à des méthodes de programmation flexibles et à de puissantes fonctionnalités du langage Go, nous pouvons utiliser Golang dans un plus large éventail de scénarios d'application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!