Comment créer votre première application Mac avec Go

Présentation

Le développement de Mac App s'appuie traditionnellement sur des langages de programmation comme Swift et Objective-C. Cependant, l'efficacité et la flexibilité de Go en font un excellent choix pour créer des applications Mac robustes mais simples. Dans ce didacticiel, nous vous guiderons étape par étape tout au long du processus de création, de test et de déploiement de votre première application Mac à l'aide de Go, en commençant par la configuration de votre environnement de développement.

Pourquoi utiliser Go pour le développement d'applications Mac ?

Go, également connu sous le nom de Golang, est un langage compilé à typage statique conçu par Google. Il a gagné en popularité en raison de sa simplicité, de ses performances et de sa gestion efficace de la concurrence. Voici pourquoi vous pourriez envisager d'utiliser le développement d'applications Go pour Mac :

Simplicité : la syntaxe de Go est simple et facile à apprendre, ce qui en fait un excellent choix pour les développeurs de tous niveaux.

Performances : étant un langage compilé, Go est rapide et efficace, ce qui est crucial pour créer des applications de bureau réactives.

Capacités multiplateformes : bien que ce guide se concentre sur macOS, la nature multiplateforme de Go signifie que vous pouvez facilement adapter votre application à d'autres systèmes d'exploitation.

Concurrency : Go intègre une prise en charge de la programmation simultanée, vous permettant de créer des applications capables de gérer plusieurs tâches simultanément sans ralentir.

Prérequis

Avant de plonger dans le code, assurez-vous que les outils suivants sont installés :

Go : installez la dernière version à partir du site officiel de Go.

Outils de ligne de commande Xcode : installez-les en exécutant xcode-select --install dans le terminal.

Gio : Gio est une bibliothèque permettant d'écrire des interfaces utilisateur graphiques portables dans Go. Il simplifie le processus de création d'interfaces graphiques et est parfait pour le développement d'applications Mac. Vous pouvez installer Gio en utilisant go get -u gioui.org/cmd/gogio.

Étape 1 : Configuration de votre environnement Go

Tout d'abord, vous devez configurer correctement votre environnement Go :

Installer Go : téléchargez et installez Go depuis le site officiel. Suivez les instructions d'installation correspondant à votre système d'exploitation.

Configurez votre espace de travail : Go utilise un espace de travail pour organiser vos projets. Par défaut, l'espace de travail est situé dans ~/go, mais vous pouvez modifier cela en définissant la variable d'environnement GOPATH.

   mkdir -p ~/go/src/github.com/yourusername
   export GOPATH=~/go

Installer Gio : Gio est une boîte à outils permettant de créer des applications natives pour Android, Linux et macOS. Installez Gio en exécutant :

   go get -u gioui.org/cmd/gogio

Étape 2 : Création d'une application Mac de base

Créons une simple application Mac "Hello World" à l'aide de Gio.

Initialisez votre projet : créez un nouveau répertoire pour votre projet et accédez-y.

   mkdir HelloWorldMacApp
   cd HelloWorldMacApp

Créez le fichier Main Go : créez un fichier nommé main.go et ouvrez-le dans votre éditeur de texte préféré.

   touch main.go

Écrivez le code : commencez par écrire un programme Go de base qui initialise une fenêtre et affiche "Hello World".

  package main

   import (
       "gioui.org/app"
       "gioui.org/io/system"
       "gioui.org/layout"
       "gioui.org/op"
       "gioui.org/widget/material"
       "gioui.org/font/gofont"
   )

   func main() {
       go func() {
           // Create a new window.
           w := app.NewWindow()
           th := material.NewTheme(gofont.Collection())

           for e := range w.Events() {
               switch e := e.(type) {
               case system.FrameEvent:
                   gtx := layout.NewContext(&op.Ops{}, e)
                   layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
                       return material.H1(th, "Hello, World!").Layout(gtx)
                   })
                   e.Frame(gtx.Ops)
               case system.DestroyEvent:
                   return
               }
           }
       }()
       app.Main()
   }

Créez et exécutez votre application : pour créer et exécuter votre application, utilisez la commande suivante :

   go run main.go

Cela devrait ouvrir une nouvelle fenêtre affichant « Hello, World ! ».

Étape 3 : Améliorer votre application avec un bouton

Maintenant que nous avons une application de base en cours d'exécution, améliorons-la en ajoutant un bouton qui affiche un message lorsque vous cliquez dessus.

Modifier main.go : mettez à jour votre fichier main.go pour inclure un bouton.

   package main

   import (
       "gioui.org/app"
       "gioui.org/io/system"
       "gioui.org/layout"
       "gioui.org/op"
       "gioui.org/widget"
       "gioui.org/widget/material"
       "gioui.org/font/gofont"
   )

   func main() {
       go func() {
           // Create a new window.
           w := app.NewWindow()
           th := material.NewTheme(gofont.Collection())

           var button widget.Clickable

           for e := range w.Events() {
               switch e := e.(type) {
               case system.FrameEvent:
                   gtx := layout.NewContext(&op.Ops{}, e)
                   layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
                       return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
                           layout.Rigid(material.H1(th, "Hello, World!").Layout),
                           layout.Rigid(material.Button(th, &button, "Click Me").Layout),
                       )
                   })

                   if button.Clicked() {
                       println("Button clicked!")
                   }

                   e.Frame(gtx.Ops)
               case system.DestroyEvent:
                   return
               }
           }
       }()
       app.Main()
   }

