Quelle version du langage Go prend en charge XP

La version "1.10" du langage Go prend en charge le système XP. Golang1.10 est la dernière version prenant en charge Windows XP/2003, donc si vous souhaitez que les programmes compilés par Golang s'exécutent sur WinXP/2003, vous devez télécharger golang1.10 ; les versions ultérieures nécessitent au moins le système d'exploitation Win7/2008.

L'environnement d'exploitation de ce tutoriel : système linux7.3, GO version 1.18, ordinateur Dell G3.

Version développée du langage Go

Le développement des programmes en langage Go repose principalement sur le compilateur golang. Les compilateurs sont divisés en GC (Go Compiler) et GCCGo. Actuellement, la version officielle de Golang téléchargeable est la version GC, tandis que GCCGo est maintenu par l'organisation GCC.

golang1.10 est la dernière version prenant en charge Windows XP/2003, donc si vous souhaitez que les programmes compilés par Golang s'exécutent sur Winxp/2003, vous devez télécharger golang1.10. Les versions ultérieures nécessitent au moins le système d'exploitation Win7/2008.

Pour les systèmes d'exploitation Linux, la version minimale du noyau prise en charge par golang est 2.6.23. Pour Redhat, c'est au moins RHEL6.0 (2.6.32-71) ; pour CentOS, c'est au moins CentOS6.0 (2.6.32-71) pour Oracle Linux, c'est au moins OL5.6 (2.6 . 32-100.26.2.el5uek) ; pour Ubuntu, au moins 10.04 ; pour Suse Linux, au moins SLE11 (Suse Linux Enterprise 11). [Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation]

Pour Unix, FreeBSD peut utiliser GC, mais pour les systèmes d'exploitation dotés de processeurs non x86, vous devez utiliser le compilateur GCCGo.

Elements for Go Language Development

(1) Compilateur

Un outil de commande qui compile le code dans un fichier exécutable binaire. En fait, il devrait être appelé ici de manière plus appropriée « constructeur ». Car une fois le code écrit, entrez la commande "go build" pour directement "compiler" et "lier" le code dans un fichier exécutable.

Les définitions des termes « compilation » et « lien » proviennent du langage C

Le code du langage C est organisé par vocabulaire fixe selon un format fixe. Il est simple et intuitif, et facile à reconnaître et à comprendre pour les programmeurs. Cependant, pour le CPU, le code en langage C est que je ne connais pas du tout la Bible. Le CPU ne connaît que quelques centaines d'instructions sous forme binaire. Cela nécessite un outil pour convertir le code du langage C en instructions binaires que le processeur peut reconnaître. Cet outil est un logiciel spécial appelé compilateur.

Une fois le code du langage C compilé, il ne génère pas le fichier exécutable final (fichier .exe), mais génère un fichier intermédiaire (ou fichier temporaire) appelé fichier objet (Object File). Le fichier cible est également sous forme binaire, qui a le même format que le fichier exécutable. Pour Visual C++, le suffixe du fichier objet est .obj ; pour GCC, le suffixe du fichier objet est .o.

Le fichier cible peut devenir un fichier exécutable après avoir été lié. Puisque le format du fichier cible et du fichier exécutable sont les mêmes, pourquoi devons-nous le lier à nouveau ? Ne peut-il pas être utilisé directement comme fichier exécutable ?

Pas question ! Étant donné que la compilation transforme uniquement le code que nous écrivons sous forme binaire, il doit également être combiné avec des composants système (tels que des bibliothèques standard, des bibliothèques de liens dynamiques, etc.), qui sont tous nécessaires au fonctionnement du programme.

Link est en fait un processus de « packaging », qui combine tous les fichiers cibles et composants système sous forme binaire dans un fichier exécutable. La réalisation du processus de liaison nécessite également un logiciel spécial appelé éditeur de liens.

(2) Packages/composants d'extension

