So erstellen Sie Ihre erste Mac-App mit Go

Einführung

Die Entwicklung von Mac-Apps stützt sich traditionell auf Programmiersprachen wie Swift und Objective-C. Die Effizienz und Flexibilität von Go machen es jedoch zu einer hervorragenden Wahl für die Erstellung robuster und dennoch einfacher Mac-Anwendungen. In diesem Tutorial führen wir Sie Schritt für Schritt durch den Prozess des Erstellens, Testens und Bereitstellens Ihrer ersten Mac-App mit Go, beginnend mit der Einrichtung Ihrer Entwicklungsumgebung.

Warum Go für die Mac-App-Entwicklung verwenden?

Go, auch bekannt als Golang, ist eine statisch typisierte, kompilierte Sprache, die von Google entwickelt wurde. Aufgrund seiner Einfachheit, Leistung und effizienten Parallelitätsverarbeitung hat es an Popularität gewonnen. Aus folgenden Gründen könnten Sie die Verwendung von Go für die App-Entwicklung für Mac in Betracht ziehen:

Einfachheit: Die Syntax von Go ist unkompliziert und leicht zu erlernen, was es zu einer großartigen Wahl für Entwickler aller Erfahrungsstufen macht.

Leistung: Als kompilierte Sprache ist Go schnell und effizient, was für die Erstellung reaktionsfähiger Desktop-Anwendungen von entscheidender Bedeutung ist.

Plattformübergreifende Funktionen: Während sich dieser Leitfaden auf macOS konzentriert, bedeutet die plattformübergreifende Natur von Go, dass Sie Ihre App problemlos an andere Betriebssysteme anpassen können.

Parallelität: Go verfügt über integrierte Unterstützung für gleichzeitige Programmierung, sodass Sie Apps erstellen können, die mehrere Aufgaben gleichzeitig erledigen können, ohne langsamer zu werden.

Voraussetzungen

Bevor Sie in den Code eintauchen, stellen Sie sicher, dass die folgenden Tools installiert sind:

Go: Installieren Sie die neueste Version von der offiziellen Go-Website.

Xcode-Befehlszeilentools: Installieren Sie diese, indem Sie xcode-select --install im Terminal ausführen.

Gio: Gio ist eine Bibliothek zum Schreiben tragbarer grafischer Benutzeroberflächen in Go. Es vereinfacht den Prozess der Erstellung von GUIs und eignet sich perfekt für die Entwicklung von Mac-Apps. Sie können Gio mit go get -u gioui.org/cmd/gogio.

Schritt 1: Einrichten Ihrer Go-Umgebung

Zuerst müssen Sie Ihre Go-Umgebung richtig konfigurieren:

Go installieren: Laden Sie Go von der offiziellen Website herunter und installieren Sie es. Befolgen Sie die Installationsanweisungen für Ihr Betriebssystem.

Richten Sie Ihren Arbeitsbereich ein: Go verwendet einen Arbeitsbereich, um Ihre Projekte zu organisieren. Standardmäßig befindet sich der Arbeitsbereich in ~/go, Sie können dies jedoch ändern, indem Sie die Umgebungsvariable GOPATH festlegen.

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

Gio installieren: Gio ist ein Toolkit zum Erstellen nativer Anwendungen für Android, Linux und macOS. Installieren Sie Gio, indem Sie Folgendes ausführen:

   go get -u gioui.org/cmd/gogio

Schritt 2: Erstellen einer einfachen Mac-App

Lassen Sie uns mit Gio eine einfache „Hello World“-Mac-App erstellen.

Initialisieren Sie Ihr Projekt: Erstellen Sie ein neues Verzeichnis für Ihr Projekt und navigieren Sie dorthin.

   mkdir HelloWorldMacApp
   cd HelloWorldMacApp

Erstellen Sie die Haupt-Go-Datei: Erstellen Sie eine Datei mit dem Namen main.go und öffnen Sie sie in Ihrem bevorzugten Texteditor.

   touch main.go

Schreiben Sie den Code: Schreiben Sie zunächst ein einfaches Go-Programm, das ein Fenster initialisiert und „Hello World“ anzeigt.

  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()
   }

Erstellen und ausführen Sie Ihre App: Um Ihre App zu erstellen und auszuführen, verwenden Sie den folgenden Befehl:

   go run main.go

Dies sollte ein neues Fenster mit der Anzeige „Hello, World!“ öffnen.