Créez et exécutez votre application améliorée : exécutez à nouveau l'application avec go run main.go. Cette fois, vous devriez voir un bouton « Cliquez sur moi » sous le bouton « Hello, World ! » texte. En cliquant sur le bouton, vous imprimerez « Bouton cliqué ! » à la console.

Étape 4 : Ajouter plus de fonctionnalités

Ajoutons plus de fonctionnalités à notre application, telles que la saisie de texte et un menu déroulant.

Ajout d'une saisie de texte : modifiez votre main.go pour inclure un champ de saisie de texte.

package main

   import (
       "gioui.org/app"
       "gioui.org/io/system"
       "gioui.org/layout"
       "gioui.org/op"
       "gioui.org/widget"
       "gioui.org/widget/material"
       "gioui.org/font/gofont"
   )

   func main() {
       go func() {
           // Create a new window.
           w := app.NewWindow()
           th := material.NewTheme(gofont.Collection())

           var button widget.Clickable
           var textField widget.Editor

           for e := range w.Events() {
               switch e := e.(type) {
               case system.FrameEvent:
                   gtx := layout.NewContext(&op.Ops{}, e)
                   layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
                       return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
                           layout.Rigid(material.H1(th, "Hello, World!").Layout),
                           layout.Rigid(material.Editor(th, &textField, "Enter text...").Layout),
                           layout.Rigid(material.Button(th, &button, "Click Me").Layout),
                       )
                   })

                   if button.Clicked() {
                       println("Button clicked with text:", textField.Text())
                   }

                   e.Frame(gtx.Ops)
               case system.DestroyEvent:
                   return
               }
           }
       }()
       app.Main()
   }

Ajout d'un menu déroulant : ajoutez un menu déroulant à votre application.

 package main

   import (
       "gioui.org/app"
       "gioui.org/io/system"
       "gioui.org/layout"
       "gioui.org/op"
       "gioui.org/widget"
       "gioui.org/widget/material"
       "gioui.org/font/gofont"
   )

   func main() {
       go func() {
           // Create a new window.
           w := app.NewWindow()
           th := material.NewTheme(gofont.Collection())

           var button widget.Clickable
           var textField widget.Editor
           var list widget.List

           list.Axis = layout.Vertical

           items := []string{"Item 1", "Item 2", "Item 3"}

           for e := range w.Events() {
               switch e := e.(type) {
               case system.FrameEvent:
                   gtx := layout.NewContext(&op.Ops{}, e)
                   layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {
                       return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
                           layout.Rigid(material.H1(th, "Hello, World!").Layout),
                           layout.Rigid(material.Editor(th, &textField, "Enter text...").Layout),
                           layout.Rigid(material.Button(th, &button, "Click Me").Layout),
                           layout.Rigid(material.List(th, &list).Layout(gtx, len(items), func(gtx layout.Context, index int) layout.Dimensions {
                               return material.Button(th, new(widget.Clickable), items[index]).Layout(gtx)
                           })),
                       )
                   })

                   if button.Clicked() {
                       println("Button clicked with text:", textField.Text())
                   }

                   e.Frame(gtx.Ops)

 case system.DestroyEvent:
                   return
               }
           }
       }()
       app.Main()
   }

Exécutez votre application : exécutez à nouveau votre application avec go, run main.go et découvrez les nouvelles fonctionnalités en action.

Étape 5 : Créer une application Mac autonome

Une fois votre application prête, vous souhaiterez la créer en tant qu'application autonome. Suivez ces étapes :

Créez votre application : utilisez gogio pour créer votre application pour macOS.

   gogio -target darwin .

Cette commande générera un bundle .app que vous pourrez exécuter directement sur macOS.

Testez votre application : ouvrez le bundle .app généré pour tester votre application. Assurez-vous que toutes les fonctionnalités fonctionnent comme prévu.

Étape 6 : Emballage et distribution

Pour distribuer votre application, vous souhaiterez peut-être la signer et la légaliser pour macOS.

Signez votre application : la signature de code est requise pour distribuer votre application en dehors du Mac App Store. Utilisez l'outil de conception de code pour signer votre application.

codesign --deep --force --verify --verbose --sign "Application d'ID de développeur : votre nom" HelloWorldMacApp.app

Notarisez votre application : pour vous assurer que macOS permet à votre application de s'exécuter sans avertissement, notarisez-la à l'aide de xcrun altool.

xcrun altool --notarize-app --primary-bundle-id "com.votrenom.helloworldmacapp" --username "yourappleid@example.com" --password "mot de passe spécifique à l'application" --file HelloWorldMacApp.zip

Distribuez votre application : une fois notariée, vous pouvez distribuer votre application via votre site Web, par courrier électronique ou par d'autres moyens.

Conclusion

Félicitations ! Vous avez créé avec succès votre première application Mac à l'aide de Go. Ce guide couvre les bases de la configuration de votre environnement de développement, de la création d'une application simple, de l'ajout de fonctionnalités et de la distribution de votre application. Grâce à la simplicité et aux performances de Go, vous êtes parfaitement équipé pour développer des applications Mac puissantes et efficaces. Continuez à explorer Gio et Go pour améliorer vos compétences et créer des applications plus complexes.

Références

Allez au langage de programmation

Boîte à outils Gio pour Go

Outils de ligne de commande Xcode

Documentation pour les développeurs Apple

Cet article de blog fournit un guide complet pour créer votre première application Mac à l'aide de Go, avec de nombreux exemples de code pour vous aider à comprendre chaque étape. En suivant ce guide, vous pouvez rapidement démarrer avec le développement d'applications Mac et explorer les puissantes capacités de Go et Gio.

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!