Dans le processus d'écriture du programme, si tous les « programmes de support » ou « classes d'outils » sont implémentés par les développeurs à partir de zéro, la charge de travail deviendra très importante. Par conséquent, pour améliorer l'efficacité du développement, vous essaierez dans la plupart des cas de trouver des « packages d'extension » ou des « composants » qui facilitent le développement du programme. Golang est livré avec son propre outil de gestion de packages, vous pouvez donc télécharger des packages d'extension via des commandes en fonction des besoins spécifiques pendant le développement.

(3) Écriture et débogage de code

Vous pouvez développer du code via n'importe quel éditeur de texte, puis compiler le programme via le compilateur GC. Bien sûr, vous pouvez également l'exécuter directement via la commande "go run". Si vous devez déboguer un programme, dans la plupart des cas, le moyen le plus sûr, le plus sécurisé et le plus fiable consiste à générer des journaux dans le programme. Si vous devez disposer d’un seul point de débogage, vous pouvez utiliser Delve.

Configuration de l'environnement

(1) Téléchargez et décompressez

cd usr/local
wget https://golang.google.cn/dl/go1.15.6.linux-amd64.tar.gz
tar xf go1.15.6.linux-amd64.tar.gz
cd go

(2) Créez une connexion douce

ln -s usr/local/go/bin/go usr/local/bin/go

(3) Exemple : Bonjour tout le monde

cd usr/local/src
mkdir -p go/helloworld
cd go/helloworld/
vim main.go

Entrez comme suit Code :

package main
import(
    "fmt"
)
func main(){
    fmt.Println("Hello world")
}

Enregistrez et quittez, puis exécutez la commande suivante

go run main.go

À ce moment, le système aura la sortie suivante :

Build

如果每次都通过go run去执行程序，则需要在发布程序时需要带上golang的运行时环境。这显然是不能满足要求的。可以将程序直接构建为可执行文件。

键入如下命令：

go build

此时，会在当前目录下产生一个helloworld的可执行文件

运行这个文件，会得到与go run 相同的结果。

./helloworld

使用扩展包

golang的扩展包有多种不同的管理方式。比如传统的 go get 方式以及新推出对的go module方式。

对于go get方式，由于某些特殊原因，部分官方包无法从golang.org下载，因此需要采取手动下载与go get相结合的方式。

对于go module方式，由于可以采用goproxy代理的方式获取golang.org的基础包，因此完美解决了国内golang开发的难题。

然而go module只有1.13版本之后的golang才能支持。而1.13是不支持winxp/2003的。并且对于go get与go module而言，有关代码在引包的时候，写法多少有些不同。因此如果要开发兼容低版本操作系统的程序，仍然建议采用go get进行包管理。

这里只介绍通过go module管理包的方式

以读取mongodb数据为例，介绍如何使用go module引入mongodb客户端扩展包，并读取数据。

设置goproxy代理

go env -w GOPROXY=https://goproxy.cn,direct

创建项目目录，并初始化

mkdir -p go/mongodemo
cd go/mongodemo/
go mod init mongodemo

此时，会在mongodemo目录下生成go.mod文件

然后编辑main.go，输入如下代码：

package main
import (
        "fmt"
    "log"
        "gopkg.in/mgo.v2"
        "gopkg.in/mgo.v2/bson"
)
type cfg_host struct {
        Host string
        Cfg_data string
}
func main() {
    user := "用户名"
    password := "密码"
    port := "端口"
    ip := "localhost"
    url := fmt.Sprintf("mongodb://%s:%s@%s:%s",user,password,ip,port)
        session, err := mgo.Dial(url)
        if err != nil {
                panic(err)
        }
        defer session.Close()
        Optional. Switch the session to a monotonic behavior.
        session.SetMode(mgo.Monotonic, true)
        c := session.DB("db").C("cfg_hosts")
        var cfgs []cfg_host
        err = c.Find(bson.M{}).All(&cfgs)
        if err != nil {
                log.Fatal(err)
        }
        for _,item := range cfgs {
            fmt.Printf("%s\n",item.Host)
            fmt.Printf("%s\n",item.Cfg_data)
        }
}

构建

go build

此时，go module会自动下载依赖包

同时，生成了名为“mongodemo”的可执行文件

执行该文件，输出了mongodb中的查询结果

更多编程相关知识，请访问：编程视频！！

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!