Schritt 3: Erweitern Sie Ihre App mit einer Schaltfläche

Da wir nun eine einfache App ausgeführt haben, erweitern wir sie, indem wir eine Schaltfläche hinzufügen, die beim Klicken eine Meldung anzeigt.

main.go ändern: Aktualisieren Sie Ihre main.go-Datei, um eine Schaltfläche hinzuzufügen.

   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()
   }

Erstellen Sie Ihre erweiterte App und führen Sie sie aus: Führen Sie die App erneut mit go run main.go aus. Dieses Mal sollten Sie unter „Hello, World!“ die Schaltfläche „Click Me“ sehen. Text. Wenn Sie auf die Schaltfläche klicken, wird „Schaltfläche angeklickt!“ gedruckt. zur Konsole.

Schritt 4: Weitere Funktionen hinzufügen

Fügen wir unserer App weitere Funktionen hinzu, z. B. Texteingabe und ein Dropdown-Menü.

Texteingabe hinzufügen: Ändern Sie Ihr main.go so, dass es ein Texteingabefeld enthält.

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()
   }

Hinzufügen eines Dropdown-Menüs: Fügen Sie Ihrer App ein Dropdown-Menü hinzu.

 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()
   }

Führen Sie Ihre App aus: Führen Sie Ihre App erneut mit go run main.go aus und sehen Sie sich die neuen Funktionen in Aktion an.

Schritt 5: Erstellen einer eigenständigen Mac-App

Sobald Ihre App fertig ist, möchten Sie sie als eigenständige Anwendung erstellen. Befolgen Sie diese Schritte:

Erstellen Sie Ihre App: Verwenden Sie gogio, um Ihre App für macOS zu erstellen.

   gogio -target darwin .

Dieser Befehl generiert ein .app-Bundle, das Sie direkt auf macOS ausführen können.

Testen Sie Ihre App: Öffnen Sie das generierte .app-Bundle, um Ihre Anwendung zu testen. Stellen Sie sicher, dass alle Funktionen wie erwartet funktionieren.

Schritt 6: Verpackung und Vertrieb

Um Ihre App zu verbreiten, möchten Sie sie möglicherweise für macOS signieren und notariell beglaubigen.

Signieren Sie Ihre App: Für die Verbreitung Ihrer App außerhalb des Mac App Store ist eine Codesignatur erforderlich. Verwenden Sie das Codesign-Tool, um Ihre App zu signieren.

codesign --deep --force --verify --verbose --sign „Entwickler-ID-Anwendung: Ihr Name“ HelloWorldMacApp.app

Beglaubigen Sie Ihre App: Um sicherzustellen, dass macOS die Ausführung Ihrer App ohne Vorwarnung zulässt, beglaubigen Sie sie mit xcrun altool.

xcrun altool --notarize-app --primary-bundle-id "com.yourname.helloworldmacapp" --username "yourappleid@example.com" --password "app-spezifisches-password" --file HelloWorldMacApp.zip

Verteilen Sie Ihre App: Nach der notariellen Beglaubigung können Sie Ihre App über Ihre Website, E-Mail oder auf andere Weise verbreiten.

Fazit

Herzlichen Glückwunsch! Sie haben Ihre erste Mac-App erfolgreich mit Go erstellt. In diesem Leitfaden wurden die Grundlagen zum Einrichten Ihrer Entwicklungsumgebung, zum Erstellen einer einfachen App, zum Hinzufügen von Funktionen und zum Verteilen Ihrer Anwendung behandelt. Mit der Einfachheit und Leistung von Go sind Sie bestens gerüstet, um leistungsstarke und effiziente Mac-Apps zu entwickeln. Entdecken Sie Gio and Go weiter, um Ihre Fähigkeiten zu verbessern und komplexere Anwendungen zu erstellen.

Referenzen

Gehe zur Programmiersprache

Gio Toolkit für Go

Xcode-Befehlszeilentools

Apple-Entwicklerdokumentation

Dieser Blogbeitrag bietet eine umfassende Anleitung zum Erstellen Ihrer ersten Mac-App mit Go, mit zahlreichen Codebeispielen, die Ihnen helfen, jeden Schritt zu verstehen. Wenn Sie dieser Anleitung folgen, können Sie schnell mit der Entwicklung von Mac-Apps beginnen und die leistungsstarken Funktionen von Go und Gio erkunden.

Das obige ist der detaillierte Inhalt vonSo erstellen Sie Ihre erste Mac-App mit Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!