Transkripte
1. EINFÜHRUNG: Hallo und willkommen. In dieser 14-tägigen
Anfänger-Herausforderung beginnen
Sie Ihre
Reise mit einem Knall. Sie erfahren,
wie Apps erstellt werden und wie sie
im App Store landen. Sie werden sich mit Xcode
vertraut machen und damit Ihr
eigenes App-Projekt starten. Sie werden
lernen, wie Sie
Benutzeroberflächen mit der Swift-Benutzeroberfläche erstellen . Und Sie werden die Grundlagen der
Swift-Programmierung erlernen , damit Sie
einfachen Swift-Code lesen und schreiben können. Jetzt, in den nächsten 14 Lektionen, wirst
du all
diese neuen Fähigkeiten erwerben. Und du wirst
deine eigene App erstellt haben , die
du auf
deinem Gerät installieren kannst und all deinen Freunden und
deiner
Familie zeigen kannst, was du getan hast. Noch
wichtiger ist jedoch, dass Sie äußerst zuversichtlich
und aufgeregt sein werden, Ihre Fähigkeiten zur
App-Entwicklung weiter über das
hinaus zu
erweitern , was wir hier behandelt haben. Dies könnte wirklich der Anfang
von etwas Neuem für dich sein. Okay, also wenn du
bereit bist, lass uns die Ärmel hochkrempeln und loslegen.
2. 01: Das The: Ich gehe durch
dieses Diagramm und danach sage
ich dir, wo du alle Teile
bekommst, alles beginnt mit
der Xcode-IDE. Jetzt steht IDE für Integrated
Development Environment, was ein Begriff für
die Anwendung
und alle Tools ist , mit denen ein Entwickler
etwas baut. Für den Rest dieses Kurses nennen
wir es einfach Xcode. Hier erstellen wir unsere
App, indem wir Swift-Code schreiben, kurz die
Benutzeroberfläche oder Benutzeroberfläche
erstellen und sie
mit all unseren Daten verbinden. Swift ist die
Programmiersprache, die wir verwenden, um
unsere Logik auszudrücken und dem
System mitzuteilen, was wir tun wollen. Wir können die
Benutzeroberfläche sogar durch Swift-Code erstellen, wie Sie bald sehen werden. Jetzt ist Swift UI ein
UI-Framework, das es uns
leicht macht , schnell
Apps für alle
Apples-Plattformen zu erstellen . Ein netter Vorteil
beim Erlernen von Xcode, schnelle und schnelle Benutzeroberfläche ist, dass es sich um dieselben Fähigkeiten und
Tools
handelt, die zum Erstellen
aller Apps für alle Plattformen von
Apple verwendet werden , einschließlich iOS, iPadOS, tvOS, watchOS, und Mac OS. Und in einigen Fällen kann
Ihre App ohne
große Änderungen auf
mehreren Plattformen arbeiten . Sobald Ihre App erstellt wurde,
können Sie sie jetzt mit Apples App Store verteilen. Dies geschieht durch den Beitritt zum
Apple Developer Program, das eine
jährliche Anmeldegebühr erforderlich ist. Sobald Sie registriert sind, erhalten Sie Zugriff auf mehrere Vorteile, darunter das App
Store-Connect-Portal, den
Testflug und das
Bereitstellungsportal. Es gibt einige weitere Vorteile,
einschließlich des Zugriffs auf Beta-Software und der Support
von Apple-Ingenieuren. Und ich gebe einen Link
zur vollständigen Liste unten. Das Provisioning-Portal
bietet Ihnen Zugriff auf
Tools zur Identifizierung und
Codesignatur Ihrer App. Es ist, als würde man Ihre
Signatur in die App einfügen
, damit Apple
erkennen kann, wer sie erstellt hat. Und dies ist wichtig
für die Sicherheit der Endbenutzer, die Ihre App
herunterladen. Und es ist auch wichtig
für Sie, weil es
bösartige Programmierer davon abhält , so zu
tun, als wären Sie. Sobald sich Ihre App in
einem testbaren Zustand befindet, können
Sie mit
Testflug Personen
zum Herunterladen und
Beta-Test Ihrer App einladen . können Sie
Feedback und Fehlerberichte
direkt an Sie senden Über
das Testflugprogramm können Sie
Feedback und Fehlerberichte
direkt an Sie senden. Verwenden Sie den Testflug, um
sicherzustellen, dass Ihre App vor dem Start
so poliert wie möglich ist . Und schließlich erstellen
Sie im App Store
Connect das
Atlas-Ding für Ihre App, einschließlich aller
Metadaten und Screenshots. Wenn Ihre App In-App-Käufe
hat
, würden Sie sie auch hier konfigurieren. Sobald Ihre App getestet wurde
und das Inserat fertig ist, können
Sie die
App von Xcode
aus in den App Store connect hochladen .
Das Zertifizierungsteam von
Apple überprüft Ihre App, um sicherzustellen, dass sie die App erfüllt
Qualitätsrichtlinien für das Geschäft. Dies dauert ein paar Tage und sich keine
Sorgen, wenn Sie
scheitern, denn Sie können alles reparieren, was sie darauf
hinweisen , und es erneut zur Überprüfung einreichen. Wenn alles gut aussieht, genehmigen
sie die App
und Ihre App wird live sein. Herzlichen Glückwunsch. In Ordnung, also wo bekommst du diese verschiedenen Teile des
Apple Developer Ecosystems? Sie können Xcode
kostenlos aus dem Mac App Store herunterladen. Ich gebe unten einen Link an. Sie müssen keine
Swift- oder Swift-Benutzeroberfläche erhalten. Die kommen einfach mit Xcode. Was das Apple
Developer Program betrifft, gebe
ich einen Link zur
Registrierungsseite unten an. Ich möchte erwähnen, dass
der Beitritt zum Apple Developer
Program völlig
optional ist , wenn Ihr Ziel nicht darin besteht, Apps in den
App Store zu verteilen, sondern nicht daran teilzunehmen. Sie
können weiterhin lernen, wie
Sie Apps für sich selbst erstellen können. Das ist also das Apple
Developer Ecosystem. Es ist der Prozess, den ich Sie
durchführe wenn Sie
mit dieser App-Reise fortfahren. Am Ende
dieses Lernpfades erstellen
Sie Ihre eigenen Apps
mit all diesen Tools, erstellen
Sie Ihre eigenen Apps die wir abgedeckt haben, auch wenn Sie derzeit keine
Programmiererfahrung haben, verspreche
ich Ihnen, dass Sie es
sein werden , was Sie
bis zum Ende dieser Herausforderung tun können. In der nächsten Lektion tauchen wir
direkt in Xcode ein. Alles klar, wir sehen uns dort.
3. 02: Xcode: Hallo und willkommen. In diesem Xcode-Tutorial werden
Sie
sich mit
der Entwicklungsumgebung vertraut machen , in der
Sie Apps erstellen werden. Ich zeige Ihnen, wo
Sie Xcode herunterladen und wie Sie ein
neues App-Projekt starten können. Und dann gehen wir
durch die wichtigsten Bereiche von Xcode und dann, was jede
der Dateien in Ihrem
App-Projekt vier ist. Und schließlich
schließen wir die Lektion mit einigen schnellen Tipps ab, wie Sie in Xcode
navigieren können. Okay, mit dem
gesagt, lasst uns eintauchen. Sprechen wir zunächst
darüber, wo wir Xcode bekommen können. Es ist kostenlos, also
musst du nicht dafür bezahlen. Starten Sie einfach den Mac App Store auf Ihrem Computer und suchen
Sie dann nach Xcode. Sie gelangen in den Suchergebnissen zu einer
solchen Seite . Klicken Sie hinein und
Sie können es kostenlos
herunterladen. Also habe ich es schon
heruntergeladen. Deshalb
heißt es „Update“ hier. Ich möchte, dass du die Warnung hier einfach
ignorierst. Es ist eigentlich eine sehr große App mit vielen
verschiedenen Funktionen. Es ist verständlich, dass
es ein paar Bugs gibt. Und wenn man sich die Bewertungen anschaut, beschweren
sich Leute über andere Dinge, die nichts mit der App zu
tun haben. Sie beschweren sich
darüber, wie Apple ihr Geschäft
führt
und so weiter und so weiter. Und einige davon
sind sehr, sehr alt. Okay, ich möchte, dass du diese wichtigen
Informationen zur
Kenntnis nimmst . Klicken Sie darauf
, um sicherzustellen, welche Voraussetzungen für
die Installation von Xcode sind
. Überprüfen Sie auch noch einmal, ob Sie genügend freien
Festplattenspeicher haben. meiner Erfahrung benötigt
es im Laufe der Zeit tatsächlich mehr
Festplattenspeicher. Was steht dann hier. Wenn Sie also etwas
wie 12 Gigs kostenlos haben, können Sie dies möglicherweise nicht installieren da es während des
Installationsvorgangs tatsächlich mehr Speicherplatz beansprucht und
dann denke ich, dass es
eine Reihe von Dateien loswird und
es hört bei dieser Größe auf. Wenn Sie jedoch im Laufe der Zeit
zusätzliche Entwicklerkomponenten
und zusätzliche iOS-Simulatoren herunterladen zusätzliche Entwicklerkomponenten , kann
dies tatsächlich noch höher
werden. Stellen Sie also sicher, dass Sie über
ausreichenden Festplattenspeicher verfügen. In Ordnung, wenn
Sie also aus irgendeinem Grund keinen
Zugriff auf den Mac App Store erhalten, können
Sie auch
die offizielle Xcode-Seite auf
der Apple-Entwicklerseite besuchen . Die URL ist also Entwickler
dot apple.com slash Xcode. Und Sie können hier sofort
auf den Link Ressourcen klicken . Und dann wirst du
zu einer Seite weitergeleitet, auf der du Xcode hier
herunterladen kannst Xcode hier
herunterladen dich
nur durch
den Mac App Store führt. Eigentlich können Sie auch
Beta-Versionen von Xcode herunterladen. Jetzt würde ich das nicht
empfehlen, weil es
oft ziemlich fehlerhaft
ist. Es Beta-Software. Daher würde ich empfehlen,
bei den offiziellen Veröffentlichungen zu bleiben. Wenn Sie aus irgendeinem Grund eine ältere
Version von Xcode
herunterladen möchten , können
Sie hier nach unten scrollen
und hier auf
diesen Link klicken. Jetzt nur noch eine Notiz,
um
Beta-Versionen der Apple-Software herunterzuladen , müssen
Sie für
ihr Apple Developer Program registriert sein, über
das wir
in der vorherigen Lektion gesprochen haben. Um ältere
Versionen von Xcode herunterzuladen, denke
ich nicht, dass Sie für dieses Programm
registriert sein müssen. Ich glaube, du brauchst nur
eine kostenlose Apple-ID. Und schließlich, wenn Sie auf einem
PC sind, betreiben Sie Windows. Prüfen Sie die Ressourcen
zu Beginn
des Kurses nach Optionen für Sie. Okay, nutzen Sie jetzt
die Gelegenheit, Xcode
herunterzuladen und zu installieren,
wenn Sie es noch nicht getan haben, und starten Sie es dann
zum ersten Mal. Während Ihres ersten Starts werden Sie nach
Ihrem Administratorkennwort gefragt , um zusätzliche
Entwicklungskomponenten zu installieren. Du wirst das machen wollen. Also mach weiter und gib
dein Admin-Passwort ein. Nachdem du das getan hast, lass uns mit dem
Rest des Videos
fortfahren. In Ordnung, lasst uns jetzt darüber
sprechen, wie man
ein brandneues Xcode-Projekt startet . Dies sollte der
erste Begrüßungsbildschirm , den
Sie beim Starten von Xcode sehen. Wenn Sie
dies nicht sehen, machen Sie sich keine Sorgen, Sie können jederzeit zu Datei
Neu gehen und Projekt auswählen. Andernfalls können
Sie von diesem
Begrüßungsbildschirm aus
auf Neues Xcode-Projekt erstellen
klicken . Von hier aus wählen Sie eine Vorlage für Ihr neues Projekt aus. Sie konfigurieren die Projekteigenschaften dafür und
wählen dann einen Speicherort aus. Beginnen wir also mit
der Auswahl einer Vorlage. Die grundlegendste für unsere
Zwecke ist unter iOS und App. Also mach weiter und wähle
das aus und klicke auf Weiter. Und dann konfigurieren Sie
hier
die Eigenschaften für Ihr Projekt. Wenn Sie also kein
Team hier haben, machen Sie sich keine Sorgen. Später kannst du hier
dein Apple-Konto hinzufügen und dann
das Team für das Projekt konfigurieren. Eine Sache, die Sie jedoch sicherstellen
möchten,
ist, Ihre
Organisationskennung hier festzulegen. Wenn Sie ein Unternehmen
oder eine Website haben, können
Sie den umgekehrten
Domain-Stil hier verwenden, com dot, was auch immer das sein mag. Und du kannst
hier sogar deinen
Vor- und Nachnamen verwenden , wenn du willst. Und dann gibst du
hier den Namen für deine App oder den Produktnamen ein. Wenn ich es also auf die Probe stelle, werden
Sie feststellen, dass diese
Paketkennung
eine Kombination aus der
Organisationskennung
und dem Produktnamen ist eine Kombination aus der
Organisationskennung . Und dies bildet zusammen diese
eindeutige Paketkennung. Diese Paketkennung wird
an verschiedenen Stellen verwendet ,
um Ihre App zu identifizieren, z. B. im App Store oder
im Provisioning-Portal oder in App Store connect. Das ist also sehr wichtig. Keine Sorge, Sie können
die Paketkennung für
Ihr Projekt später ändern . Ich möchte Sie nur darauf
aufmerksam machen, wie es entstanden ist und
wofür es verwendet wird. Alles klar, als Nächstes. Auf Ihrer Schnittstelle stellen
Sie
sicher, dass Sie die
Swift-Benutzeroberfläche ausgewählt haben. Und für den Lebenszyklus stellen
Sie
sicher, dass Sie die
Swift-UI-App ausgewählt haben. Und dann schließlich für Sprache, wählen Sie schnell und lassen Sie sie
für diese Optionen einfach alle deaktiviert oder wenn sie aktiviert sind, deaktivieren Sie sie
einfach. Jetzt eine kurze Notiz zu diesen
Dropdowns genau hier. Im Laufe der Zeit, als sich die App-Entwicklung
für iOS weiterentwickelt hat, gab es einige Programmiersprachen und auch einige Möglichkeiten, Benutzeroberflächen zu
erstellen. Die neueste und beste
ist die schnelle Benutzeroberfläche und schnell. Das
wollen wir also benutzen. Lass uns weitermachen und auf Weiter klicken. Wenn Sie mit all Ihren
Auswahlen zufrieden sind, wählen Sie einen
Ort, an dem Sie sie speichern können. Ich
speichere es einfach auf meinem Desktop ,
damit es leicht zu finden ist. Da ich
ihr Projekt bereits dort
habe, wollte ich es einfach ersetzen. Alles klar, Willkommen bei Ihrem
brandneuen Xcode-Projekt. Jetzt mag es mit
all den verschiedenen
Panels und Bereichen
überwältigend erscheinen , aber es ist eigentlich nicht so komplex wenn man weiß, wie es zerlegt
wird Es gibt tatsächlich nur
vier Hauptbereiche von Xcode. Fangen wir von
ganz links an. Hier haben wir das Navigator-Panel oder den Navigatorbereich in, wie Sie hier sehen können, haben
wir eine Dateiliste
aller verschiedenen Dateien
in unserem App-Projekt. Der Navigatorbereich hat tatsächlich verschiedene Registerkarten, um auch
durch verschiedene
Dinge zu navigieren , die wir in
zukünftigen Lektionen vorerst erreichen werden, ist auf den ersten Tab eingestellt und wir haben eine Auflistung
unserer Akten. Wenn Sie auf eine Datei klicken, ändert
sich das, was
in diesem großen Hauptbereich angezeigt wird, und dies wird als Editorbereich bezeichnet
. Es ermöglicht uns, die von
uns ausgewählten Dateien im
Datei-Navigator zu
bearbeiten .
Sie können sehen, dass sie sich
an den ausgewählten
Dateityp anpassen . Wählen Sie eine Punkt-Swift-Datei aus, sind Codedateien. Wenn ich diese XC-Assets-Datei wähle, ist
dies eine Bildbibliothek, also zeigt sie mir so
etwas. Der Editorbereich ist ein Ort, um die Datei zu bearbeiten
, die ich hier auswähle. Der letzte Tab befindet
sich also ganz rechts und dies wird als
Inspektorbereich bezeichnet. Und es zeigt mir entweder zusätzliche zusätzliche
Informationen was ich für den Editorbereich ausgewählt habe, oder es ermöglicht mir, das Ding, das ich
im
Editorbereich ausgewählt habe, zu konfigurieren
oder zu bearbeiten , je nachdem an welcher Art von Redakteur
ich gerade arbeite. Dies ist zum Beispiel
ein Code-Editor, weil ich mir eine Punkt-Swift-Datei
anschaue. Wenn ich den Mauszeiger über das Schlüsselwort hier fahre oder das Schlüsselwort
auswähle, ,
wenn ich auf dieser Registerkarte „Schnellhilfe“ bin zeigt
es mir,
wenn ich auf dieser Registerkarte „Schnellhilfe“ bin, einige
schnelle Informationen darüber, wofür dieser
Code oder dieses Schlüsselwort bestimmt ist. Das Inspektor-Panel
hat hier oben auch ein paar
verschiedene Registerkarten. Zum Beispiel
ist dies eine Identitätsregisterkarte. Es zeigt mir Informationen über diese Datei, die ich ausgewählt
habe wo sie sich befindet und welche App sie in einer enthält, wenn wir
unsere Benutzeroberfläche erstellen würden. Wenn ich nun eines
dieser Elemente auswählen und zu dieser Registerkarte
wechseln würde, kann ich
es konfigurieren. Zusammenfassend
ist das
Inspektor-Panel hier kontextabhängig mit dem, was Sie im Editorbereich
auswählen. Und der
Editorbereich ist kontextabhängig was Sie
im Navigatorbereich auswählen. Es stammt also alles von dem, was Sie zuerst hier auf der
linken Seite
auswählen. Und dann oben haben
wir die Symbolleiste hier. Lassen Sie mich
Ihnen erklären, was das ist. Ganz links und ganz
rechts befindet sich eine Schaltfläche , um den
Navigator und Inspektor ein- und auszublenden. Diese sind praktisch, wenn Sie nicht viele
Bildschirm-Immobilien haben. Das nächste, worauf ich Sie
aufmerksam machen
möchte , ist hier in der Mitte. Dies ist die Statusleiste. Es sagt dir, was
gerade passiert. Was macht Xcode? Hast du irgendwelche Fehler? Hast du irgendwelche Warnungen und so weiter und so fort. Links davon haben
Sie ein Dropdown-Menü, um einen Simulator auszuwählen. Und dieser iOS-Simulator
ist im Grunde ein virtuelles Gerät,
das auf dem Bildschirm angezeigt wird , auf dem Sie Ihre App
ausführen und testen können. Sie benötigen eigentlich kein
physisches Gerät. Wenn Sie eines haben, wie sehr
neu ist, schließen Sie es an und Sie möchten
Ihr Xcode-Projekt auf
Ihrem tatsächlichen Gerät ausführen , Sie feststellen, dass es von hier aus ausgewählt
werden kann,
sobald Sie es anschließen. Und
links neben diesem Menü sehen
Sie hier ein paar Schaltflächen, um Ihr Projekt
auszuführen. Wenn Sie diese Schaltfläche drücken,
wird
Ihr Projekt tatsächlich in diesem Simulator ausgeführt . die Stopp-Taste drücken, wird Ihr Projekt
nicht mehr
im Simulator ausgeführt. Und dann
gibt es auf
der rechten Seite auch zwei weitere Knöpfe. Dies ist die Schaltfläche für die Bibliothek,
in der Sie verschiedene Elemente der
Benutzeroberfläche
finden, verschiedene Möglichkeiten, diese Elemente zu
ändern. Codeausschnitte in den Assets, die
Sie dem Projekt hinzugefügt haben, den Farben, die Sie für Ihr
Projekt
angegeben haben usw. Dieses kleine Bibliotheks-Panel
ist nützlich, um eine Suche durchzuführen. Und um schnell Dinge im Editorbereich auszuwählen und hinzuzufügen. Darauf werden wir in
der nächsten Lektion kommen. Aber im Moment ist das
der Bibliotheksbereich. Dies werden Sie wahrscheinlich am Anfang nicht
zu viel verbrauchen. Dies ist eine Schaltfläche zur Revision
oder Codeüberprüfung , die Ihnen zeigt, ob Sie die Quellcodeverwaltung
verwenden, wie Ihre Dateien im Laufe der Zeit
geändert wurden. Dies sind also die
vier Hauptbereiche der Xcode-Benutzeroberfläche. Alles klar, jetzt gehen wir die Dateien in Ihrem neuen Projekt durch. Fangen wir von ganz oben an. Dies ist der Stammknoten oder Ihre Projektdatei. Wenn Sie diese Option ausgewählt haben, wechselt der
Editorbereich in diesen Konfigurationsbildschirm
, damit Sie einige
der Details bearbeiten können, die sich auf Ihr Projekt
beziehen. Hier ist zum Beispiel die Bundle-ID
, die veränderbar ist. Sie können die
Geräteausrichtung konfigurieren, auf welchen Geräten und auf welchen Plattformen ausgeführt werden können,
Dinge wie diese. Wenn wir ein Level absteigen, können
Sie sehen, dass es hier zwei Ordner
gibt. Dieser enthält alle Ihre Codedateien
und Projektdateien. Dieses Produkt
enthält die Ausgabe. Wenn Sie Ihre
App erstellen und kompilieren, wird
sie in diese App umgewandelt, die letztendlich das
kleine bereitstellbare Bundle
oder Paket ist , das wir
in den App Store senden. Man muss hier nicht wirklich
viel damit machen, aber dort wird es gespeichert. Alles klar, schauen wir uns diese Akte an. Dies wird nach
Ihrem Produktnamen,
App Dot Swift, benannt . Und Sie können hier
mit diesem Haupttag hier sehen, dies der
Einstiegspunkt zu Ihrer App ist. An dieser Stelle gibt es hier nicht
zu viel zu konfigurieren. Alles, was es wirklich tut, ist
die erste Ansicht zu erstellen ,
die der Benutzer sieht, nämlich die Inhaltsansicht. Und Sie können sehen, dass dieser Name Content-View-Punkt Swift
zugeordnet ist. Werfen wir einen Blick auf das. Diese Datei repräsentiert die
Ansicht, die der Benutzer sieht. Jetzt können Sie
zusätzliche Ansichten erstellen, aber standardmäßig erhalten Sie diese
Inhaltsansicht zunächst. Und ja, hier ist alles Code. Das bedeutet also, dass
die Benutzeroberfläche durch Code generiert
wird. Es gibt aber auch eine visuelle Möglichkeit,
die Benutzeroberfläche anzupassen, die Sie in
der nächsten Lektion sehen werden. Lasst uns mit
unseren anderen Akten fortfahren. Dieser ist, wie ich bereits erwähnt habe, unsere Asset-Bibliothek. Hier können wir
die Farben für unsere App
sowie die App-Symbole
sowie alle anderen
Bilder speichern sowie die App-Symbole sowie alle anderen , die wir unserem Projekt
hinzufügen möchten. Wir ziehen es einfach und
lassen es hier rein. Und das ist unser Image-Asset. Nun, nicht nur Bilder,
sondern Asset Library. Und dann haben wir eine
info.plist und das sind einige zusätzliche
Konfigurationsinformationen für das Projekt. Hier haben wir Vorschauinhalte, und dies ist eine weitere
Asset-Bibliothek, jedoch nur für
Vorproduktionsressourcen bestimmt ist. Also nur Bilder und Text
und Farben und solche Dinge mit
denen
Sie testen,
wie der Namensvorschau vermuten lässt, wenn es sich
um einen Vermögenswert handelt, der es letztendlich
zu der App schafft , die Sie die
App Store, dann kannst du es stattdessen hier in die
Asset-Bibliothek legen. Das ist also eine kurze
Erklärung aller Dateien in Ihrem
Projekt auf
den Punkt gebracht. In den zukünftigen Lektionen werden
wir tiefer in
jeden einzelnen
eintauchen und Sie werden sehen, wie jede
dieser Dateien
eine Rolle bei der
Konstruktion Ihrer App spielt. Das letzte, was ich in dieser Lektion tun
möchte ist, Ihnen ein
paar schnelle Tipps
zum Navigieren
in Xcode zu geben , um Ihre Dateien zu
durchsuchen und auch in Bezug auf das Bearbeiten
von Code. Lassen Sie uns zunächst über das
Navigieren in Dateien sprechen . Diese
beiden Pfeile werden Sie hier bemerken. Diese sind wirklich praktisch
, weil Sie damit zur letzten Datei
gehen können , die
Sie sich angesehen haben. Und obwohl es jetzt
etwas trivial erscheint, wenn Sie
um Bearbeitung und Dateien springen, wird
dies wirklich praktisch. Anstatt diese Datei
im Navigator
erneut auswählen zu müssen , können
Sie einfach zurückschlagen und zu dieser vorherigen Datei zurückkehren. Sie werden auch feststellen, dass Sie hier mehrere Registerkarten haben
können. Sie können also die
Kontrolle gedrückt halten und auf eine Datei
klicken und Sie können jederzeit auf neuem Tab öffnen wählen. Sie können auch in einem
neuen Fenster öffnen, wenn Sie möchten. Da ich das
schon als Tab habe, wird es keinen zweiten Tab für mich
öffnen. Wenn Sie
Dinge nebeneinander haben möchten, können
Sie das auch tun. Nehmen wir an, ich wollte mir diese
beiden Dateien nebeneinander ansehen . Also kann ich das schließen. Und dann kann ich
weitermachen und ich kann auf der rechten Seite einen weiteren Editorbereich
hinzufügen, damit ich meinen
Editorbereich in zwei Editorbereiche aufteilen kann. Sie können sehen, dass ich mir
hier die
Inhaltsansicht anschaue , die
schnell in der Suche ist. Schauen wir uns die Test-App an. Es sind also unabhängige Bereiche. Ich möchte vielleicht meine Leinwand
loswerden. Und dann sehe ich
beide PFOS so. Wenn Sie es vorziehen, dass sie
horizontal gestapelt werden, können
Sie Option gedrückt halten. Und Sie können sehen,
dass sich dieses Symbol ändert. Richtig, wenn Sie
diese Schaltfläche erneut drücken, wird rechts ein weiterer
Editorbereich hinzugefügt. Also wirst du dich in drei
teilen. Oder Sie können
Option gedrückt halten und stattdessen einen
Editor unten hinzufügen. Also machst du das. Sie können das auch hier tun, Option
gedrückt halten und das tun. Jetzt eine schnelle Möglichkeit,
eine Datei in eine geteilte Editor-Ansicht zu starten . Nehmen wir an, ich schaue mir die
Test-App an und möchte die
Inhaltsansicht als
separaten Editorbereich öffnen . Ich kann Option gedrückt halten und auf die Datei
klicken, die ich in einer
separaten Editoransicht öffnen
möchte. Dies sind also einige Möglichkeiten
, wie Sie
mit Ihren Dateien arbeiten können. Um es zu wiederholen, können Sie navigieren. Du kannst zurückgehen und vorwärts gehen. Sie können verschiedene Registerkarten haben. Und dann können Sie auch Ihren Editorbereich
in mehrere Instanzen
des Editors
aufteilen . Jetzt möchte ich
über das Bearbeiten von Code sprechen , weil dies eine Menge von dem ist,
was Sie tun werden. Und der Code sieht gerade
ziemlich kurz aus, kann
aber länger werden. Es ist also praktisch, ein paar Möglichkeiten
zu kennen, damit umzugehen. Oben hier sehen
Sie
diese Art von Breadcrumb-Menü. Und Sie werden feststellen, dass das der Wurzelknoten dem
entspricht, oder? Dies ist ein Ordner oder eine
Gruppe, kann das sehen. Und dann ist dies
die Inhaltsansicht, die die Datei ist, die
Sie sich ansehen, die sich hier in Tests befindet. Und hier können wir tatsächlich
darauf klicken und Sie können zu
verschiedenen Abschnitten Ihres Codes springen. Sie können sehen, dass die
Inhaltsansicht damit übereinstimmt. Der Körper passt dazu, oder? Dies ist also eine großartige
Möglichkeit, zu
verschiedenen Abschnitten
in Ihrer Codedatei
zu springen verschiedenen Abschnitten
in Ihrer Codedatei falls Ihre Codedatei ziemlich lang
wird. Sie können hier auch verschiedene
Kommentare hinzufügen , die dem entsprechen,
was Sie hier oben sehen. So können Sie
hier sehen, ich habe
meine eigene Dokumentation erstellt und sie fügt sie hier hinzu. Dies ist also eine großartige Möglichkeit
, Ihre Datei zu organisieren. Wir werden in Zukunft noch einmal
darüber sprechen. Also mach dir keine Sorgen, wenn das etwas zu schnell
geht. Alles klar, jetzt reden wir hier
über diesen kleinen Knopf. Du hast gesehen, dass ich das benutzt habe,
um den Canvas zu öffnen, aber du kannst
diese Minikarte auch hier öffnen. Und diese Minikarte zeigt
Ihnen einen Überblick über
Ihre Codedatei. Sie können dies ziehen, um
Ihren Code zu durchblättern. Leider kann ich es hier nicht sehr viel
machen weil diese
Codedatei nicht sehr lang ist. Aber wenn Sie eine
wirklich lange Codedatei hätten, würde
sie Ihnen den Umriss
dieser Codedatei hier unten zeigen . Und Sie können ganz
einfach navigieren , indem Sie darauf klicken
und ziehen. Sie werden feststellen, dass
selbst wenn ich hervorgehoben habe, es mir die
verschiedenen Teile
meines Codes zeigen wird , die
dem entsprechen, was wir hier haben. Auch hier waren das nur
ein paar schnelle Feuertipps. Sie sich keine Sorgen, wenn das
zu schnell vorbeigeflogen ist, denn wir werden all diese Dinge in den
kommenden Lektionen
gemeinsam
nutzen . Das ist also ein kurzes Tutorial
, mit dem Sie loslegen können. Nicht so kompliziert, wenn Sie
wissen, wo die Dinge richtig sind, nur um zusammenzufassen,
haben Sie herausgefunden, wo Xcode
herunterladen und wie Sie ein neues App-Projekt
starten können. Sie erfahren, wofür jede der
Dateien in Ihrem Projekt gedacht ist. Und Sie lernen die Hauptbereiche von Xcode kennen, einschließlich des Navigators, des Editors, des
Inspektors und der Symbolleiste. Schließlich
erfahren Sie auch einige kurze
Tipps , wie Sie mit diesem Xcode
navigieren können. sich keine Sorgen,
wenn es gerade ein
bisschen überwältigend ist.
Sie werden sich bei
Xcode wie zu Hause fühlen, Sie werden sich bei
Xcode wie zu Hause fühlen da wir es in den kommenden Lektionen öfter
zusammen verwenden in den kommenden Lektionen öfter
zusammen um Ihnen zu helfen, sich einzuleben Ich habe tatsächlich einen
Xcode-Spickzettel erstellt , den Sie
ausdrucken und an Ihrer Seite behalten können ,
während Sie die Verwendung von Xcode lernen.
Ich empfehle dringend, dass Sie versuchen,
Ihr eigenes Xcode-Projekt zu erstellen Ihr eigener Computer nur
für zusätzliche Übung. In der nächsten Lektion werden wir
Xcode verwenden , um unsere
erste Benutzeroberfläche zu erstellen. Alles klar, wir sehen uns dort.
4. 03: So gestaltest du Benutzeroberflächen: Hallo und willkommen. In dieser Lektion lernen Sie
, wie Sie
Xcode verwenden können, um Benutzeroberflächen mit der Swift-Benutzeroberfläche zu erstellen. Wir werden zuerst lernen,
wie Sie eine Vorschau der App anzeigen können, damit Sie tatsächlich sehen können, wie die
Benutzeroberfläche aussieht. Sie zeigen Ihnen nicht, wie
Sie Xcode verwenden, um kurz die
Benutzeroberfläche oder Benutzeroberfläche visuell zu konstruieren. Bis jetzt war
das Lernen
ziemlich passiv,
was bedeutet, dass Sie sich einfach
zurücklehnen und die Videos ansehen können. Aber ab jetzt
werden wir zu einem
aktiveren Lernen wechseln. Ich möchte, dass Sie tun, was ich tue, es in Ihrem
eigenen Xcode-Projekt
replizieren. Und ich möchte, dass Sie
eine der Herausforderungen versuchen, die Sie haben, dies ist der beste Weg zu lernen. Und ehrlich gesagt, wenn
Sie sich einfach
zurücklehnen und den Unterricht ansehen
und keine Arbeit machen. Du machst nicht das
Beste aus deiner Zeit. Das war meine
persönliche Erfahrung und ich denke, es wird
für dich genauso sein. Wenn du also bereit bist, werden
wir uns die Hände schmutzig machen. Lass es uns machen. Beginnen wir damit, ein
brandneues Xcode-Projekt zu erstellen. Wir werden uns für die iOS-App entscheiden. Und ich nenne
diesen einen UI-Test. Stellen Sie einfach sicher, dass Schnittstellen Swift UI Lifecycle eine schnelle
UI-App und die Sprache schnell ist. Ansonsten kannst du es so
nennen, was du willst. Lasst uns weitermachen und unser Projekt
speichern. Und wie ich in
der vorherigen Lektion erwähnt habe, repräsentiert der
Content-View-Punkt Swift Ihre Ansicht. Aber wie Sie sehen können, ist
es alles Code. Wie siehst du eigentlich
, wie deine Benutzeroberfläche aussieht? Nun, es gibt zwei
verschiedene Möglichkeiten. Die erste Möglichkeit besteht
darin, Ihre App
in einem iOS-Simulator zu starten ,
wie ich bereits erwähnt habe. Also lasst uns
das zuerst machen. Wähle eine aus, die dir gefällt. Also
wähle ich das iPhone 11 aus. Und ich drücke diesen
Build and Run-Button. Jetzt ist es das erste Mal dass
Sie
den iOS-Simulator starten. Es wird eine
Weile dauern, bis ich hochgefahren bin, genauso wie es wäre,
ein echtes Gerät für mich hochzufahren ein echtes Gerät für mich weil ich
den Simulator schon einmal gestartet habe. Es passiert sehr,
sehr schnell. Wie Sie sehen können, hat
Ihr Projekt standardmäßig ein
Hello World-Label. werden wir in einer Sekunde
sprechen. Aber lassen Sie mich Ihnen
zuerst zeigen, wie Sie eine
Vorschau Ihrer App anzeigen können. Lasst uns also weitermachen und unser Projekt
beenden. Und das wird verhindern, dass die App im Simulator läuft. Die zweite Möglichkeit besteht darin, eine Vorschau Ihrer App in dieser
Leinwand genau hier anzuzeigen. Das ist Teil des Editorberberbereichs. Wenn Sie dies nicht sehen, können
Sie hier auf diese
kleine Schaltfläche klicken und sicherstellen, dass neben Canvas ein
Häkchen vorhanden ist. Und wenn Sie sich eine Punkt-Swift-Datei ansehen
,
bei der es sich um eine Ansicht handelt, können
Sie diesen Canvas sehen. Andernfalls können Sie sehen
, dass es keine Vorschau
gibt, wenn Sie sich diese Einstiegspunktdatei hier ansehen. Gehen wir also zurück
zur Inhaltsansicht. Stellen Sie sicher, dass wir unsere Vorschau
hier haben und klicken Sie auf Fortsetzen. Es wird es bauen und ausführen. Und dann
siehst du die Vorschau hier. Schon wieder. Wenn dies das erste
Mal ist, dass Sie es tun, kann
es eine Weile dauern. Verwenden wir die
Zoom-Steuerelemente hier unten und zoomen Sie ein wenig heraus, damit
wir das Ganze sehen können. Jetzt gibt es hier
ein paar Dinge, die ich erwähnen
möchte. Dies ist einfach eine Vorschau, während Sie
diese App beim Starten im Simulator tatsächlich auf
einem virtuellen Gerät
installieren , damit Sie
damit interagieren und testen können. Hier ist dies eine Vorschau, mit der
Sie nicht interagieren können, aber es gibt eine Möglichkeit, die Sie können. Wenn Sie also hier auf diese
Schaltfläche klicken, Live-Vorschau, wechselt
sie in einen Modus, in
dem es genau wie der Simulator ist
, den Sie zuvor gesehen haben. Aber es ist in dieser Vorschau-Leinwand. So kannst du weitermachen
und auf „Stop“ drücken. Und dann
wird es wieder eine normale Vorschau. Das dient nur zu
Vorschauzwecken. Eine weitere coole Sache bei der Verwendung dieser Vorschau-Leinwand ist, dass
Sie hier auf diese Schaltfläche klicken und
ein anderes Gerät auswählen können. Sie können ein Layout auswählen, Dunkelmodus oder den Lichtmodus wählen
und eine Reihe
verschiedener Dinge auswählen. Dies ist der bevorzugte
Weg, um eine Vorschau Ihrer Benutzeroberfläche denn wenn Sie
Ihre Benutzeroberfläche durch
Code auf dieser Seite erstellen , können
Sie hier sehen, dass sich die
Dinge auf der rechten Seite ändern ohne dass um
die App im Simulator neu zu starten. Alles klar, jetzt lassen Sie uns
eintauchen und darüber sprechen, wie wir die Benutzeroberfläche tatsächlich
aufbauen werden. Stellen Sie also sicher, dass Sie den
Inhaltsansichtspunkt schnell hervorgehoben
haben , und blenden Sie
den Datei-Navigator aus. Jetzt gibt es
hier eine Reihe von Code, der die Ansicht ausmacht. Aber wir werden es später eingehend
durchgehen wenn Sie vorerst einige der Grundlagen der
Swift-Programmierung lernen , um Verwirrung zu vermeiden,
wollte ich Sie nur auf eine Sache
aufmerksam machen was ist
dieser Code genau hier. Was ich auf
dem Bildschirm hervorgehoben habe, ist, was dieses Label hier
generiert
, das Sie in der Vorschau sehen. Beachten Sie, dass wir
ein Textschlüsselwort haben. Wir haben das Halloworld
Textstück , das Sie hier sehen können. Und wir haben auch dieses
Polsterelement hier, das die Polsterung
um das Wort gibt. Werfen wir einen Blick auf diesen Code und brechen ihn auf. Ich werde es
einfach löschen. Wie Sie sehen können, wird
Xcode alle
möglichen
Beschwerden und Fehler auslösen. Aber keine Sorge, wir
werden es sofort reparieren. Jetzt müssen unsere
Elemente der Benutzeroberfläche zwischen dieser
öffnenden Klammer
und dieser schließenden Klammer liegen. Und Sie können nur ein
Benutzeroberflächenelement haben. Das macht offensichtlich keinen
Sinn, da unsere Benutzeroberflächen aus
mehr als einem Element bestehen. Aber hier kommen
Containerelemente ins Spiel. Und ich zeige dir auch ein paar
davon in dieser Lektion. Lassen Sie uns das Textelement
vorerst neu erstellen. Was wir also schreiben, ist das
Textschlüsselwort
gefolgt von einem Paar solcher Klammern
, abgerundeten Klammern. Und dann haben wir da drinnen
ein paar Anführungszeichen. Und dann legen wir den Text ein, den wir anzeigen möchten. Also hier werde ich einfach
Hallo setzen. Aber du wirst feststellen, dass
dieser blaue Rahmen
sehr eng gegen
meinen Hallo Text rappt . Wenn Sie
die Polsterung wieder hinzufügen
möchten, schreiben Sie Punkt. Und dann würden Sie einfach
Padding eingeben und die automatische Vervollständigung verwenden, Sie können einfach genau dort auswählen
. Und einfach so haben wir Label mit Polsterung
neu erstellt. Dies ist genau hier das
Textelement oder das Label. Dieser Teil mit der Punktpolsterung. Dies wird als Modifikator bezeichnet. Und Sie können sich einen
Modifikator als Anhang
zu einem Element vorstellen ,
das das Aussehen und Verhalten ändert. In diesem Fall fügt dieser
Auffüllmodifikator den Textelementen eine
Auffüllung hinzu
, so dass, wenn sich ein
Element direkt daneben befindet, etwas Platz
um unser Textelement herum
vorhanden ist. Und es gibt tatsächlich viele
weitere Modifikatoren, die wir unseren
Benutzeroberflächenelementen hinzufügen
können. Zum Beispiel kann ich
einen sogenannten Hintergrund hinzufügen, und ich füge ihn einfach
am Ende des Padding hinzu. Und ich werde sagen, dass der Hintergrund für
dieses Label blau sein sollte. Sie können also sehen, dass unsere
Vorschau-Leinwand sehr gut repräsentiert, was wir hier durch Code
schreiben. Wenn es irgendeine Zeit gibt, in der die
Dinge nicht synchron werden, vielleicht der Code, den Sie
hier schreiben sagt
vielleicht der Code, den Sie
hier schreiben, dass der
Hintergrund grün sein sollte, aber Sie sehen ihn hier nicht. Der Code
gilt als Quelle
der Wahrheit, da die Vorschau-Leinwand und
sogar
das, was Sie im
Inspektor-Panel sehen, letztendlich Vorschau-Leinwand und
sogar
das, was Sie im
Inspektor-Panel sehen nur visuelle Darstellungen
des Codes sind . Und das bringt mich
zu meinem nächsten Punkt
, nämlich wenn Sie die Benutzeroberfläche
erstellen, müssen
Sie keinen Code schreiben. Es gibt so viele visuelle
Möglichkeiten, den Code zu erstellen. Lassen Sie uns dieses
Textelement wieder löschen und lassen Sie mich Ihnen einige
der Möglichkeiten zeigen, wie Sie
die Benutzeroberfläche visuell erstellen
können. Ich habe vorher über das
Bibliothekspanel gesprochen. So können Sie hier sehen, dass
wir einfach auswählen, nach dem ausgewählten
Textelement suchen und es hier in unseren
Code-Editor ziehen können. Und dann können wir
den Platzhaltertext ändern, aber wir
müssen den Text hier nicht einmal ändern. Wenn Sie auf
dieses Textelement klicken und in das
Inspektor-Panel gehen, können
Sie es
hier so ändern. Und dann werden
Sie auch in diesem
Inspektor-Panel sehen, dass
es eine Reihe
von Modifikatoren gibt , die wir hinzufügen können. Also füge die Polsterung hinzu, ich könnte darauf klicken, um
nur Top-Padding hinzuzufügen. Und Sie können sehen, dass sich
der Code ändert. Und es gibt an, dass es
nur eine Polsterung oben gibt. Und Sie können sehen, dass es
sich hier widerspiegelt. Oder ich klicke hier
und schalte die Polsterung ein oder aus. Und du kannst jetzt sehen, dass ich auf allen Seiten
Polster habe. Zusätzlich zu einigen der Modifikatoren,
die Sie hier sehen, gibt es hier
unten ein
Textfeld, in dem Sie nach weiteren Modifikatoren
suchen können . Also kann ich nach dem
Hintergrund suchen und darauf klicken. Und dann wähle diesen
blauen Hintergrund aus, wie du hier sehen kannst. Und dann kann ich diese Polsterung auch
hinzufügen. Neben
der Verwendung der hier gezeigten Modifikatoren und der Verwendung dieses Textfelds „Modifikator
hinzufügen können
Sie die
Bibliothek auch zum Hinzufügen von Modifikatoren verwenden. dieser ersten Registerkarte finden Sie also alle
Elemente der Benutzeroberfläche, die
Sie Ihrer Ansicht hier auf
der zweiten Registerkarte oder auf den Modifikatoren hinzufügen können. Wie Sie sehen können, gibt es die Polsterung, es gibt den Hintergrund. Wie fügen Sie diese Modifikatoren
hinzu? Nun, du klickst einfach
und ziehst es. Aber hier müssen Sie
sicherstellen, dass Sie es an das Ende des Codes
ziehen. Denn wenn Sie es versehentlich in die
Mitte Ihres Codes
ziehen, dauert
es möglicherweise nicht, oder Sie erhalten so
etwas. Das ist eindeutig ein Fehler. Machen wir das also rückgängig. Als ob das nicht genug wäre, gibt es
noch ein paar Möglichkeiten, wie ich Ihnen zeigen
wollte , wie Sie Ihre
Benutzeroberflächenelemente
visuell
ändern können Ihre
Benutzeroberflächenelemente
visuell
ändern ,
anstatt Code zu schreiben. Lassen Sie uns zunächst die
Konfiguration dieses Hintergrunds abschließen und wir wählen genau dort
Blau
oder vielleicht grün aus. Okay, das ändert das nicht. Es ändert das also, aber es ändert sich hier nicht. Also wähle ich die Farbe aus, und wir werden
grün machen, Kleinbuchstaben g. Alles klar, damit du den Befehl auf
deiner Tastatur
gedrückt halten kannst und
dann auf
das Element der Benutzeroberfläche klicken kannst aus deiner Vorschau gleich hier. Und dann gibt es eine
Reihe von Dingen, die Sie mit diesem Element machen
können, einschließlich dieses, zeigen Sie
Swift UI Inspector. Und dann erhalten Sie
diesen Add Modifier, TextField, was Sie nach hinzuzufügenden Modifikatoren
suchen können. Also füge ich
einen mit dem Namen Blur hinzu. Sie können sehen, dass es die Farbe Grün
verwischen lässt. Und du siehst, dass mein
Hintergrund jetzt ein verschwommenes Grün ist. Jetzt können Sie dasselbe
auf den Seiten des Code-Editors tun. Sie können also den
Befehl gedrückt halten und auf
das Textelement klicken und
Sie erhalten dieses Menü. Sie können erneut auf Swift-UI-Inspektor
anzeigen klicken. Und von hier aus sieht man, dass dieses Menü hier wie
der Inspektor aussieht. Und wir können auch
Modifikatoren hinzufügen. Um meinen Standpunkt zu veranschaulichen, habe
ich Ihnen eine ganze Reihe
verschiedener Möglichkeiten gezeigt, wie Sie Ihre
Benutzeroberfläche visuell ändern können. Du musst den Code nicht
schreiben. Aber im Laufe der Zeit, während Sie
dies visuell tun, sehen
Sie den Code, der immer und immer wieder
generiert wird . Sie werden an einen Punkt kommen,
an dem es so vertraut ist, es
für Sie schneller sein wird, es einfach
auszutippen , anstatt überall zu
klicken. Es ist also eine wirklich ordentliche Möglichkeit, den Benutzeroberflächencode zu lernen. Ist das nicht ziemlich cool? Xcode hat in der Vergangenheit einen langen
Weg zurückgelegt. Früher war es sehr pingelig,
den visuellen
Interface-Builder mit Xcode zu verwenden , aber die Swift-Benutzeroberfläche hat die Dinge wirklich zum Besseren
verändert. In dieser Lektion lernen
Sie, wie Sie
das Textelement verwenden , und haben sein Aussehen und
Verhalten mithilfe von Modifikatoren geändert. Darüber hinaus erfahren
Sie auch, dass die Benutzeroberfläche tatsächlich aus Swift-Code
generiert wird. Es gibt jedoch eine
Vielzahl von Möglichkeiten in Xcode, Ihre Benutzeroberfläche visuell zu erstellen. Und während Sie
Ihre Benutzeroberfläche visuell über
den vorherigen Canvas oder
das Inspektor-Panel erstellen , wird
der Swift-Code im
Code-Editor
automatisch aktualisiert, Code-Editor
automatisch aktualisiert um diese Änderungen
widerzuspiegeln. Dies ist also eine großartige Möglichkeit
, den Swift-Code zu lernen. wir das nächste Mal zusammensitzen, stelle
ich Ihnen zusätzliche Ansichten und
Container vor, die Sie
verwenden können , damit Sie
kompliziertere
Benutzeroberflächen erstellen können . Alles klar, wir sehen uns dort.
5. 04: SwiftUI und Container: Hallo und willkommen. In dieser Lektion
lernen Sie, wie Sie eine Vielzahl
verschiedener
Elemente und Container der Benutzeroberfläche verwenden . Und am
Ende der Lektion zeige
ich Ihnen ein paar
Benutzeroberflächen, die Sie versuchen,
sich selbst als Praxis aufzubauen. Denken Sie daran, dass Sie viel
mehr aus diesem Kurs herausholen
werden ,
wenn Sie während
der gesamten Lektion angehalten haben und versucht haben, das
zu replizieren, was ich
mit Ihrem eigenen Xcode-Projekt gemacht habe. Alles klar genug zu reden.
Lasst uns zum lustigen Teil kommen. Okay, richtig, also hast du
etwas über das Textelement erfahren. Jetzt möchte ich dir
das Bildelement zeigen. Also werden wir
weitermachen und das löschen. Und warum suchen wir
die Bibliothek nicht, um nach dem Bildelement zu suchen. Also lasst uns das Bild ziehen
und dort ablegen. Jetzt ist das Problem, dass wir kein Bild anzeigen müssen. Aber bevor ich dir sage,
wie man das angibt, gerade bemerkt, dass es
irgendwie im gleichen Format wie
das Textelement ist, oder? Hier gibt es das image Schlüsselwort, und dann gibt es eine
Reihe von runden Klammern. Und in der Mitte werden
wir
unseren Image-Namen angeben. Dieser Image-Name ist nun dem grafischen
Asset zugeordnet , das wir in unsere Asset-Bibliothek
eingefügt haben. Wenn wir also unseren
Datei-Navigator öffnen und in unsere Asset-Bibliothek gehen, können
Sie sehen, dass alles leer ist. Wir haben hier nichts. Also lasst uns weitermachen und hier ein Bild
hineinlegen. Wenn Sie zu den
Unterrichtsressourcen gehen, wird eine
ZIP-Datei namens Logo Assets angezeigt. Und lasst uns weitermachen
und sie entpacken. Und dann wirst
du drinnen ein lokales Bild finden. Du wirst tatsächlich
drei Akten finden. Und sie werden auf die gleiche
Weise benannt , außer mit einem Apt zu
x und fügen dann drei x hinzu. Und das ist buchstäblich nur zwei Mal
so groß wie das erste. Und dieser ist dreimal
so groß wie der erste. Und der Grund, warum sie in
verschiedenen Größen erhältlich sind , ist, dass es iOS-Geräte
mit unterschiedlichen
Bildschirmauflösungen gibt . Durch Hinzufügen aller drei Größen wählt
die Plattform die richtige Größe aus, wählt
die Plattform die die für
die Bildschirmauflösung verwendet werden soll. Es wird auf angezeigt. Alles, was Sie
tun müssen, ist alle drei zu greifen und sie dann so in die
Asset-Bibliothek zu ziehen. Es wird klug
genug sein zu wissen, dass diese drei in
derselben Gruppe sind. Und es wird ihm einen Namen
geben. Sie können
dies immer umbenennen, damit Sie
darauf klicken und
es beliebig benennen können. Aber dieser Name hier ist
das, was Sie im
Bildelement
referenzieren werden . Machen Sie also weiter und setzen Sie
Anführungszeichen ein, diesen Bild-Asset-Namen, und Sie sollten
ihn hier sehen. Oh, eigentlich automatische Vorschau,
Aktualisierung, pausierte, geh
weiter und klicke auf Fortsetzen. Alles klar, da drin sehen
wir unser Bild. Jetzt
wird das Bild standardmäßig in
der Größe des grafischen
Assets angezeigt , das Sie importiert haben. Wenn Sie jedoch die Größe ändern
möchten,
skalieren Sie es nach oben oder unten, Sie können einen Modifikator hinzufügen, der
als resizable bezeichnet wird. Wenn du das triffst, kann es
sich dehnen. Wenn es sich dehnt, ob
Sie
das Seitenverhältnis beibehalten möchten , weil
Sie hier
sehen können ist alles ausgestreckt und es sieht nicht wie
das Originalbild aus. Sie können einen weiteren Modifikator
namens Seitenverhältnis hinzufügen. Und vergessen Sie nicht,
obwohl ich diese Modifikatoren hier
durch Code
eintippe, können
Sie sie immer
über dieses Menü hinzufügen. Du kannst es genau dort finden. Und dann können Sie mit dem
Seitenverhältnismodifikator verschiedene Möglichkeiten
auswählen
, wie dies skaliert werden soll. Wenn ich also „fit“ sage, wird
es so skaliert
, dass es innerhalb der Grenzen passt. Aber mit Beibehaltung des
Seitenverhältnis Und während wir
diese Modifikatoren hinzufügen, wäre
dies ein guter
Punkt, um zu erwähnen , dass es sinnvoll ist, bei
Ihren Modifikatoren die Eingabetaste
zu drücken hier bei
Ihren Modifikatoren die Eingabetaste
zu drücken
, damit sie ausgerichtet werden. Da einige Elemente
möglicherweise eine Liste von
Modifikatoren haben und
sie alle in eine neue Zeile setzen, werden
sie automatisch unter
die
Elemente der Benutzeroberfläche einrücken, auf werden
sie automatisch unter
die
Elemente der Benutzeroberfläche einrücken die sie sich
beziehen, und es wird
sehr einfach lesen. In Ordnung, jetzt wissen Sie über Textelemente und
Bildelemente Bescheid. Wie
kombinieren wir die beiden? Wie haben wir
mehr als ein Element
für unsere Benutzeroberfläche? Hier kommen
Containerelemente ins Spiel. Gehen wir also in unsere Bibliothek und
suchen wir nach v Stack. Dies ist der, auf den ich mich
beziehe, vertikaler Stapel. Und du kannst es hier
hineinklicken und ziehen. Jetzt werden Sie
ein paar Fehler bekommen , weil dies als Element
gilt. Es scheint, dass
Xcode nicht eingeholt hat, aber dies wäre keine gültige Benutzeroberfläche. Im Wesentlichen haben wir hier
zwei Elemente. Was wir
stattdessen tun wollen, ist,
dass wir unser Bild
aufnehmen wollen und
ich werde unser Bild
aufnehmen wollen und
ich werde ihn zwischen
diese öffnende Klammer und die
schließende Klammer
des vertikalen Stapels einfügen diese öffnende Klammer und die
schließende Klammer . Innerhalb des vertikalen Stapels können
Sie bis zu
10 Elemente platzieren und sie werden
vertikal übereinander stapeln. Also hier werde ich auch sagen. Textelement wie dieses. Und Sie können sehen, dass ich
jetzt
zwei Elemente haben kann und sie
automatisch übereinander gestapelt
werden . Neben dem
vertikalen Stapel gibt es auch einen horizontalen Stapel. Und anstelle des Stacks ist
das H-Stack. Und wenn Sie
das in einen H zurück ändern, werden
Sie sehen, dass es jetzt horizontal
nebeneinander
gestapelt ist. Und es gibt auch einen
namens Zed Stack, ich bin in Kanada oder z
Stack, wenn du es vorziehst. Und das stellt die Dinge
übereinander, wobei die Elemente oben am weitesten hinten sind. So können Sie sehen, dass
unser Textelement hallo oben auf dem Bild sitzt. Jetzt ist es cool, dass Sie diese verschiedenen
Containerelemente
verschachteln können . Also kann ich, sagen
wir mal, ich möchte, dass mein Bild, Logo der
Hintergrund sind, und oben möchte
ich
Elemente nebeneinander texten müssen. Dann kann ich hier
einen H-Stack benutzen. Und anstatt
es zu tippen oder aus der Bibliothek zu ziehen
, zeige
ich Ihnen
eine andere Möglichkeit, Ihre Elemente in die Stapel
einzubetten. Wenn Sie Command gedrückt halten
und auf das Element klicken, haben
Sie dieses Menü schon einmal gesehen. Sie können in H-Stack einbetten und es wird das nur für Sie
erstellen. Und das ist wahrscheinlich der
einfachste Weg, dies zu tun. Also werde
ich in diesem H-Stack Hello World hinzufügen. Sie können hier sehen
, dass mein Bild
jetzt hinter diesem H-Stack
mit zwei Textelementen steckt. Jetzt scheint es ziemlich intuitiv zu sein, diese Stacks zu
benutzen, oder? Aber wie ordnen Sie die
Elemente in dieser Steuer an? Nun, es gibt einige Möglichkeiten. Wenn ich also hier auf
diesen Stapel
klicke, schauen wir uns den Stapel an. Also klicke ich weiter
und klicke darauf. Dieser hat tatsächlich eine Ausrichtung. Das tut dieser Hirsch
auch nicht,
weil er einfach alles
übereinander legt. Aber für den H-Stack
und den Stack gibt es eine Ausrichtung. So können Sie wählen,
alles an ihrer Mitte auszurichten, alles an
ihren Baselines
auszurichten oder alles nach oben auszurichten. Und Sie können auch Abstand hinzufügen. Sie können also hier sehen, dass ich einen Abstand von drei
hinzufüge. Sie können sehen, wie es
den Code ändert , und es
fügt dort tatsächlich einen Abstand hinzu. Jetzt ist es zu wenig für dich,
um zu bemerken, dass ich 20 hinzufügen lasse. Sie können sehen, dass
es jetzt eine Lücke gibt. In Ordnung, Sie haben also
gelernt, dass Sie die Elemente
in einem Stapel
ausrichten können , und Sie können auch Abstand
zwischen Elementen in einem Stapel hinzufügen. Aber ich möchte
Ihnen eine andere Möglichkeit
zeigen Elemente
innerhalb eines Stapels anzuordnen. Um das zu tun, ändere
ich diesen Stack in einen V-Stack. Also kriegen wir so
etwas. Nehmen wir an, ich wollte, dass dieses
Logo oben steht, und ich wollte, dass meine beiden Textetiketten
hier unten stehen. Eine Möglichkeit, es zu tun,
besteht darin , den Abstand
in meinem V-Stack hinzuzufügen, oder? Sagen wir also, ich füge 100 hinzu. Man sieht, dass
sie auseinander geschoben werden. Wenn ich mehr hinzufügen kann, 300. Aber das ist ein fester Wert. Und wie Sie wissen,
gibt es eine Menge
verschiedener Bildschirmgrößen
und Auflösungen. Das ist also keine gute
Möglichkeit, sich dem zu nähern. Lassen Sie mich
diesen Abstandswert loswerden. Stattdessen können wir
ein Element verwenden, das als Spacer bezeichnet wird. Also lass mich dir zeigen,
wie das funktioniert. Zwischen dem Bildelement und dem H-Stack,
der die beiden Textelemente enthält. Ich füge
ein Abstandselement ein. Und der Name dieses
Elements ist Spacer, gefolgt von zwei
abgerundeten Klammern. Was dieses Abstandselement macht, ist den gesamten verfügbaren Platz
einzunehmen. Es dehnt sich einfach aus und
schiebt alles weg. Du siehst also, ich
habe das Bild hier. Ich habe den Abstandhalter, der so viel
Platz einnimmt wie möglich. Und dann enthält mein H-Stack
die beiden Elemente dort. Das Coole an dem
Spacer-Element
ist jedoch, dass es gut mit
anderen Abstandselementen
im selben Stapel spielt . Wenn ich also über
dem Logo hochgehe und
ein weiteres Abstandselement hinzufüge, passiert letztendlich, dass die beiden Abstandselemente beide gleich
viel Platz einnehmen. Sie können oben und
unter dem Kriegslogo sehen, dass
es gleich
viel Platz gibt. Wenn ich ein drittes
Abstandselement unter meinem H-Stack hinzufüge, was wird Ihrer Meinung nach
passieren? Nun, alle drei Bereiche, in denen
Elemente die verfügbaren Leerzeichen
teilen werden . Also die ersten Abstandselemente
hier, das zweite hier und das dritte ist da, und alles hat einen
gleichen Platz. Dies ist eine großartige Möglichkeit, die Dinge gleich
auszuräumen. Tatsächlich könnte ich das Gleiche mit
meinem H-Stack
machen , anstatt hier den Abstand
anzugeben. Und beachte dieses
Mal, dass ich
den Abstand 20 dort einfach löschen werde. Anstatt
es im Inspector zu ändern. Ich kann dort einen Abstandshalter hinzufügen. kopiere ich. Und Sie können hier sehen, dass es den gesamten verfügbaren Platz einnimmt meine beiden Etiketten zur Seite
schiebt. Aber wenn ich hier
auf der rechten Seite eins hinzufüge, wird
es
es in die Mitte schieben. Und wenn ich dann
einen in der Mitte hinzufüge, wird
es alles gleich weit entfernt machen. Großartig. Sie haben gelernt,
das Bild und den Raum für
Elemente zusätzlich
zum Textelement zu verwenden . Sie lernen auch, wie Sie
die Stack-,
HCI Stack - und
Zed-Stack-Container verwenden. wir das nächste Mal zusammensitzen, bauen
wir die Benutzeroberfläche für
Arbeitsharte Spiele auf.
6. 05: Aufbau der War: Hallo und willkommen. In dieser Lektion bauen
wir die Benutzeroberfläche
des Kriegskartenspiels auf. Eigentlich werde ich dich dazu
bringen, es zuerst
selbst zu bauen , weil
ich denke, dass du es schaffst. Komm schon. Ich lass dich loslegen. Probieren Sie es
ehrlich aus und dann gehen
wir gemeinsam die
Lösung durch. Deal. Komm schon, du kapierst
das, lass es uns machen. Okay, also
beginnen wir mit einem Xcode-Projekt, starten Xcode und erstellen
ein brandneues Xcode-Projekt. Wir werden die
App unter iOS wählen. Und du kannst das
alles nennen, was du willst. Aber ich werde
diese Kriegsherausforderung nennen
, denn das ist es, und es ist eine Herausforderung, von der ich
zuversichtlich bin, dass Sie es tun können. Interfaces Swift UI Lifecycle ist eine schnelle UI-App und die
Sprache ist schnell. Lassen Sie den Rest nicht aktiviert und speichern wir ihn irgendwo. Also
speichere ich es einfach auf meinem Desktop. In Ordnung, hier ist unser
brandneues Xcode-Projekt. Gehen wir
zuerst zur Asset-Bibliothek , da wir
alle Image-Assets hinzufügen werden
, die wir für diese App benötigen. Wenn Sie speziell
in den Ordner „
Kursressourcen“ in
dieser Lektion gehen, finden Sie eine Zip-Datei mit allen
Bild-Assets. Also mach weiter und entpacke das. Und dann ziehen wir all diese Assets
in die Asset-Bibliothek. Jetzt solltest du
die Karte zurück haben, den Hintergrund für
die gesamte App. Und dann solltest du
Karten zwei bis 14 und nein haben, du verpasst
den Einkaufswagen Nummer eins nicht. Das Ass ist Carbon-14. Und der Grund, warum ich sie
auf diese Weise
nummeriert habe , ist, dass
wir
diese Nummer am Ende
der Kartennamen hier verwenden diese Nummer am Ende
der werden, um den Wert
darzustellen. Und wir werden diesen Wert
vergleichen, um zu sehen , welche Karte die andere übertrumpft. Und dann
haben wir ein Deal-Button-Bild und ein Logo-Bild. Fall, dass ich es vorher nicht
erwähnt habe, haben
wir drei verschiedene
Größen für jedes Bild da es
für iOS-Geräte unterschiedliche
Bildschirmauflösungen gibt . Alle neueren Geräte
haben also ein Super-Retina-Display und
verwenden daher die a3x-Geräte und ich glaube nicht,
dass sie
tatsächlich Geräte mehr herstellen , die das One
Image Asset verwenden. Aber diese App stammt von vor
langer Zeit und wir haben zu vielen verschiedenen Zeiten umgebaut
, also haben wir immer noch alle drei. Lassen Sie mich Ihnen nun die
fertige Benutzeroberfläche zeigen. Und dies ist das Endergebnis, das Sie versuchen werden, sich selbst
zu erreichen. So sieht es aus. Achten Sie nicht zu sehr
auf den Abstand,
solange Sie
im Allgemeinen alles am richtigen Ort haben . Ich denke, das ist großartig. Eine andere Sache, die zu erwähnen ist , ist,
dass dies ein Button sein soll
, aber da wir noch keine Schaltflächen
durchlaufen haben, dafür ein
Bildelement verwenden. Und das ist
perfekt, wenn wir
auf Schaltflächen übergehen. Und ich kann dir zeigen, wie du
dieses Bildelement in einen Button umwandeln kannst. Eine andere Sache, die ich Ihnen
gegenüber erwähnen muss, ist das Konzept des sicheren Bereichs. Nun, der sichere Bereich
ist diese Region , die genau
hier unter ihnen beginnt, und sie endet genau hier oberhalb
dieses kleinen Lenkers. Und in einigen Fällen gibt es auch
auf der linken und
rechten Seite Ränder . Und alles in dieser
Region befindet sich in der sicheren Gegend. Jetzt wird dieses Gebiet garantiert
nicht behindert. Alles außerhalb
des sicheren Bereichs. Alles in dieser Ecke
oder dieser Ecke könnte also
behindert sein , wie Sie an Symbolen oder zu der Zeit sehen
können. Und offensichtlich gibt es
hier
diesen Lenker , der auch Dinge
blockieren könnte. Wenn Sie einen
Vollbild-Hintergrund wünschen, wie diesen grünen Hintergrund
, den wir hier haben , müssen
Sie
den sicheren Bereich ignorieren ,
da
Sie standardmäßig Elemente
zur Ansicht hinzufügen, es wird versuchen, im sicheren
Bereich zu bleiben. Es gibt also einen Modifikator, den
ich dir noch nicht gezeigt habe. Es wird als
sicherer Bereich ignorieren bezeichnet, den Sie auf ein Bild
anwenden können , das es ermöglicht über den sicheren Bereich hinaus
zu dehnen ,
so dass es die Kanten erreicht. Und das ist wahrscheinlich
die einzige andere
fehlende Information , die Sie benötigen. Abgesehen davon haben Sie
etwas über Stacks erfahren, Sie haben etwas über
Bild- und Textelemente erfahren,
alles, was Sie zum
Erstellen dieser Benutzeroberfläche benötigen. Also mach weiter, pausiere dieses Video
und probiere es selbst aus. Und danach kommen
wir wieder zusammen und ich werde dich
durchführen, wie man das baut. Also willkommen zurück. Wie konnten
Sie diese Benutzeroberfläche aufbauen? Herzlichen Glückwunsch,
wenn Sie dies oder etwas
bauen können , das dem ähnelt. Und wenn du feststeckst
oder du dir keine Sorgen machen konntest, weil wir es jetzt durchmachen
werden. Und oft finde ich
das, wenn du es
selbst ausprobierst und steckenbleibst und
später die Lösung findest. Dies sind oft die
besten Lernerfahrungen. Alles klar, lasst uns das jetzt gemeinsam
durchgehen. Bevor wir jetzt eintauchen und mit dem Aufbau dieser
Benutzeroberfläche beginnen, möchte
ich mir einen
Moment Zeit nehmen, um zu zerlegen
, welche Elemente ich hier sehen kann. Zuallererst kann
ich sehen, dass wir weil einen Zed-Stack brauchen
werden. Wir haben ein Bild hinter
all diesen Elementen. Und so
wird dieser Stapel es uns ermöglichen, Elemente
übereinander zu positionieren. Als nächstes haben wir einen
V-Stack, bei dem Elemente vertikal
übereinander gestapelt
werden. So können Sie sehen, dass ein V-Stack
durch diese gesamte
Benutzeroberfläche von oben nach unten läuft . Jetzt werden einige der Elemente
in diesem V-Stack tatsächlich
in einem H-Stack enthalten sein, wie zum Beispiel diese beiden Karten
nebeneinander. Und dieses Element hier
unten wird ein H-Stack von TÜV-Stacks sein. Dies ist also ein V-Stack,
der die beiden Textelemente enthält. Dies ist ein V-Stack, der die beiden Elemente
enthält und dann kapselt man
sie in einen H-Stack. Das ist also der
Zusammenbruch, den ich sehe. Und jetzt springen wir schnell in unseren Content View dot
und bauen ihn aus. Alles klar, also hier schaue
ich mir
den Inhalt an Vue.js Swift. Das erste, was ich tun
werde, ist, diesen Simulator
auf iPhone 11 zu
ändern. Und lass uns auf „Fortsetzen“ klicken. Und in ein paar Sekunden könnte die
Zeit länger sein, wird hier eine Vorschau sehen. Perfekt. Jetzt ändern wir dieses
Standardtextelement. Werde das los. Lasst uns einen Z-Stack dorthin legen ein Paar
geschweifte Klammern
öffnen. Was hinter all
diesen Elementen sitzt , ist ein Bild. Und das Bild, das wir haben,
heißt Hintergrund. Beachten Sie, dass es nicht
ganz nach oben reicht. Jetzt überlappt es
diesen sicheren Bereich ein wenig. Ich sagte, der sichere Bereich sei genau hier
unter der Kerbe. Du siehst also, dass es überläuft, aber es
geht nicht ganz wirklich den ganzen Weg dorthin. So können wir einen Modifikator mit dem
Namen ignoriert sicheren Bereich hinzufügen. Wenn du das machst, wird
es einfach alles
abdecken. Also okay. Was wird also
ganz oben auf diesem Hintergrund stehen? Nun, wie ich schon sagte, wir werden
einen vertikalen Stapel haben der all
diese Elemente
enthält. Das erste ist das Logo. Und dann
haben wir einen H-Stack mit zwei Karten und dann ein Bildelement, das
den Deal-Button darstellt. Und danach
werden wir die Score
vertikale Stapel in
einem horizontalen Stapel haben . Lassen Sie mich das also austippen, damit es etwas
sinnvoller ist. Fangen wir mit dem
Logo an der Spitze an. Wir werden ein Bild haben und unser
Image-Asset-Name ist Logo. Sie können also sehen, dass es dort
einfach in
der richtigen Größe erscheint. Und das liegt daran, dass unser
Image-Asset diese Größe hat. Okay, jetzt legen wir
einen H-Stack hier rein. Und hier drin werden
wir
zwei weitere Bildelemente platzieren . Wir legen die, legen wir auch die Karte ein. Und dann Karte drei. Wir haben also zwei Karten
in einem H-Stack. Und danach setzen
wir
ein anderes Bildelement ein. Und das wird der Deal-Button
sein. Und jetzt kommen die Score-Labels. Es wird also ein H-Stack sein. Aber innerhalb des Stacks haben
wir tatsächlich zwei Vs. Danke. Jeder VSAT enthält
zwei Textelemente. Also werden wir Spieler haben und wir werden die tatsächliche Punktzahl
haben. Und dann werden
wir für diesen eine CPU haben. Und wir werden
die tatsächliche Punktzahl haben, die CPU. Also haben wir im Grunde alle
unsere Elemente angelegt. Jetzt fügen wir ihnen etwas
Abstand hinzu. Um das zu tun,
können wir Abstandhalter verwenden. Beginnen wir also mit dem Hinzufügen
eines Abstandshalters
direkt über dem H-Stack
der beiden Karten unter
dem Logo-Bild. Also lege ich ein
Abstandselement genau dort ein. Und was du über
Abstandselemente gelernt hast, oder? Es nimmt
den gesamten verfügbaren Speicherplatz ein. Wenn Sie jedoch
mehrere Abstandselemente
im selben Container haben , wird dieser
Raum gleichmäßig zwischen den beiden Abstandshaltern aufgeteilt. Also lege ich einen weiteren
Abstandhalter direkt unter die Karten. Jetzt können Sie sehen
, dass es
zwei gleiche Anzahl an Leerzeichen gibt . Ich setze vorerst
einen weiteren Abstandhalter unter den Deal-Button
oder das Bild. Und dann lege ich einen Abstandhalter unter die Punktebeschriftungen. Also musst du sicherstellen, dass du es hier
nicht an den
falschen Ort bringst. Wir wollen es
unter diesen H-Stack legen. Und wenn Sie auf
diese Endklammer klicken, können
Sie sehen, dass Xcode
kurz
die Anfangsklammern aufleuchtet ,
damit Sie überprüfen können , ob Sie es haben möchten. In Ordnung, und das Letzte,
was zu tun ist, ist
ein Abstandselement
über das Gedankenlogo zu setzen . Das ist also genau hier. Jetzt ist
es aus vertikaler
Sicht alles gut verteilt. Für diesen H-Stack
mit den beiden Karten. Warum legen wir da nicht ein paar
Räume rein? Beginnen wir damit,
einen Abstandshalter zwischen
die beiden Karten zu legen . Und dann der Platz sie vor all den Karten und dem
Abstandhalter nach den Karten. Wir machen das Gleiche
mit den Textbeschriftungen hier unten. In diesem H-Stack. Wir werden einen Abstandshalter
zwischen die Steuer der beiden V setzen. Und dann werden wir einen Abstandhalter vor die IT
stellen. Und der Raum oder danach. Alles klar, und jetzt ist es
das Letzte, was Sie tun müssen, nur
die Schriftfarbe
dieser Textelemente zu ändern . Und auch um ihre
Schriftgewichte und Schriftgrößen zu ändern. Und vielleicht fügen Sie ein
wenig Platz
zwischen der Partitur und dem Label hinzu. Okay, also klicken wir auf dieses Textelement und schauen
uns an, was wir tun könnten. Wenn Sie also im
Inspector-Panel nach der Schriftart suchen, können
Sie eine dieser
vordefinierten Schriftgrößen auswählen. Wählen wir für diesen eine Überschrift. Und du kannst es sehen. Dort wird es etwas mutiger. Lasst uns das in Weiß ändern. Wir machen das
Gleiche für das CPU-Label. Wir werden
es in Überschrift ändern. Wir werden
die Farbe auf Weiß ändern. Für die eigentliche Punktzahl ändern
wir dann die Schriftart in, sagen wir, Unterüberschrift. Und wir werden
die Farbe auch auf Weiß ändern. Und für dieses Score-Label werden
wir
es in eine Unterüberschrift ändern, und wir werden
es auch in Weiß ändern. In Ordnung, und wenn wir es tatsächlich schaffen
wollten, denke
ich, dass
ich es in der ursprünglichen
Benutzeroberfläche als großen Titel hatte. Also werde ich es
dahin ändern. Also
ändere ich die 0 von der Unterüberschrift auf einen großen Titel. Jetzt um hier
etwas Polsterung
zwischen dem Label
und dem Score hinzuzufügen . Was Sie tun können, ist das Etikett zu
wählen. Fangen wir hier mit
dem Spieler an. Und klicken wir nur auf
diese untere Polsterung. Also aktiviere das. Und dann kannst du diese
Zahl auf „sagen wir 20“ ändern. Sie können diesen Anstieg sehen. Und das sieht ein
bisschen zu viel aus. Vielleicht bleiben wir also bei 10. Wir machen das
Gleiche mit der CPU hier und klicken nur auf den unteren
Padding, und dann fügen wir 10 hinzu. Den
entsprechenden Code sehen Sie hier. Es fügt Polsterung hinzu,
aber es wird
nur für die
Unterkante und für 10 Punkte angegeben . Und das ist eine gute Praxis
, wenn Sie etwas ändern, visuell, einen Modifikator hinzufügen oder etwas
im Inspektor-Panel ändern.
Es empfiehlt sich, einen Blick darauf
zu werfen, was sich auf der codeseitig, nur damit Sie sich im Laufe der
Zeit erinnern können, je mehr Sie es sehen, desto mehr erinnern Sie sich daran, dass, hey, wenn ich sie
in eine Schriftart im Schlagzeilenstil ändern wollte, ich nur einen Punktschriftmodifikator
hinzufügen müsste und geben Sie eine Überschriftenoption ein. Dasselbe gilt für die
Vordergrundfarbe für dieses Textelement, Punktvordergrundfarbe,
Farbe Punktweiß. Sie müssen nicht
versuchen, es auswendig zu lernen, sondern achten Sie einfach darauf. Und mit der Zeit wirst du dich
einfach erinnern. es eingeben, wird Wenn Sie es eingeben, wird es schneller
sein, als über das Inspektorfenster oder
die Vorschau-Leinwand visuell umklicken und Dinge
konfigurieren zu müssen. Okay, das Letzte, was Sie tun
müssen, stellen Sie sicher Sie das Projekt
speichern
und fertig sind. In dieser Lektion haben Sie also die Benutzeroberfläche des Kriegskartenspiels
erstellt, aber um auf
Benutzerinteraktion zu reagieren und die Kartenbilder
programmgesteuert zu ändern, müssen
wir
einige schnelle Programmierung lernen. In den nächsten vier Lektionen werden
Sie also mit Swift in die
Programmiergrundlagen eingeführt . Wenn Sie jetzt zum ersten
Mal programmieren lernen, gehen Sie es langsam und
versuchen Sie nicht , sich eines
der Keywords zu merken. Und danach werden
wir zu
dieser
Benutzeroberfläche für Kriegskartenspiele zurückkehren dieser
Benutzeroberfläche für Kriegskartenspiele und es mit Code zum Leben erwecken. Alles klar, wir sehen uns dort.
7. 06: Variablen: Hallo und willkommen. In dieser Lektion und
in den nächsten drei lernen
Sie die Grundlagen
der Swift-Programmiersprache. Jetzt sind dies die Fähigkeiten, die Sie haben müssen, um das Kriegskartenspiel abzuschließen, sowie das Erstellen der Feature-App, die
wir zusammen machen werden. Wenn du noch nie
codiert hast, weiß
ich, dass das ein
bisschen einschüchternd erscheinen mag, aber ich möchte wirklich, dass
du
dabei bleibst und wirklich
genau aufpasst. Öffnen Sie Xcode auf Ihrem eigenen Computer und tippen Sie
genau das ein, was ich Ihnen zeige. Dies wird wirklich
dazu beitragen,
die Struktur der Sprache
und aller Schlüsselwörter zu verstärken . Es ist überhaupt nicht nötig, sich etwas
auswendig zu lernen. Ich garantiere, dass
Sie
am Ende dieses Moduls Ihren eigenen Swift-Code schreiben. Alles klar, lass uns eintauchen. Ich möchte zunächst den View-Update-Lebenszyklus
einer einfachen App ansehen und Ihnen zeigen, wo
Swift-Code in jedem Teil
des Lebenszyklus
eine Rolle spielt . Beginnen wir mit dem,
was Sie in den vorherigen Lektionen bereits
gelernt haben in den vorherigen Lektionen bereits
gelernt , dass die Benutzeroberfläche
aus Swift-Code generiert wird. Wir nennen das deinen View-Code. Es generiert eine Benutzeroberfläche, die
Ihr Benutzer sehen kann. In der Regel haben
wir mit einer App eine Art von Daten, die wir abrufen und anzeigen möchten. Zum Beispiel eine Nachrichten-App. Wir möchten diese Daten aus
einer Datenquelle abrufen
und dann in unsere App abrufen und in unserer Benutzeroberfläche
anzeigen. Sie können dafür Swift-Code verwenden. Der Swift-Code kann die Daten
abrufen und dann in einem Format
verarbeiten
, das unsere App verstehen kann. Anschließend können
wir diese
Daten mithilfe von Swift-Code auch mit unserem
View-Code verknüpfen , sodass diese Daten dem Benutzer
angezeigt werden können, wenn
die Benutzeroberfläche aus diesem View-Code
gerendert wird. Wenn der
Benutzer mit der Benutzeroberfläche interagiert,
z. B. das Tippen einer Schaltfläche, können
wir den Swift-Code verwenden, um
dieses Ereignis zu erfassen und darauf zu reagieren. Basierend auf dem, worauf
der Benutzer getippt hat, verwenden
wir möglicherweise einen
Swift-Code, um unsere Daten zu ändern. Wenn diese Datenänderung
stattfindet, weil wir diese Daten
mit unserem View-Code
verknüpft haben . Diese Daten werden automatisch erkannt und die neue Benutzeroberfläche wird mit
den aktualisierten Daten
neu gerendert
, damit der Benutzer sehen kann,
was sich geändert hat. Jetzt ist dieser Zyklus im Wesentlichen alles, was die App
immer wieder macht. Und wir werden diese App, Ansicht und Aktualisierung des Lebenszyklus in zukünftigen Lektionen
genauer untersuchen. Aber im Moment möchte ich nur, dass Sie verstehen, dass Swift-Code in jedem
Teil dieses Lebenszyklus eine Rolle spielen
muss. Aus den letzten Lektionen haben
Sie bereits den
Code zum Erstellen der Benutzeroberfläche gesehen. Sie wissen also irgendwie
, wie dieser View-Code aussieht. Lassen Sie uns unseren Fokus
auf den Datenteil verlagern, in dem wir sehen
können, welcher Swift-Code
verwendet wird , um die Daten im
Auge zu behalten. Wie sieht das in unserer App
überhaupt aus? Um einen
Teil des Swift-Codes auszuprobieren und die Antwort auf unsere Frage
zu finden, verwenden
wir einen Xcode-Spielplatz. Ein Spielplatz ist eine
leichtgewichtige
Möglichkeit , einen Teil unseres Codes zu testen, ohne sich zu einem
vollwertigen App-Projekt zu verpflichten , das wir hier durchführen können. Stellen Sie sich das im Xcode Playground
wie Ihr Doodle-Pad vor, aber für Code starte jetzt
einfach ein neues. Gehe zu Datei, klicke auf Neu und klicke dann
auf Playground. Wir werden uns für
einen leeren Spielplatz entscheiden. Und geben wir ihm einen Namen. Und lasst es uns irgendwo aufheben. Wir schließen
diese Navigator-Registerkarte indem wir auf diese Schaltfläche klicken
, da wir das nicht benötigen. Jetzt, hier unten in der linken
unteren Ecke, werden
Sie feststellen, dass wir
einen Button mit dem Namen haben , der den Fehlerbereich
zeigt. Gehen Sie weiter und klicken Sie darauf,
um dieses Fach anzuzeigen. In diesem Debugger-Konsolenbereich werden
wir viele Daten
ausgeben. Schalten Sie das einfach ein und
stellen Sie sicher, dass Sie diesen
kleinen Bereich hier unten sehen. Und dann diesen Button, ich möchte, dass du
gerade darauf klickst,
es wird den Spielplatz ausführen. werden
alle
Codezeilen im Editorbereich ausgeführt Hier oben werden
alle
Codezeilen im Editorbereich ausgeführt. Beachten Sie jedoch,
dass Sie auch
diesen kleinen blauen Run-Button
entlang der Zeilennummern haben . Auf diese Weise können Sie auswählen , zu welcher Zeile Sie den Code
ausführen möchten. Wenn ich also den Mauszeiger auf Zeile drei fahre und
den Knopf genau hier drücke, laufen die Zeilen 123
im Gegensatz zu diesem Button hier
, der alles ausführt. Wenn Sie diesen Spielplatz zum ersten Mal
betreiben, kann
es eine Weile dauern. Du zeigst den Spinner
bis zu einer Minute lang. Ich möchte
, dass du das machst und
es einfach laufen lässt , bis es
bereit ist, fortzufahren. Und das wird uns dazu bringen im nächsten Teil Code
auszuführen. Lassen Sie uns vorerst
einfach
diese Codezeilen löschen , damit
wir neu beginnen können. Okay, jetzt, da dein Setup, lass uns zu unserer
ursprünglichen Frage zurückkehren. Wie sehen Daten
aus und wie verwenden
wir Swift-Code, um sie im Auge zu
behalten? Schauen wir uns ein paar
verschiedene Arten von Daten an. Beginnen wir zunächst mit einem gemeinsamen Datentyp,
einem Textstück. In Swift umgeben Sie Texte mit Anführungszeichen wie diesem. Und dies wird als
String-Daten bezeichnet. Lassen Sie uns
hier oben eine Notiz
mit zwei Schrägstrichen hinzufügen . Wenn Sie das tun,
wird es als Kommentar bezeichnet, und es ist eine Möglichkeit für uns,
eine Notiz oder eine kleine Dokumentation zu hinterlassen eine Notiz oder eine kleine Dokumentation , damit wir
uns
oder andere Personen daran erinnern können, die sich unseren Code ansehen was dieser Code macht. Und wenn Xcode diese
beiden Schrägstriche sieht, wird
es diese Zeile nicht
ausführen. Werfen wir einen Blick auf einen
anderen Datentyp, ganze Zahlen. Also etwas, das so
aussieht. In Swift wird dies als
int bezeichnet, kurz für Integer. Und was ist mit Dezimalzahlen? Nun, ja, das ist
auch ein Datentyp , den Swift erkennen
und handhaben kann. Jeder von diesen. Sie sind als Double bekannt. Und Swift kann auch
mit booleschen Werten umgehen. Also Dinge wie wahr und falsch. In Swift wird dies als bool bezeichnet. Jetzt string, int,
double und bool. Dies werden alle
Datentypen genannt und so klassifiziert Swift Daten. Jetzt sind dies nicht
alle verfügbaren Datentypen ,
aber dies sind die weitem
gebräuchlichsten, die Sie
zumindest am Anfang verwenden werden . Und es ist ein großartiger
Ausgangspunkt für uns. Alles klar, jetzt schauen wir uns das Erstellen und
Verfolgen von Daten an. In Swift gibt es viele
Möglichkeiten, Daten im Auge zu behalten, aber zwei von ihnen
sind grundlegende Möglichkeiten Variablen und Konstanten zu
verwenden. Gehen wir zurück zu unserem
Xcode-Spielplatz und schauen uns ein Beispiel an. Fangen wir hier mit unseren
Hello String-Daten an. Jetzt wird diese Daten
allein für uns nutzlos
sein, es sei denn, wir haben eine Möglichkeit, sie
zu referenzieren und zu verfolgen. Und wir könnten das
mit einer Variablen machen. Sehen wir uns also an, wie wir
eine Variable deklarieren können , um
diese Hallo Daten im Auge zu behalten. Also verwenden wir das
Schlüsselwort var und das dient zum Deklarieren einer neuen Variablen. Und dann geben wir den
Namen der Variablen ein. Dieser Name wird verwendet, um auf diese Daten
zu verweisen und ihn zurückzurufen. Also nenne ich das MyVar und dann folgen wir
ihm mit einem Doppelpunkt. Und danach setzen wir den Datentyp ein, den diese
Variable verfolgen wird. Da die Daten, auf die wir verweisen
möchten , ein
Stück String-Daten sind, füge
ich hier eine Zeichenfolge ein. Und als nächstes weisen wir
normalerweise in derselben Zeile, in der
wir die Variable deklarieren, die Daten der
Variablen zu, um den Überblick zu behalten. Und das können wir mit
dem Zuweisungsoperator tun
, der nur ein Gleichheitssymbol ist. Und dann legen
wir auf der
rechten Seite die Daten ein, die wir dieser Variablen
zuweisen möchten. Ich nehme das
und verschiebe das genau hierher. Was diese
Codezeile sagt, deklarieren
wir im Wesentlichen eine neue
Variable namens MyVar. Wir sagen, dass es die Daten des String-Typs
verfolgt. Und dann weisen wir dieser Variablen diese Hallo String-Daten
zu. Es ist so, als würden
wir diesem Datenstück
namens MyVar
ein Etikett beifügen . Wann immer ich auf dieses Datenstück
verweisen möchte, muss ich
es
nur noch mit dem Variablennamen referenzieren. Probieren wir es also mal aus. Wir können einen speziellen
Befehl verwenden, der die Daten an
den Konsolenbereich unten im Spielplatz
ausgibt . Und dieser Befehl wird nur gedruckt gefolgt von zwei
abgerundeten Klammern. Und zwischen diesen Klammern legen
Sie die Variable oder welche Daten
, die Sie
ausgeben möchten . Also mache ich das. Und dann werde
ich hier unten
meinen Spielplatz anhalten und den
gesamten Code darin noch einmal ausführen. Und dann, wie Sie
da unten sehen können und es heißt hallo, dass der Inhalt von MyVar genau
das ist, was
wir erwarten würden. Beachten Sie, dass ich das Schlüsselwort
var nicht mehr verwenden muss, wenn
ich auf meine Variable
verweise . Das war nur, um die Variable zu
deklarieren. Und sobald ich meine Variable
deklariert habe, kann
ich
sie einfach am Namensende referenzieren. Ich kann ihm auch
neue Daten zuweisen. Ich kann es immer wieder benutzen. Ich muss es nicht einlösen. Nachdem
ich es zum Beispiel als
zugewiesenes Hallo erklärt
habe, kann ich mich umdrehen und ihm
etwas anderes zuweisen. Weisen wir diesen
String-Daten namens
world MyVar zu. Und im Wesentlichen haben
wir hier gemacht, dass wir diese Variable stattdessen
gesagt haben , um diese Daten zu verfolgen. Was würdest du erwarten, wenn ich den Code jetzt auf
dem Spielplatz ausführe? Wir würden nur
Welt ausgeben, weil MyVar
diese Hallo Datenmenge nicht mehr verfolgt. Eine Sache, die ich hervorheben
möchte ist der Datentyp
der Variablen. Wenn ich angebe, dass MyVar ein String-Typ
ist, kann
ich nur
Teile von String-Daten verfolgen. Wenn ich zum Beispiel eine Ganzzahl wie
100
hatte und versucht habe, diese MyVar
zuzuweisen, bekomme ich einen Fehler
, der nicht erlaubt ist. Was ich stattdessen tun muss,
ist eine neue Variable
vom Typ int zu deklarieren , um diese Int-Daten zu verfolgen
. Gehen wir also fort und verwenden
das Schlüsselwort var und nennen es. Und dann Doppelpunkt und dann der Datentyp, den
ich verfolgen möchte. Und das ist jetzt vollkommen in Ordnung. Versuchen wir, das auszudrucken. Xcode wird Ihnen nicht helfen, Rechtschreibfehler
automatisch zu korrigieren. Alles klar, also
haben wir Welt und 100. wir jetzt
mehr zusammen programmieren, werden
Sie
verschiedene Arten von
Namenskonventionen bemerken, wie zum verschiedene Arten von
Namenskonventionen bemerken, wie was Sie hier sehen, wo meine Variablennamen
mit einem Kleinbuchstaben beginnen, und dann beginnt jedes
nachfolgende Wort in
meinem Variablennamen
mit einem Großbuchstaben. Das ist also nur eine
Standardbenennungskonvention. Du könntest wirklich
alles machen, was du willst. Aber wenn Sie anfangen,
mehr zu programmieren und in Teams zu arbeiten, ist
es wichtig, dies zu haben. Standard, den jeder benutzt, und das ist üblich. Alles klar, eine Sache, über die ich
noch
sprechen möchte , bevor wir zum
nächsten Thema übergehen , ist die Tatsache, dass es in
Xcode Kurzformen gibt. Sie müssen nicht wirklich alle Informationen
eingeben. Zum Beispiel
erklären wir hier, dass diese Variable, mein int, ein int-Typ ist und wir ihr
ganzzahlige Daten zuweisen. Aber die Sache ist, wir könnten diesen Datentyp tatsächlich
weglassen und einfach 102 zuweisen. Wenn wir das tun, kann Xcode sehen, dass es sich um einen
Int-Daten handelt. Es wird also davon ausgegangen, dass mein int
nur Typen verfolgen wird. Jetzt gilt die gleiche Regel
immer noch. Ich meine, nachdem Xcode festgestellt hat, dass diese Variable n-Typ ist weil Sie ihr 100
zugewiesen haben. Ich kann nicht gehen und ihm
eine Zeichenfolge zuweisen. Das wird nicht
erlaubt sein, da Xcode bereits erkannt
hat, dass
dies ein n-Typ sein sollte. Das Gleiche gilt hier oben. Ich muss den Datentyp nicht
angeben. Wenn ich ihm sofort
ein Stück
Stringdaten zuweisen werde sofort
ein Stück
Stringdaten zuweisen ,
weil das
Xcode mitteilt, dass dies eine
String-Typvariable sein wird. Das ist also nur eine
kleine Abkürzung , um dir etwas Tippen zu ersparen. In Ordnung, also haben Sie gelernt, eine neue Variable
zu deklarieren, Daten
zuzuweisen und diese Daten
unter Verwendung des Variablennamens abzurufen. Und Sie haben auch
gelernt, dieser Variablen
neue Daten zuzuweisen . Sprechen wir über die andere
Möglichkeit, Daten im Auge zu behalten. Konstanten. Konstanten sind also genau wie Variablen
, außer dass Sie ihr keine Daten
neu zuweisen können , nachdem Sie ihr das erste
Datenelement
zugewiesen haben . Also sigillata, wie man eine
Konstante deklariert , um diese String-Daten zu verfolgen
. Anstelle des Schlüsselworts var verwenden
Sie das Schlüsselwort let. Und dann ist der Rest genauso
wie eine Variable. Also beginnen wir mit
einem konstanten Namen, meinem Doppelpunkt, und dann haben Sie vermutet , dass der Datentyp
gefolgt vom Zuweisungsoperator ist. Und dann werden wir diese Daten so auf
die rechte Seite
dieses
Zuweisungsoperators
verschieben die rechte Seite . Versuchen wir nun,
diese Konstante zu referenzieren. Versuchen wir,
die Daten in meinem Kontext auszudrucken. Wie Sie sehen können,
funktioniert es wie erwartet. Versuchen wir nun, das
Ding zu tun, was nicht erlaubt ist. Versuchen wir, ihm
etwas anderes zuzuweisen. Und wie erwartet können wir Daten nicht
neu zuweisen, da es sich um eine Konstante handelt. Jetzt sind Konstanten nützlich. Es ist ein zusätzliches Tool
, das wir verwenden können, wenn wir nicht erwarten, dass sich
diese Daten ändern werden. Und deshalb müssen wir niemals
Änderungen daran vornehmen. Wann würdest du also eine
Konstante über eine Variable verwenden? Nun, es hängt wirklich davon ab,
was du versuchst zu tun. Wahrscheinlich werden Sie aufgrund
ihrer Vielseitigkeit und
aufgrund von Datenänderungen
die meiste Zeit Variablen
verwenden aufgrund von Datenänderungen
die meiste Zeit . Die beste
Vorgehensweise ist es
jedoch, Konstanten gegenüber Variablen zu bevorzugen ,
in denen sie erstellt werden Sinn. Tatsächlich ist Xcode klug
genug zu wissen, ob Sie eine Variable
verwenden und diese Variable nie ändern.
Es wird vorschlagen,
dass Sie dieses var-Schlüsselwort
in ein let-Schlüsselwort
ändern und eine Konstante
verwenden stattdessen. In Ordnung, lassen Sie uns eine kurze Zusammenfassung
machen bevor wir die Lektion abschließen Sie haben etwas über den
View-Update-Lebenszyklus erfahren und wie Swift-Code
dabei eine Rolle spielt. Sie haben etwas über
Datentypen wie String,
int, bool und double erfahren . Sie haben gelernt
, wie Sie Variablen und
Konstanten verwenden , um Daten zu referenzieren. Bisher machen Sie große
Fortschritte. Und in der nächsten Lektion bringe
ich Ihnen bei, wie Sie
Ihre Codeanweisungen
in Funktionen organisieren können. Alles klar, wir sehen uns dort.
8. 07: Schnelles Programmieren: Hallo und willkommen. In der vorherigen Lektion haben
Sie etwas über
Swift-Variablen und -Konstanten erfahren. Sie lernen, wie Sie
einige Daten erstellen und eine
Variable oder Konstante deklarieren , um sie im Auge zu behalten. In dieser Lektion
lernen
Sie, wie Sie Ihre
Codeanweisungen organisieren und
gruppieren lernen
Sie, wie Sie Ihre
Codeanweisungen organisieren . Damit die Nummer eins, alle Codeanweisungen
, die Sie
zusammengefasst haben , können für eine gemeinsame Aufgabe
zusammenarbeiten. Und Nummer zwei: Sobald Ihr Code in Gruppen unterteilt
ist, können
Sie auswählen, welche
Gruppe von Mänteln
ausgeführt werden soll , je nachdem, welche
Aufgabe Sie erledigen müssen. Diese Gruppen haben
Codeanweisungen, die in Swift als Funktionen
bezeichnet werden . In Ordnung,
werfen wir einen Blick auf das
Lifecycle-Diagramm der Ansicht aus der vorherigen Lektion
und sehen, wo Funktionen in diesem Lebenszyklus eine
Rolle spielen könnten. Denken Sie daran, dass
Swift-Code dieses
Ereignis erfasst und darauf
reagiert, wenn der Benutzer mit der Benutzeroberfläche interagiert . Nun, hier haben wir möglicherweise ein
paar verschiedene Funktionen je nachdem, wie der Benutzer mit unserer Benutzeroberfläche
interagiert. Beispielsweise kann der Benutzer, der auf eine Schaltfläche
tippt die App
dazu veranlassen, den Bildschirm
zu wechseln. In diesem Fall führen wir vielleicht Funktion a aus, um diese Aufgabe auszuführen. Oder
was ist, wenn der Benutzer auf einen
Artikel tippt, um mehr Details zu sehen? In diesem Fall führen wir dann
Funktion B aus, um
den Detailbildschirm aufzurufen. Gehen wir nun den Code durch
, der den
Datenabruf durchführt. Zum Beispiel könnten wir
eine Funktion C haben , die den
tatsächlichen Abruf der Daten durchführt, vielleicht den Netzwerkcode. Und es schnappt sich die
Daten und gibt
sie dann an, D als Eingabe zu funktionieren. Und die Verantwortung
dieser Funktion
könnte darin bestehen
, diese Daten zu verarbeiten und in
ein Format umzuwandeln , das unsere
App verstehen kann. Funktion D nimmt diese Daten also als Eingabe und gibt die
formatierten Daten für unsere App aus. Jetzt könnte ich weitermachen,
aber wie Sie sehen können, sind
Funktionen eine grundlegende Komponente
der schnellen Programmierung. Es ist überall. Jetzt lasst uns sehen, wie wir unsere eigenen Funktionen erstellen
können. In Ordnung, also hier habe ich einen brandneuen
Xcode-Spielplatz und
wir werden uns
die Funktionssyntax ansehen. Und nur für den Fall, dass ich das noch nicht
erklärt habe, ist
das Wort Syntax einfach ein Wort das die Struktur oder
die Grammatik der Sprache
beschreibt. Also, Funktionssyntax, um eine neue Funktion zu
deklarieren, beginnen
Sie mit dem
Func-Schlüsselwort FUN, siehe. Es ist eine funky Funktion. Und dann folgst du ihm mit
dem Namen der Funktion. Und dann
sind eine Reihe von Klammern abgerundete Klammern und dann eine Reihe
geschweifter Klammern. In den
geschweiften Klammern legen
Sie Ihre Codeanweisungen ein,
alles, was Sie ausführen
oder ausführen möchten , wenn wir diese Funktion
aufrufen. Lassen Sie mich also einfach
ein paar Aussagen abgeben. Nehmen wir an, deklarieren Sie zwei
Konstanten wie diese, und drucken wir dann ein Plus b. Wenn ich das jetzt ausführen und alle
diese Codezeilen ausführe, wird
nichts passieren. Sie sehen keine Ausgabe. Und das liegt daran, dass wir diese Funktion nicht wirklich aufgerufen haben. Um diese Funktion aufzurufen und
auszuführen, müssen
wir
sie nur mit dem Funktionsnamen referenzieren. Das ist also mein FUN, C, gefolgt von den
Paarklammern, und so führen Sie den
gesamten Code dazwischen hier aus. Probieren wir das also aus. Ich höre auf, die Ausführung zu und führe dann wieder meinen
Spielplatz aus. Und wir bekommen 30 wie erwartet. Wenn ich diese
Anweisungen noch einmal ausführen wollte, kann ich es
einfach noch einmal anrufen. Und wenn ich es ausdrucke, führe diesen Code jetzt zweimal aus. Jetzt möchte ich
für nur eine Sekunde
zu diesem
View-Update-Lebenszyklusdiagramm zurückkehren . Denn wenn Sie
in diesem Datenabrufbereich wieder bemerken, sagte
ich, dass wir möglicherweise zwei Funktionen
haben könnten, c und Funktionen dy, bei denen C
die Daten abrufen und als Eingabeparameter an D übergeben
würde . So kann diese Funktion D mit
diesen Daten arbeiten und
formatieren, wie wir es brauchen. Eine Funktion, die Daten akzeptieren
kann, um damit zu arbeiten, ist daher
eine sehr leistungsstarke Funktion. Werfen wir einen Blick darauf, wie wir
eine Funktion deklarieren würden
, die eine Art von Eingabedaten akzeptiert. Okay, also
lösche ich diese beiden Zeilen und ich werde
meine Funktion hier ändern. Anstatt
zwei Konstanten, a und b, zu deklarieren gebe
ich an , dass a und b
an die Funktion übergeben werden müssen. Wir tun das also durch die
Verwendung von Funktionsparametern zwischen
den beiden abgerundeten Klammern. Dort
würden wir alle Parameter angeben ,
die wir an diese Funktion
übergeben werden möchten. Sie können
mehrere Parameter übergeben, aber fangen wir
einfach mit
einem an und fangen wir einfach mit einem an.
Also würde ich zuerst den
Namen des Umfangs angeben,
also möchte ich,
dass das acht ist Also würde ich zuerst den
Namen des Umfangs angeben, . Und dann würde ich
einen Doppelpunkt setzen, der
durch den Datentyp angegeben ist, um den
dieser Parameter handelt. Da ich erwarte, dass es dabei sein werde
ich
diesen Parameter
als gefolgt
vom Datentyp int deklarieren . Und dann kann ich
diese Konstante von hier aus löschen. Wie Sie sehen können, ist
dies fast wie eine Variablendeklaration oder eine konstante Deklaration, außer ohne die var und
ohne die Linke. Hier geben wir an, dass bei jedem Aufruf dieser
Funktion ein int-Parameter zusammen mit ihm übergeben
werden muss. Und es wird durch
diesen Parameternamen a
innerhalb dieser Funktion referenziert . Jetzt können Sie also sehen
, dass ich nirgends eine Variable
a oder Konstante a
deklariert habe , aber ich kann immer noch ein Plus B als Teil
meiner Gleichung setzen , weil a als Parameter übergeben
wird. Werfen wir einen Blick darauf, wie Aufruf dieser Funktion aussehen
würde. Jetzt verlasse ich mich
auf die automatische Vervollständigung. Also tippe ich MY FUN und du kannst sehen,
sobald ich das mache, dass es meine Funktion hier erkennt. Also klicke ich weiter
und klicke darauf. Und Sie können sehen, dass
ich jetzt beim Aufruf dieser Funktion beim Aufruf dieser Funktion auch ein
ganzzahliges Datenelement übergeben muss. Also werde ich weitermachen
und das weitergeben und etwas anderes
in der Vergangenheit
übergeben und fünf, du kannst hier sehen,
da zeigt an,
dass dies der Parameter
ist, den ich übergebe. Lass uns weitermachen und anhalten und meine
Codezeilen noch einmal
ausführen. Und dieses Mal ist die Ausgabe 25, weil 5
an die Funktion übergeben wurde. Plus 20 ist 25. nun wieder zum
View-Update-Lebenszyklusdiagramm zurückkehren, akzeptiert die
Funktion D die
Eingabe als Parameter, aber auch die Ausgabe zurück. Das ist also ein weiteres sehr
leistungsfähiges Feature von Funktionen. In der Lage zu sein, einige Eingaben aufzunehmen, mit diesen Daten zu
arbeiten und
einige Ausgaben wieder in die
Farbe der Funktion bereitzustellen . Werfen wir einen Blick auf unseren
Spielplatz und sehen, wie wir
angeben können , dass eine Funktion einige Daten zurückgeben
soll. Um diese Funktion zu ändern, um anzuzeigen, dass sie einige Daten
zurückgibt. Wir gehen hier direkt nach
der abgerundeten Klammer
für den Umfang
und kurz vor Beginn
der geschweiften Klammern hoch der abgerundeten Klammer
für den Umfang . Hier schreiben wir einen Bindestrich gefolgt von einem
Größeren als Symbol, das
eine Art Pfeilähnliche Ausgabe ergibt. Und dann geben wir den
Datentyp der Ausgabe an. Was ich also tun werde,
ist, dass ich
die Summe von a und B ausgeben werde,
anstatt sie
auf die Konsole auszudrucken. Also lösche ich diese Zeile. Und dann gebe ich
einen int aus. Dort gebe ich an, dass
nach diesem Bindestrich
größer als das Symbol ist. Jetzt können Sie sehen, dass Xcode jetzt einige Fehler
auslöst, da nur angeben , dass Ihre Funktion einen int
zurückgibt, Sie nicht nur angeben
, dass Ihre Funktion einen int
zurückgibt, sondern auch
einen int innerhalb der
Codeanweisungen zurückgeben müssen . Als letzte Zeile unseres Codes können
wir das Schlüsselwort return verwenden,
was bedeutet, dass dies
die Daten sind, die
wir von der Funktion zurückgeben werden. Und dann geben wir die Daten an
, die wir zurückgeben möchten. Also werde ich ein Plus b zurückgeben. Und alles ist
nun, denken Sie daran, dass
unabhängig vom Datentyp, den Sie hier in der
Funktionsdeklaration
angeben
, der Datentyp ist
, den Sie haben um zurückzukehren, wenn es eine Nichtübereinstimmung gibt. Zum Beispiel, wenn ich angegeben habe , dass diese Funktion einen int
zurückgibt, gebe ich eine Zeichenfolge
zurück. Wie ein Stück Text. Du wirst Xcode sehen. Beschweren Sie sich
auch darüber
, denn das ist falsch. Also werden wir
ein Plus b zurückgeben und wir
werden einen int zurückgeben. Warum führen wir
unsere Funktion jetzt nicht aus und
sehen, was passiert. Nichts passiert. Nun,
was ist los? Ich gebe ein Plus b zurück. Also hier ist was passiert. Das Aufrufen dieser Funktion
gibt diese Daten zurück, aber ich muss diese Daten irgendwie referenzieren und verfolgen
, oder? Und dafür ist eine
Variable da. Also werde ich hier oben
eine Variable deklarieren, var. Lassen Sie uns tatsächlich konstant erklären, da ich das nicht ändern werde
,
lassen Sie meine Summe dem
Ergebnis dieser Funktion entsprechen. So können Sie
diese Codeausweisungsrate verstehen, wir deklarieren eine
Konstante, die meine Summe genannt wird. Und dann
rufen wir diese Funktion in derselben Zeile
auf, die 25
zurückgibt, und wir
weisen meiner Summe 25 zu. Jetzt kann ich meine Summe ausdrucken. Und lasst uns noch einmal prüfen
, ob wir die Ausgabe bekommen. Da sind wir los.
Bevor wir weitermachen, zwei sehr
wichtige
Dinge möchte ich zwei sehr
wichtige
Dinge erwähnen. Diese Return-Anweisung beendet also tatsächlich die Ausführung
dieser Funktion. Sobald diese
return-Anweisung ausgeführt wurde, kehrt die
Ausführung aus
dieser Funktion zurück. Also alle Codeanweisungen,
die Sie hier niedergelegt haben, sagen
wir, ich habe genau dort
ein b zurückgegeben, und ich habe hier ein
Plus B gedruckt. Diese Print-Anweisung
wird nicht
C-Code ausgeführt , nachdem die Rückkehr niemals ausgeführt
wird. Das ist also nur wichtig,
um zu bedenken , dass beim Schreiben Return und der Ausführung
dieser Codezeile die Ausführung stoppt und
diese Funktion verlässt. Eine andere Sache, die ich
erwähnen wollte, ist dieser Rückgabetyp. Früher, als ich Ihnen sagte , dass das Deklarieren einer Funktion keinen solchen
Rückgabetyp hatte. Nun, das hat es tatsächlich getan. Es war nur so, dass der
Rückgabetyp ungültig war. Und nichtig bedeutet nichts. Lassen Sie mich also, lassen Sie mich
eine grundlegende Demonstration machen , lassen Sie mich hier unten einfach eine andere
Funktion deklarieren. Ich nenne das einfach ein
Mikrofon, um es zu sehen dann habe ich dir gesagt, dass dies
eine grundlegende Deklaration
einer Funktion war , aber eigentlich war das eine Kurzschrift. Die vollständige Deklaration hat
tatsächlich einen Rückgabetyp wie diese, wenn Sie nichts zurückgeben
werden. Aber es ist nur so, dass
Sie, wenn
Sie nichts zurückgeben, nicht wirklich den Rückgabetyp der Void
angeben müssen . Also dachte ich einfach,
ich hätte das erwähnt. Sie wissen also, was dieses
void-Schlüsselwort bedeutet. Wenn Sie also eine Funktion sehen , die einen Rückgabetyp von ungültig hat, wissen
Sie, dass dies
im Grunde bedeutet , dass sie nichts
zurückgibt. Alles klar, also lasst uns ein bisschen
zurücksetzen. Es wird langsam
etwas chaotisch. Also lasst uns
alles außer dem löschen, außer unserer Funktion genau hier. Jetzt möchte ich
Ihnen zeigen, wie wir mehrere Parameter
übergeben können . Anstatt also hier
zu spezifizieren, setzen
wir B hier in die
Parameterliste ein und
lassen Sie es stattdessen übergeben. Okay, also lasst mich diese
Codezeile
löschen ,
damit wir B von erscheint. Nun, wie fügen wir diesem einen weiteren
Parameter hinzu? Was Sie tun, ist
einfach Komma zu setzen und
dann einen anderen Parameter
für Ihre Funktion zu deklarieren . Einfach, oder? Wir werden diesen nennen, gefolgt von
einem Doppelpunkt, und dann der Datentyp von B, das wird
eine weitere ganze Zahl sein. In Ordnung, schauen wir uns
jetzt an, wie wir diese Funktion
mit zwei Parametern aufrufen. Mein Func, das siehst du hier. Nein, Sie geben nur an, oh, eine schnelle Sache ist, wenn
Sie Funktionen aufrufen, eine einfache Möglichkeit,
die Parameter in der
Liste auszufüllen , indem Sie die Tabulatortaste drücken. Das bringt Sie nur zum nächsten Parameter
,
den Sie ausfüllen müssen. Also lege ich 2 und 3 ein. Lassen Sie uns diesen ganzen Code ausführen und wir erhalten ein Ergebnis.
Wir bekommen kein Ergebnis. Denken Sie daran, dass ich
meine Codezeile gelöscht habe. Warum
drucken wir das Ergebnis nicht einfach aus,
anstatt es diesmal einer
Variablen zuzuweisen. Also gehe ich
weiter und
übergebe diesen Funktionsaufruf
direkt an meine Print-Anweisung. Das wird
die Ausgabe meiner Funktion ausdrucken. Lass uns den Code
ausführen und wir bekommen 5. Jetzt können Sie offensichtlich
mehr als zwei Parameter haben. Setzen Sie einfach ein Komma zwischen jeden Parameter in Ihrer Funktion ein. Und eine andere
Sache, die ich
erwähnen wollte , die mit Parametern ziemlich
cool
ist, ist, dass Sie einen
Standardwert für einen Parameter angeben können. Für Parameter b könnte
ich dies beispielsweise zu
optionalen Eingabedaten machen, könnte
ich dies beispielsweise zu
optionalen Eingabedaten machen indem ich einen
Standardwert für diesen Parameter angebe. Wenn ich das tue, bedeutet das, dass beim Aufruf dieser
Funktion Weitergabe von Daten für Parameter
b optional sein wird. Werfen wir einen
Blick darauf, wie das funktioniert. Nachdem ich den
Datentyp für meinen B-Parameter angegeben
habe, kann ich ein Gleichheitszeichen setzen und
dann kann ich ihm einen Wert geben. Nehmen wir an, 0 ist der
Standardwert. Wenn b nicht übergeben
wird, wird B einfach 0 sein. Lassen Sie uns nun
meinen Funktionsaufruf löschen
und versuchen, ihn erneut
aufzurufen und schauen uns an, was uns das
Autocomplete-Menü zeigt. Hier sehen Sie, dass es jetzt
zwei verschiedene Formen
meines Funktionsaufrufs gibt , eine mit den Parametern a und b. Also gebe ich
beide Daten weiter. Und man
übergibt einfach einen Parameter a. Wenn ich das tue, wird v
einfach 0 sein. Aber wenn ich beide übergebe, sagen
wir mal, ich gebe wieder 23, dann wird B
drei statt 0 sein. Das ist also eine Möglichkeit,
Ihre Perimeter optional zu machen. Jetzt möchte ich
über Argument-Labels sprechen. Wie Sie sich vorstellen können, desto
mehr Parameter wir haben, desto
verwirrender werden diese Funktionsaufrufe in Bezug auf diese
Funktionsaufrufe sein, insbesondere wenn es um
Parameternamen wie a und B
geht. manchmal sind a
und B im Kontext
des Codes
innerhalb der Funktion sinnvoll. Aber für die Farbe
der Funktion, a und B. Sie bedeuten nichts. Es gibt also eine spezielle Funktion
namens Argumentbeschriftungen. Und lass mich dir zeigen,
wie das aussieht. Also werde ich gleich hier eine
neue Funktion deklarieren. Ich nenne
es auch meine Funktion. Und ich werde es
eigentlich tun, weißt du was? Ich kopiere einfach diese Funktion und mache eine
Kopie davon und zeige Ihnen,
wie Argumentbeschriftungen sie ändern. Ein Argument mit der Bezeichnung geht
also vor jeden Parameter. Jeder Parameter kann also eine
eigene Argumentbezeichnung haben, und Sie
setzen im Wesentlichen nur einen Namen vor
diesen Parameter. Ich nenne
diesen ersten Parameter. Ich gebe ihm
ein Argumentlabel namens erste Nummer. Und für meinen, für den
zweiten Parameter, gebe
ich ihm ein Argument Bezeichnung zweite Nummer. Das ist also buchstäblich alles was es ist. Eine Argumentbezeichnung
ist ein Name vor dem Parameternamen,
der durch ein
Leerzeichen getrennt ist. Werfen wir einen Blick darauf, wie
sich dies auf den Funktionsaufruf auswirkt. Wenn ich meine Funktion eintippe, siehst du hier, dass ich immer noch diese ersten beiden
habe, a und B, und das ist von
der ersten Funktion hier oben. Aber schau hier unten, ich habe erste Nummer und erste
Nummer und zweite Nummer. Und das entspricht meiner
zweiten Funktion genau hier, denn die zweite Zahl ist
immer noch optional, oder? Weil ich diesen
Standardwert dort habe. Also wenn ich das nenne. Mein Funktionsaufruf wird diese myfunc erste Nummer
1, zweite Nummer 3. Intern
innerhalb dieser Funktion referenziere
ich diese
Parameter jedoch immer noch mit a und b. Also Argumentbeschriftungen dort. Eine Möglichkeit für Sie, die Benennung für
einen Funktionsaufruf gegenüber
der Referenzierung
im Code zu
unterscheiden einen Funktionsaufruf gegenüber . Wenn Sie
die Argumentbeschriftungen weglassen,
wie wir es hier oben getan
haben, werden die
Parameternamen
sowohl für den Funktionsaufruf auch für die Referenzierung dieser Parameter innerhalb
von die Funktion. Hoffentlich merkt man hier
den Unterschied. Ein cooler Trick, den Sie mit
Argumentbeschriftungen machen können, ist, wenn Sie überhaupt
keinen Text
in Ihrem Funktionsaufruf anzeigen möchten, können
Sie einen Unterstrich
als Argumentbezeichnung verwenden. Wenn Sie dies tun, sehen
wir uns an, was mit Ihrem Funktionsaufruf passiert
. Also meine Funktion, Sie können
hier sehen , dass diese beiden dem entsprechen,
was ich genau hier gemacht habe, indem Sie Unterstriche für
die Argumentbeschriftungen verwenden. Wenn Sie also einen Unterstrich
für die Argumentbezeichnung verwenden, werden
die Funktionsaufrufe
einfach myfunc. Und dann das erste
Datenstück, Komma, zweite Daten. Es gibt keine Parameternamen, es gibt überhaupt keine Argumentbeschriftungen in
Ihrem Funktionsaufruf. Das macht die Dinge also
wirklich prägnant und sehr
ordentlich und ordentlich, aber es macht
die Dinge auch verwirrender wenn nicht klar ist,
welche Parameter vier sein
sollen. Es gibt also viel
Vielseitigkeit hier. Meine persönliche Vorliebe ist es
einfach, es zuerst so zu machen. Und normalerweise gebe ich überhaupt
keine Argumentbeschriftungen an. Und ich benutze einfach die
Perimeter-Namen. Okay, das Letzte, was ich versprochen habe,
bevor wir mit
Funktionen enden , ist, dass ich nicht
weiß, ob du es bemerkt hast, aber wir haben hier zwei
verschiedene Funktionen deklariert, beide mit demselben
Funktionsnamen. Wir können das nicht mit
Variablen machen, oder? Wenn Sie versuchen, die Variable
a zu deklarieren und
dann erneut a zu variable, erhalten Sie bei der zweiten einen
Fehler. Und Xcode wird sich beschweren, Sie können die Variable 8 nicht einlösen. Für Funktionen. Die Dinge sind ein
bisschen anders. Funktionen haben
eine sogenannte Funktionssignatur. Und das besteht aus dem Funktionsnamen,
der Parameterauflistung und dann
gefolgt vom Rückgabetyp. Geben wir also myfunc ein
und schauen uns an, was uns das
Autocomplete-Menü bietet. Wie Sie sehen können,
haben alle vier
dieser Variationen denselben
Funktionsnamen namens myfunc. Aber weil die
Parameterwerte, Argumentbeschriftungen, unterschiedlich
sind kann
Xcode erkennen und wissen, welche Funktion wir aufrufen
möchten, oder? Wenn ich das
also nenne und keine Parameternamen
oder Argumentbeschriftungen
angeben. Es weiß, dass ich versuche,
diese zweite hier aufzurufen diese zweite hier weil dieser Methodenaufruf,
diesen Funktionsaufruf. Ich meine, es
stimmt nicht mit dem ersten überein. Während wenn ich meine Funktion mache und die
Parameterbeschriftungen a und b angebe, dann weiß es definitiv,
dass ich versuche,
den ersten aufzurufen , weil dieser Aufruf, diese Parameterliste
hier übereinstimmt. Okay, also habe ich Ihnen versprochen, dass wir etwas tiefer gegangen sind, als Sie wahrscheinlich wissen müssen, indem wir Ihnen all
diese Optionen und Möglichkeiten zeigen diese Optionen und Möglichkeiten ,
wie Funktionen flexibel sein können, wenn wir mehr zusammen codieren, Sie werden sehen, dass ich nur
grundlegendere Funktionen verwende, aber zumindest zahlen
Sie jetzt viel mehr und ich bin sicher, dass Sie
schätzen können , wie leistungsstark
diese Funktionen sind. Okay, diese Lektion war
ziemlich actionreich. Lassen Sie uns eine Zusammenfassung machen, bevor
wir die Lektion abschließen. Zunächst haben Sie gelernt, grundlegende Funktionen zu deklarieren,
und dann
lernen Sie, Funktionen zu deklarieren , die
Eingabedaten als Parameter akzeptieren. Darüber hinaus
lernen Sie, wie Sie
eine Funktion mit
mehreren Parametern deklarieren . Und wieder, Funktionen,
wenn sie fast
so nützlich sind, wenn es keine Daten
ausgeben könnte, oder? Sie lernen, wie Sie
das mit Rückgabetypen und
dem Schlüsselwort return machen. Sie haben auch etwas über
Argument-Labels erfahren. Und schließlich haben Sie etwas
über Funktionssignaturen erfahren. Du machst große Fortschritte. Und in der nächsten Lektion zeige
ich Ihnen, wie Sie Ihre Funktionen
in zwei Strukturen
organisieren können. Also sehe ich dich dort.
9. 08: Schnelles Programmieren: Hallo und willkommen. Bisher haben Sie etwas
über Variablen und
Konstanten erfahren und wie sie
verwendet werden, um Daten zu verfolgen. Sie haben auch
über Funktionen zum
Organisieren und Gruppieren
von Codeanweisungen erfahren . Während dieser Lektion lernen
Sie kurz etwas über Strukturen oder Strukturen. Und dies sind die grundlegenden
Bausteine, um Ihre Daten
darzustellen oder etwas in Ihrer App darzustellen. Strukturen
bringen die Funktionen , die Variablen und Konstanten,
alles, was Sie
bisher in den letzten Lektionen gelernt haben, in einem ordentlichen kleinen Paket zusammen. Alles klar, lass uns eintauchen und
sehen, worum es geht. Lassen Sie uns jetzt eine kurze Zusammenfassung machen. Zuerst hattest du Mäntel, solche
Dinge. Und dann habe ich Ihnen gezeigt, wie Sie
Funktionen verwenden , um sie zu organisieren
und zu gruppieren. Jetzt
können Sie mit Strukturen Ihre Funktionen gruppieren. Sie können auch
Variablen und Konstanten haben, Daten
innerhalb Ihrer Struktur
verfolgen, jedoch außerhalb jeder Funktion. Und wir werden
etwas später in dieser Lektion darüber
sprechen . Werfen wir nun noch einmal einen Blick auf unser
View-Update-Lebenszyklusdiagramm. Für den View-Code, der ihre Benutzeroberfläche
darstellt, können Sie eine Struktur
erstellen Ihren Startbildschirm darstellt und der gesamte Anzeigecode für Ihren Startbildschirm
würde in diese Struktur fließen. Wenn Sie einen zweiten
Bildschirm in Ihrer App hatten, erstellen
Sie möglicherweise
eine andere Struktur für diesen zweiten Bildschirm. Und der gesamte View-Code für diese zweite Feder würde in diese Struktur
eingehen. In diesem Fall
stellt jede Struktur einen anderen
Bildschirm in Ihrer App dar. Gehen wir nun zum
Datenabrufteil dieses Diagramms über . Sie können eine Struktur erstellen
und sie als Datenmanager bezeichnen. Und Sie werden den
gesamten Code und die Funktionen im Zusammenhang mit dem Abrufen
und Verarbeiten der Daten in diese
Datenmanagerstruktur einfügen. In diesem Fall stellt die
Struktur kein Screening Ihrer App
dar, sondern stellt eine
entscheidende Komponente Ihrer App dar. Wie Sie sehen können, sind
Strukturen sehr flexibel und leicht und werden in Ihrer gesamten App verwendet. Gehen wir nun in einen
Xcode-Spielplatz und schauen uns an, wie wir unsere eigene Struktur
deklarieren können. Alles klar, also hier habe ich einen
brandneuen leeren Spielplatz. Werfen wir einen Blick darauf, wie wir unsere eigenen Strukturen
definieren können . Zuerst beginnen Sie mit
dem Schlüsselwort struct, gefolgt von einem Leerzeichen und dann dem Namen
Ihrer Struktur. Also nenne ich
das meine Struktur. Und dann stellst du ein
Leerzeichen ein und
öffnest eine Reihe geschweifter Klammern. In den geschweiften Klammern würden
Sie den gesamten Code in Ihre Struktur einfügen,
und das war's. Wir haben unsere
eigene Struktur erklärt. Bevor wir nun
weitermachen und einen
Blick darauf werfen , was sich in der Struktur befindet, möchte
ich auf
die Namenskonvention
der Struktur hinweisen . Beachten Sie, dass ich mit einem Großbuchstaben angefangen habe. Dies ist die Standardkonvention. Dies unterscheidet sich von dem
Kamelgehäuse, das wir
für die Variablen und Konstanten
und die Funktionsnamen verwendet haben . Diese begannen mit
einem Kleinbuchstaben, und jedes nachfolgende Wort begann mit einem Großbuchstaben. Während
es für Strukturen mit
einem Großbuchstaben beginnt und jedes nachfolgende Wort einen Großbuchstaben
hat. In Ordnung, jetzt, da Sie
über das Benennen von Strukturen Bescheid wissen, gehen
wir hinein und
schauen uns an, wie wir die Dinge
innerhalb der Struktur
organisieren. Normalerweise würden
wir an der Spitze
der Struktur , in den geschweiften Klammern hier
alle unsere Variablen und
Konstanten deklarieren die verwendet werden, um
Daten zu verfolgen , die mit der Struktur zusammenhängen
. Nun haben diese einen besonderen Namen, wie ich bereits erwähnt habe, und wir werden
später in dieser Lektion darauf eingehen. Nachdem Sie also
alle Variablen
und Konstanten zur Verfolgung von
Daten für diese Struktur deklariert haben, sind alle Funktionen,
die sich
auf die Struktur beziehen. Jetzt gibt es keine klar definierten Abschnitte
in einer Struktur. Weißt du, der ganze
Code
geht wirklich nur zwischen den
geschweiften Klammern. Aber normalerweise organisieren
Sie so alle verschiedenen Codeteile
in Ihrer Struktur. Oben also Variablen
und Konstanten und dann unten alle Funktionen. Wie Sie sehen können,
eignen sich
Strukturen hervorragend zum
Gruppieren von Funktionen, Variablen und Konstanten
sind für eine Sache verwandt. Strukturen
sollen jedoch normalerweise
etwas in Ihrer App im
View-Update-Lebenszyklusdiagramm darstellen etwas in Ihrer App im , das Sie zuvor gesehen Wir haben Beispiele für
eine Struktur gesehen , die verwendet wird, um
einen Bildschirm Ihrer App, sowie um
eine wichtige Komponente
Ihrer App wie diesen
Network Manager darzustellen eine wichtige Komponente . Warum machen wir also kein
anderes Beispiel, und ich zeige Ihnen eine Struktur , die
etwas konkreter ist. Lasst es uns nach etwas modellieren. Früher im
View-Update-Lebenszyklusdiagramm haben
Sie gesehen, dass wir Strukturen
verwenden können, um eine Ansicht in unserer App
darzustellen. Also lass uns damit gehen. Lass uns eine
hypothetische Chat-App haben. Und sagen wir,
diese Struktur repräsentiert meine Chat-Ansicht. Also ändere ich
den Namen meiner
Struktur in die Chat-Ansicht. Jetzt
habe ich unter Variablen
und Konstanten möglicherweise eine Variable, um die Nachricht zu
verfolgen,
wie die Chat-Nachricht, die
ich in das Chat-Feld eintippe. Also
rufe ich diese Nachricht an. Und die Art der
Daten, die dies sein
würde, wäre wahrscheinlich eine Zeichenfolge. Und ich werde
ihm eine leere Zeichenfolge zuweisen, nichts dazwischen,
nur zwei Anführungszeichen. Das ist also eine leere Zeichenfolge. Jetzt
könnte ich unter Funktionen
Codegruppen haben , die
verschiedene Aufgaben auf dem Bildschirm ausführen würden. Wenn der Benutzer beispielsweise auf die Schaltfläche „Chat senden“
tippt, würde
er möglicherweise auf die Schaltfläche „Chat senden“
tippt, einen Code ausführen um die
Chat-Nachricht an den Server zu senden. Also würde ich eine Funktion deklarieren. Das ist also Funk, gefolgt von, nennen
wir diesen Send-Chat
und zwei abgerundete Klammern. Und ich öffne
ein Paar geschweifte Klammern. Und hier drin würde ich
den Code eingeben, um eine Chat-Nachricht zu senden. Und dann hätte
ich zwischen
den Variablen und Konstanten und den Funktionen und Konstanten und den Funktionen den Anzeigecode für diesen Bildschirm und als den gesamten
Code für die Benutzeroberfläche. In dieser
Chat-View-Struktur haben
wir ein ordentliches kleines Paket, haben
wir ein ordentliches kleines Paket das den gesamten
Code für diesen einen Bildschirm
enthält. Vorhin habe ich erwähnt,
dass die Variablen und Konstanten, die Sie
oben in der Struktur deklarieren , einen anderen Namen
haben. Jetzt möchte ich
dir sagen, was das ist. Diese variable Deklaration
, dass ich hier oben habe Nachricht. Dies wird als Eigenschaft
der Chat-View-Struktur bezeichnet. Wenn ich zusätzliche variable
oder konstante Deklarationen hätte, würden
diese als
Eigenschaften des Chats bezeichnet. Strukturierst du
auch? Und hier unten haben
Funktionen tatsächlich auch einen anderen Namen. Eine Funktion innerhalb
einer Struktur wird als Methode
dieser Struktur
bezeichnet. Diese Chat-Funktion senden ist also eigentlich eine Methode
der Chat-Ansicht. Aktualisieren wir jetzt einfach
unsere Kommentare hier, damit wir hier oben die richtige Terminologie
anstelle von Variablen
und Konstanten verwenden . Ich benenne das um, gut nicht umbenannt,
aber tippe einfach
meinen Kommentar erneut ein und rufe
diese Eigenschaften auf. Und anstelle von Funktionen werden
diese
Methoden genannt , nur damit wir uns klar sind. Jetzt können
Eigenschaften und Methoden innerhalb einer Struktur
tatsächlich zusammenarbeiten, können
Eigenschaften und Methoden innerhalb einer Struktur
tatsächlich zusammenarbeiten um die Aufgaben
der Chat-Ansicht zu erfüllen. Werfen wir einen Blick auf einige
der besonderen Möglichkeiten, wie
sie zusammenarbeiten können. Werfen wir einen Blick auf
diese Chat-Methode senden. Wenn
wir zum Beispiel
den Code hier schreiben würden, um eine Chat-Nachricht zu
senden, wäre
es sicher praktisch,
wenn wir auf
die eigentliche Nachricht in dieser
Nachrichteneigenschaft zugreifen könnten , oder? Nun, das können wir tatsächlich. Wenn ich also so
etwas geschrieben habe, drucke und dann in
die Klammern gebe ich den Namen der Immobilie ein. Tatsächlich kann ich auf diese Daten zugreifen. Und der Grund dafür
ist, dass diese Eigenschaft
im Rahmen dieser Struktur deklariert wird. Der Umfang der
Struktur liegt also zwischen diesen
beiden geschweiften Klammern, im Wesentlichen den
öffnenden und schließenden geschweiften Klammern
der Struktur. Also jede der Methoden, die ich hier
deklariere, zum Beispiel, wenn ich eine andere deklariere, nennen
wir diese einen Delete-Chat. Weil diese beiden Methoden
ebenfalls im gleichen Umfang sind. Wissen Sie, es befindet sich
im Rahmen der Chat-Ansicht. Ich kann auf
die Unterkunft zugreifen. Die Eigenschaften, die Sie hier
angeben, sind alles
im gleichen Umfang
beurteilbar. Das schließt also alle Methoden ein,
die hier unten
deklariert sind. Jetzt muss ich sagen, dass jede Methode ihren
eigenen lokalen Bereich hat. Diese Send-Chat-Methode
hat hier einen Umfang. Und diese Delete-Chat-Methode hat ihren eigenen Bereich zwischen
diesen geschweiften Klammern. Wenn ich also eine Variable
in meiner Send-Chat-Methode deklariere, sagen
wir mal, var Präfix ist
gleich Chris, sagen wir. Und dann sagen wir, ich
benutze dieses Präfix und habe meiner Chat-Nachricht vorangestellt. Die gesamte Chat-Nachricht
wäre also , sagt Chris
und dann etwas. Vielleicht drucke ich das Präfix plus Nachricht, um diese
Art von Effekt zu erzielen. Und ich wollte das
Gleiche im Delete Chat machen. Wenn ich versuche, auf die
Präfixvariable zuzugreifen, tippe, drucke, Präfix plus Nachricht
hier unten in der
Delete Chat-Methode, wirst
du sehen, dass es sich
Xcode beschwert. Nssa kann das
Präfix im Bereich nicht finden , da diese Variable nicht im selben Bereich
deklariert ist. Es ist im Rahmen
des Sendechats deklariert. Wie würden wir das beheben? Nun, eine der Möglichkeiten, dies zu
tun, besteht darin,
diese Präfixvariable in
eine Eigenschaft umzuwandeln diese Präfixvariable in , die wir oben in unserer Struktur deklariert
haben. Weißt du, verschiebe es außerhalb
des Bereichs von Sen-Chat und stelle es stattdessen hier in den Umfang der
Chat-Ansicht. Jetzt, da ich
mein Präfix als Eigenschaft
der Chat-Ansicht deklariere , können
Sie sehen, dass
die Fehler verschwinden. Und ich kann auf diese
Präfix-Eigenschaft zugreifen. Beide senden einen Chat und
löschen Chat-Methoden. Jetzt möchte ich über
eine andere Art von Immobilie sprechen. Lassen Sie uns zunächst definieren, was
diese Eigenschaften hier oben sind. Diese werden als
gespeicherte Eigenschaften bezeichnet. Und der
Grund ist, dass wenn Sie auf diese Eigenschaften zugreifen und sie mit
ihrem Eigennamen referenzieren, nur
den Wert zurückgibt, den es gespeichert hat. Es gibt eine andere
Art von Eigenschaft ,
bei der Sie beim Zugriff berechnen oder
berechnen müssen den Wert berechnen oder
berechnen müssen, bevor
er an Sie zurückgibt. Werfen wir einen
Blick darauf, wie diese zweite neue Art von
Immobilie aussieht. Lassen Sie mich also damit beginnen diese Präfixeigenschaft
hier oben zu löschen und diese zu löschen. Und dann deklariere ich
diese neue Art von Immobilien. Es fängt genau
wie ein normales an. Verwenden Sie VAR-Leerzeichen und dann den
Namen der berechneten Eigenschaft. Ich nenne es
Nachricht mit Präfix, gefolgt vom Namen. Anstatt
ihm einige Daten zuzuweisen, öffnen
Sie eine
Reihe geschweifter Klammern. Und hier können Sie den
Berechnungscode eingeben, um den Wert zu berechnen, den Sie
zurückgeben werden , wenn diese
Eigenschaft aufgerufen wird. Eine Sache jedoch, da der Wert nicht
sofort bekannt ist, kann
Xcode nicht ableiten,
was der Datentyp ist. Sie müssen also tatsächlich den Datentyp
nach dem berechneten
Eigenschaftsnamen
angeben . Nach einer Nachricht mit Präfix werde
ich einen Doppelpunkt setzen und Zeichenfolge einsetzen,
da dies
der Werttyp ist , den diese
Eigenschaft zurückgeben wird. Dies unterscheidet sich von dieser
gespeicherten Eigenschaft hier oben Nachricht, in der ich tatsächlich die Kurzschrift
verwenden und den Datentyp
löschen kann . Es ist also nur var
message gleich string. Und ich kann das tun, weil ich dieser Eigenschaft
sofort einen
Wert zuweise. Xcode kann sich also
diesen Wert ansehen und bestimmen und ableiten, wie der Datentyp für diese
Eigenschaft sein soll. Bei einer berechneten Eigenschaft muss
ich den Datentyp explizit
angeben. Okay, also für meine berechnete
Eigenschaftsnachricht mit Präfix, schauen wir uns den Code innerhalb der geschweiften Klammern an. Hier verwende ich
das Schlüsselwort return, genau wie bei Funktionen, oder? Ich komme zurück. Chris sagt, das ist also
eine String plus Nachricht. In meiner Chat-Methode kann
ich jetzt, anstatt
Präfix plus Nachricht zu drucken, anstatt
Präfix plus Nachricht zu drucken, einfach
eine Nachricht mit Präfix zurückgeben. Das Gleiche für den Delete-Chat. Anstelle von Präfix plus Nachricht gebe
ich
eine Nachricht mit Präfix zurück. Jedes Mal, wenn auf diese
Eigenschaft zugegriffen
wird, wird
der Code in
diesen geschweiften Klammern ausgeführt und diesen
als Wert für diese Eigenschaft zurückgegeben als Wert für diese Eigenschaft und muss sie berechnen. Deshalb heißt es
eine berechnete Eigenschaft. Jetzt mit Computereigenschaften gibt es auch eine Verknüpfung. Wenn hier nur eine
Codezeile vorhanden ist, brauche ich
das Schlüsselwort return nicht da Xcode davon ausgehen kann, dass diese einzelne
Codezeile
die Daten ausgibt , die ich
für meinen Computer zurückgeben möchte eigentum. Also kann ich das Schlüsselwort return einfach
löschen. Wenn ich jedoch
mehrere Codezeilen habe, würde ich
dieses Return-Schlüsselwort definitiv benötigen ,
da Xcode nicht weiß , welche Codezeile der zurückgegebene Wert
sein soll . Wenn ich zum Beispiel innerhalb
meiner Computereigenschaft sage, wenn ich sage, dass Präfix gleich ist, sagt
Chris, und dann
habe ich hier unten Präfix plus Nachricht. Es wird nicht wissen, welche Codeanweisung den Wert
zurückgibt. Also muss ich das Schlüsselwort
return tatsächlich so verwenden. Und das wird gut werden. Was berechnete
Eigenschaften angeht, gibt es definitiv mehr, worüber
wir sprechen können, aber das wird vorerst ausreichen. In späteren Kapiteln
dieses Kurses. Wir werden auf jeden Fall wieder
berechnete Immobilien durchgehen. In Ordnung, lassen Sie uns eine kurze Zusammenfassung
machen bevor wir diese Lektion abschließen.
Sie haben gelernt, eine grundlegende Struktur zu deklarieren. Sie haben über Eigenschaften und Methoden in der Struktur erfahren, etwas über den Umfang erfahren
und auch mehr über
berechnete Eigenschaften erfahren. Jetzt weiß ich, dass der schwierige Teil darin besteht sich mit diesen Konzepten auseinanderzusetzen. Wenn wir weiter zusammenarbeiten, werden
Sie sehen, wie diese
Konzepte in die Praxis umgesetzt werden. Ich möchte nur
eins sagen, bevor wir enden. Du hast es geschafft. Wenn Sie ganz neu darin sind,
diese drei Lektionen zu programmieren , wo
die bewusstseinsbeugenden Lektionen sind. In der nächsten Lektion zeige
ich Ihnen, wie sich diese Konzepte auf
Ihr eigentliches Xcode-Projekt beziehen. Alles klar, wir sehen uns dort.
10. 09: Swift Programmieren: Hallo und willkommen. Sie haben also gelernt, dass viele Swift in den letzten Lektionen mit Variablen, Konstanten
und Datentypen begonnen haben. Dann hast du etwas
über Funktionen gelernt. Und dann lernen Sie Strukturen
kennen denen Sie
all diese Dinge
zusammenfassen können , um etwas in Ihrer App darzustellen oder zu
modellieren. Jetzt wird diese Lektion das letzte Puzzleteil
sein. sage nicht, dass du
ein schneller Meister sein wirst oder so. Am Ende dieser Lektion werden
Sie jedoch sehen, wie alle
Konzepte und der Code
in einer schnellen UI-App
zusammenpassen und zusammenarbeiten. Alles klar, mit dem gesagt,
lasst uns gleich eintauchen. Alles klar, also fangen wir
mit einem leeren Spielplatz an. Erinnern Sie sich damals,
als Sie etwas über
Funktionen erfahren haben und ich Ihnen
beigebracht habe, wie
Sie eine Funktion deklarieren können,
indem Sie das Schlüsselwort func gefolgt vom Funktionsnamen verwenden. Nehmen wir an, meine Funktion
gefolgt von einer Reihe von Klammern und dann einer
Reihe geschweifter Klammern. Und innerhalb der
geschweiften Klammern hätten
wir den Code
für die Funktion. Aber das ist nur eine
Funktionsdeklaration , dass kein Code ausgeführt wird,
nichts passiert. Erst wenn wir
die Funktion aufrufen, wird
der Code in dieser
Funktion ausgeführt, richtig? Also würde ich die Funktion aufrufen, die meine Funktion
und dann die Klammern
sagt . Wenn ich meinen Spielplatz
jetzt betreibe, kannst du sehen , dass er Hello
in die Konsole ausgibt. Strukturen sind also auch
so. Wenn wir eine
Struktur mit
dem Schlüsselwort struct deklarieren ,
gefolgt vom Strukturnamen. Sagen wir also meine Struktur, gefolgt von einer Reihe
geschweifter Klammern. Und dann legen wir den Code
in diese Struktur ein. Lassen Sie mich meine Funktion hierher verschieben und erklären wir eine
Eigenschaft hier oben,
var message ist gleich hallo. Und dann drucken wir meine Eigenschaftsnachricht
innerhalb meiner Funktion aus. Dies ist nur eine
Deklaration einer Struktur. Es macht eigentlich nichts. Stellen Sie sich das wie eine
Blaupause für ein Gebäude vor. Damit wir diese Struktur
nutzen können, müssen
wir sie zum Leben erwecken. Wir müssen eine sogenannte
Instanz der Struktur erstellen . Sie können sich vorstellen, als würde diese Blaupause für das Bauen
in ein echtes Gebäude verwandeln. Wie erstellen wir also eine Instanz dieser Struktur? Nun, das ist einfach. Sie schreiben einfach den
Strukturnamen gefolgt von einem Paar
solcher Klammern. Fall, dass Sie
immer noch unscharf über das Konzept der Erstellung einer
Instanz einer Struktur sind. Lassen Sie mich Ihnen ein paar
verschiedene Analogien geben, die
Ihnen helfen ,
dieses Konzept zu verstehen. Manche Leute finden es
einfacher, wenn ich sage , dass die Deklaration einer Struktur oder der Deklaration dieser Struktur wie eine Blaupause für
ein Auto oder einen
Architekturplan für ein Haus
ist . Mit dieser Blaupause oder mit
diesem Architekturplan kann
ich Autos erstellen und
Häuser erstellen, und das sind die
eigentlichen Objekte. Während der Blueprint oder der Architekturplan
eher einer Vorlage ähnelt. Es beschreibt einfach
, wie das Ding funktionieren wird,
sobald man es zum Leben erweckt hat. Das
passiert also genau hier. Dies ist eine
Deklaration einer Struktur. Es beschreibt alle seine
Eigenschaften und Funktionen. Weißt du, die Dinge
, die es tun kann. Und dann können wir es erst verwenden, bis
wir es zum Leben erwecken
, indem wir eine Instanz davon
schaffen. Jetzt, da wir eine Instanz davon
erstellt haben, lasst uns untersuchen, was
wir damit machen können. Zunächst
müssen wir
diese Instanz im Auge behalten, da sie als Daten
angesehen wird, wir müssen sie im Auge behalten und eine Möglichkeit
haben, darauf zu verweisen. Erstellen wir also eine Variable namens Ich nenne
sie einfach aus Gründen der Einfachheit willen. Und ich werde
diese neue Instanz
meiner Variablen a zuweisen . Hey, warte mal. Wenn es sich bei dieser Instanz um
ein Datenelement handelt, wie lautet
dann
der Datentyp dieses Datenbestandes? Und welchen Datentyp hat
diese Variable? Nun, der Datentyp ist der Name Ihrer
Struktur. Das stimmt. Also kann ich
meine Variablendeklaration tatsächlich
von var a,
var a colon, meiner Struktur ändern meine Variablendeklaration tatsächlich
von var a, . Ja, Ihre Struktur
ist ein eigener Datentyp. Diese Instanz
, die Sie erstellt haben, der Datentyp davon
ist meine Struktur. Jetzt hat diese kleine Instanz Superkräfte, weil wir es so
entworfen haben. Es kann Daten in
seiner Nachrichteneigenschaft enthalten, und es kann
diese Nachricht mit der
myfunction -Methode ausgeben . Wie können wir also diese Dinge
dieser
Instanz zugreifen? Nun, da kommt die
Punktnotation ins Spiel. Werfen wir einen Blick darauf,
was Punktnotation ist. Verweisen wir also auf
die Variable a, gefolgt von einem Punkt oder einer Periode. Und wie Sie
im Autocomplete-Menü sehen können, können
Sie eine Nachricht auswählen, die
auf die Eigenschaft zugreift, oder Sie können meine Funktion auswählen, die
den Code in dieser Methode ausführt. Mit der Punktnotation können
Sie also auf die Eigenschaften
und Methoden
dieser Instanz zugreifen . Probieren wir das mal aus. Zunächst werde ich der Eigenschaft dieser Instanz etwas
zuweisen. Ich werde zuweisen, sagen
wir Hallo. Und dann drucke ich aus. A.me, nur um Ihnen zu zeigen, dass ich tatsächlich auf diese Eigenschaft zugreifen
kann
und ich kann sie ausdrucken. Als Nächstes. Anstatt
diese Print-Anweisung hier zu verwenden, rufe
ich einfach die
Methode dieser Instanz auf. Ich rufe meine Funktion auf. Und ich führe
diesen Code noch einmal aus. Und wir werden immer noch high
, weil der Code in dieser Methode tatsächlich nur die Eigenschaft
ausdruckt. Jetzt sind diese kleinen Instanzen ganz
der Actionheld, nicht wahr? Es kann all die Dinge tun, für
die wir es entworfen haben. Da diese
Strukturdeklaration wie ein Blueprint oder
ein Architekturplan
ist, bedeutet
das, dass wir so
viele Instanzen erstellen können , wie wir möchten. Lassen Sie uns also eine zweite Instanz
erstellen. Dieses Mal
deklariere ich eine andere Variable,
var, um eine andere
Instanz meiner Struktur zu speichern. Nun ist es wichtig
zu beachten, dass es sich völlig
unabhängige Instanzen
handelt. Zurück zur
Auto-Blaupause ist
es, als hätte die Autofabrik
zwei Autos aus
derselben Blaupause hergestellt . Diese beiden Autos werden
wie zwei verschiedene Autos behandelt. Das Gleiche hier. Ich habe gerade zwei
Instanzen meiner Struktur erstellt. Wenn ich zum Beispiel
eine Nachricht „hoch“ zuweise,
drucke ich
Perle auf Nachricht aus
oder lasse mich etwas anderes zuweisen,
um zu sein drucke ich
Perle auf Nachricht aus
oder lasse mich etwas anderes zuweisen, oder lasse mich etwas anderes zuweisen . Message und
drucke das aus. Sie werden sehen, dass für einen Punkt
myfunction, der diese Methode aufruft, hoch ausgegeben
wird. Und wenn ich b.me ausdrucke, gibt
es die Welt an die Konsole aus. Sie können also sehen, dass jede
Instanz ihre eigenen Werte innerhalb
der Nachrichteneigenschaft verfolgt . Jetzt wissen Sie, dass
Sie
eine Instanz einer Struktur
erstellen müssen , um sie verwenden zu können. Werfen wir einen Blick darauf, wie Instanzen von Strukturen zusammenarbeiten
können. Um nun ein früheres Beispiel
aus der vorherigen Lektion zu verwenden, nehme an, ich habe eine
Chat-Ansicht in meiner App, also habe ich eine Struktur
zur Darstellung dieser Ansicht deklariert. Es gruppiert alle
Eigenschaften, den View-Code und
die Methoden, die mit meiner Chat-Ansicht
zusammenhängen. Angenommen, ich habe eine andere Struktur, um den gesamten
Netzwerkcode
oder den Datenbankcode
zusammenzufassen Netzwerkcode
oder den Datenbankcode ,
um die Daten zu speichern. Erklären wir
so etwas hier. Also struct, Nennen wir
das das Netzwerk oder nennen wir es den
Datenbankmanager. Okay? Und nehme an, ich
hatte eine Methode hier drin. Also func, nennen wir
das Daten speichern. Und der Eingabeparameter dafür sind die Daten
, die wir speichern möchten. Nehmen wir an, ich deklariere einen einzelnen Parameter namens data
und mache ihn zu einem String-Typ, und er gibt einen Wert zurück Er gibt
einen booleschen Wert zurück,
true oder false, der angibt, ob dies der Fall war
erfolgreich oder nicht. Richtig für einen erfolgreichen,
falsch für erfolglos. Und im wirklichen Leben wäre
es nicht möglich, wäre
es nicht möglich sofort ein Ergebnis wie dieses zurückzugeben, da
Sie abhängig Netzwerkbedingungen
und anderen Faktoren von den
Netzwerkbedingungen
und anderen Faktoren nicht warten
möchten
die zu speichernden Daten. Sie möchten also nicht, dass die
Hinrichtung beendet wird. Aber aus Gründen der Einfachheit sagen
wir einfach, dass wir das Ergebnis sofort
zurückgeben können. Wenn Sie dies hören, speichert
dieser Code die Daten und
gibt ein boolesches Ergebnis zurück. In diesem Beispiel werde
ich einfach wahr zurückgeben. Also werde ich einfach einen fest codierten Wert
drehen weil ich diese Methode nicht
implementieren werde. Die Hauptsache, die ich
Ihnen zeigen möchte, ist, wie die Chat-Ansicht den
Datenbankmanager verwendet, um die Nachricht zu speichern. Zurück in der Chat-Ansicht in diesem
Beispiel eine Chat-Methode senden könnte ich
in diesem
Beispiel eine Chat-Methode senden,
eine Instanz des
Datenbankmanagers erstellen . Nehmen wir an, var d b
entspricht dem Datenbankmanager, gefolgt von einer Reihe
von Klammern. Und einfach so habe ich
eine neue Instanz dieses
Datenbankmanagers erstellt . Und wenn ich jetzt meine Nachricht speichern
wollte, würde
ich sie als
gespeicherte Datenmethode bezeichnen. Also hat db dot Daten gespeichert und ich würde meine Nachrichteneigenschaft
als Eingabedaten
übergeben. Ich werde weitermachen
und eine Nachricht weitergeben. Aber denken Sie daran, wenn ich
diese Methode für gespeicherte Daten aufrufe, gibt
sie einen booleschen
Wert zurück, damit ich ,
ob das Speichern erfolgreich
war oder nicht. Also kann ich die Ausgabe
dieser Methode einer Konstante zuweisen. Ich nenne das
als Erfolg, oder? Also werde ich
diese boolesche Ausgabe
einer neuen Konstante zuweisen , die als Erfolg
bezeichnet wird. Oder vielleicht
nenne ich es einfach erfolgreich. Und dann kann
ich hier unten etwas Code schreiben. Prüfen Sie den erfolgreichen
booleschen Wert. Wenn es nicht erfolgreich ist. Zeigen Sie dem Benutzer eine Warnung an. Jetzt lernen
Sie in zukünftigen Lektionen, wie Sie diese Aussagen
basierend auf Bedingungen schreiben. Aber im Moment wird dieser
Kommentar ausreichen müssen. Das Hauptessen zum Mitnehmen. In diesem Beispiel, das ich Ihnen
zeige, ist die Tatsache, dass innerhalb der Chat-Chat-Methode
der Chat-View-Struktur andere
Strukturmethoden verwendet, es
innerhalb der Chat-Chat-Methode
der Chat-View-Struktur andere
Strukturmethoden verwendet,
indem eine Instanz davon erstellt wird . So können Instanzen
von Strukturen zusammenarbeiten, um
Ihre App zum Funktionieren zu bringen. Und das ist im Wesentlichen
alles, was deine App ist. Es sind verschiedene
Instanzen von Strukturen zusammenarbeiten, um die Ansichten
zu
erzeugen, die Benutzereingaben zu verarbeiten
und die Logik auszuführen. Jetzt möchte ich für eine Sekunde über
Zugriffsebenen sprechen. Angenommen, zum Beispiel hatte
ich
in meinem Datenbankmanager
eine Art von Informationen, die ich als Eigenschaft verfolgt habe , die nur der
Datenbankmanager benötigte. Es wäre für keine andere Struktur relevant
. Vielleicht ist es ein Servername
oder so ähnlich. Lassen Sie mich also einfach
eine neue Eigenschaft in meinen
Datenbankmanager schreiben , der Servername genannt wird. Und ich werde ihm eine
Zeichenfolge namens Server eins zuweisen. Jetzt wäre diese Eigenschaft für keine andere Struktur
interessant, aber wie Sie in
der Sende-Chat-Methode sehen können, habe
ich diese Instanz
des Datenbankmanagers deklariert. Wenn ich einen DB-Punkt
mit Punktnotation schreibe, kann
ich auf diese Eigenschaft des
Servernamens zugreifen. Und manchmal
möchten Sie diese Dinge vielleicht nicht entlarven. Was Sie also tun können, ist, dass Sie eine Zugriffsebene
vor dieser Eigenschaft
angeben können . Vor dem
var-Servernamen, dieser Eigenschaft, kann
ich das Schlüsselwort privat setzen, also wird jetzt ein privater
Var-Servername. Und auf diese Weise bleibt diese
Eigenschaft
nur im Rahmen
des Datenbankmanagers zugänglich . Wie Sie sehen können, kann
ich immer noch auf den
Servernamen innerhalb
der gespeicherten Datenmethode zugreifen . Okay, es ist im gleichen Umfang, aber in der Center-Chat-Methode
der Chat-Ansicht hier unten. Wenn ich für meine Instanz
erneut Punktnotation verwende, können
Sie sehen, dass ich nicht auf dieses
Eigenschaftsziel zugreifen kann oder es nicht sehen kann. Und außerdem können
Sie das Gleiche
mit Funktionen
tun. Also kann ich privat
vor das Func-Keyword stellen. Und jetzt können Sie sehen
, dass sich Xcode beschwert. Ich kann diese Methode nicht
von der Sun-Chat-Methode
der Chat-Ansicht ausführen . Jetzt ist es eine gute
Praxis zu wissen , welche Eigenschaften
und Methoden für
andere Instanzen und
andere Strukturen zugänglich
sein müssen , und zu markieren, dass
alles andere privat ist. Dies ist eine proaktive Methode, um zu verhindern, dass unerwartetes Verhalten
und Fehler auftreten. In Ordnung, und jetzt zum
letzten Teil der Lektion möchte
ich alles, was Sie bisher gelernt haben
, einer schnellen
UI-App in XCode in Verbindung
bringen. Also lasst uns weitermachen und das machen. In Ordnung, also
lasst uns jetzt
ein brandneues iOS-App-Projekt starten . Ich werde nur dieses
Testprojekt benennen und sicherstellen , dass die Schnittstellen Swift UI und Lebenszyklus schnelle
UI-App-Sprachen Swift sind, und wir können loslegen. Also speichere ich das einfach auf
dem Desktop und wir werden
zuerst in den Content
View Point Swift springen. Jetzt ändere ich
das einfach auf iPhone 12 und
klicke auf „Lebenslauf“. Aber der wichtige Teil ist
die Hauptsache, die ich dir zeigen
wollte ,
ist wirklich der Code, oder? Werfen Sie einen Blick auf diese Struktur. Sie wissen, dass dies bedeutet , dass die Inhaltsansicht eine Struktur
ist. Es gibt einige Keywords und Code-Bits , die
wir vorerst beschönigen werden, weil wir
das
noch nicht gelernt haben und jetzt nicht der
richtige Zeitpunkt ist, um es zu besprechen. Also werde ich
ein paar Dinge beschönigen indem ich wirklich auf die
Konzepte hinweisen möchte , die du bisher
gelernt hast , und
dir zeigen, wo sie hinpassen. Dies ist also eine
Strukturdeklaration. Lassen Sie mich
diesen Code einfach für eine Sekunde zusammenklappen. Da gehst du. Sie können also sehen, dass
dies eine Struktur ist. Die Inhaltsansicht ist der Strukturname
gefolgt von einer Doppelpunktansicht. Und wir werden
das in nur einer Sekunde schaffen. Und dann können Sie
die geschweiften Klammern sehen die den gesamten
Code für diese Struktur
enthalten. Alles klar, also lasst es uns noch einmal
erweitern. Und schauen wir uns an,
was wir sonst noch bekommen haben. Hier unten. Wir haben das Schlüsselwort var. Das ist also
der Beginn einer Immobilie. Der Name dieser
Eigenschaft ist body. Okay, danach haben wir einen Doppelpunkt und dann
haben wir einen Blick. Und wir werden das in nur einer Sekunde
wieder schaffen. Aber Sie können sehen , dass es hier eine Reihe von
geschweiften Klammern gibt. Das sagt Ihnen also, dass dies eine berechnete Eigenschaft
ist. Lassen Sie mich
den Code also nochmal zusammenbrechen. Und Sie können sehen, dass dies
tatsächlich
wie ein berechneter
Eigenschaften-Var-Body-Datentyp aussieht , und dann ist eine Reihe geschweifter Klammern darin der Code
, der
berechnet oder berechnet wird, um den Wert zurückzugeben wenn auf diese Eigenschaft zugegriffen wird. Können Sie also all
diese Konzepte sehen , die wir in den
letzten vier Lektionen gelernt haben? Kommen sie zurück? Jetzt möchte ich über
diese Ansicht und eine Ansicht sprechen. Sprechen wir also zuerst in
der Deklaration
der Struktur über diese Doppelpunktansicht . Gemessen daran, wie Sie den Doppelpunkt zuvor
verwendet haben, denken
Sie vielleicht, dass dies
der Datentyp für die
Struktur ist , aber nicht ganz. Das ergibt wirklich keinen
Sinn, oder? Denken Sie daran, dass
der Name der Struktur selbst der Datentyp für
Instanzen dieser Struktur
ist. Was ist diese Doppelpunktansicht
nach dem Strukturnamen? Nun, wenn Sie eine Struktur
deklarieren, der Doppelpunkt nach
dem Strukturnamen zeigt
der Doppelpunkt nach
dem Strukturnamen an, dass diese Struktur einem Protokoll
folgt. In diesem Fall folgt es
dem View-Protokoll. Woran
denkst du also, wenn du das Wort Protokoll
hörst ? Nun, für mich denke ich
darüber nach, dass es sich Regeln oder eine Reihe von Aktionen handelt. Zum Beispiel wie das Brandnotfallprotokoll
, das ein Gebäude
haben könnte , um was zu tun ist
, wenn ein Brand auftritt. Oder wie die Bauordnung, die ein Entwickler befolgen muss, um ein sicheres Haus zu
bauen. In ähnlicher Weise ist
ein Protokoll in Swift eine Spezifikation oder eine Reihe von Regeln, denen die Struktur folgen
muss. Dieser
Doppelpunktansichtsteil zeigt an, dass diese Inhaltsansicht
dem View-Protokoll folgt. Informelle Swift-Terminologie. Inhaltsansicht
entspricht dem View-Protokoll. Nun ist eine wichtige
Sache, die zu erwähnen ist , dass das Schreiben von Doppelpunkt gefolgt vom Protokoll darin besteht, zu sagen und zu
erklären, dass Sie dem Protokoll
entsprechen. Aber eigentlich ist
es so, als würde man die
Hand heben, um etwas zu erklären. Aber befolgen Sie tatsächlich
die Regeln dieses Protokolls? Und so muss der Code in dieser
Struktur tatsächlich die Spezifikationen
für dieses Protokoll
erfüllen. In diesem Fall benötigen
wir eine Body-Eigenschaft, die eine Ansicht zurückgibt, damit
das
View-Protokoll ihm entspricht . Wie Sie hier sehen können, erfüllt
unsere Inhaltsansichtsstruktur
diese Regel tatsächlich. Deshalb entspricht es
dem View-Protokoll. Jetzt, da Sie verstehen,
was Protokolle sind, können
Sie sehen, dass der Datentyp
für diese Body-Eigenschaft
tatsächlich ein Wert ist , der dem View-Protokoll
entspricht. Ja, in diesem Fall der Datentyp für diese Eigenschaft eigentlich
kein Datentyp, aber es ist tatsächlich jeder Datentyp , der einem
bestimmten Protokoll entspricht, in diesem Fall dem View-Protokoll. Innerhalb dieses Codes für
diese berechnete Eigenschaft
muss er also eine Instanz zurückgeben ,
die dem View-Protokoll entspricht. Lasst uns diesen Code öffnen
und sehen, was wir haben. Also was wir hier haben, nun, wir haben eine einzige Code-Anweisung. Und denk daran, was ich
über berechnete Eigenschaften gesagt habe. Wenn es sich nur um eine einzige
Code-Anweisung
handelt, können Sie
das Schlüsselwort return weglassen,
aber ich werde es können Sie
das Schlüsselwort return weglassen,
aber ich werde explizit angeben
, damit es für Sie klar ist. Also was passiert hier? Es sieht so aus, als würden wir
eine Instanz einer Textstruktur erstellen . Nun können Sie dies
herausfinden, wenn Sie in den Bereich „Dienstprogramme“ oder den Inspektorbereich gehen
und hier auf
die Registerkarte „Schnellhilfe“ gehen. Und du legst einfach den Cursor über das Ding, das
du dir ansehen willst. Also klicke ich
in diesen Text. Wie Sie hier sehen können, ist Text
tatsächlich eine Struktur. Wir erstellen also eine Instanz
der Textstruktur. Sie werden jedoch feststellen, dass das Erstellen dieser Instanz
sich von dem unterscheidet wie wir es zuvor gemacht da wir einen leeren
Satz von Klammern verwendet haben. Ich bin hier, wenn wir eine Instanz
dieser Textstruktur
erstellen, wir geben
einige Eingabedaten weiter. Also ja, Sie können Eingabedaten tatsächlich als
Parameter an die Erstellung
einer Instanz einer Struktur
übergeben Parameter an die Erstellung . Diese werden Initialisierer genannt. Jetzt haben wir noch nicht
darüber gesprochen und werden es in kommenden Lektionen tun. Aber im Moment sollten Sie verstehen, dass es eine Möglichkeit
gibt,
Eingabedaten an die Erstellung
einer Instanz einer Struktur zu übergeben Eingabedaten an die Erstellung . Genau das
passiert genau hier. Jetzt fragen Sie sich vielleicht, entspricht diese Textstruktur
dem View-Protokoll? Nun, es muss schreiben, denn gemäß dieser Körpereigenschaft muss
alles, was für
diese berechnete Eigenschaft
zurückgegeben wird , dieser entsprechen. Lassen Sie uns nochmal
in die schnelle Hilfe eintauchen. Also fahre ich mit dem
Mauszeiger über Texte. Ich gehe runter. Und tatsächlich öffne
ich die Entwicklerdokumentation. Wenn Sie jetzt Xcode 1.112 verwenden, ist ein Fehler
aufgetreten, der beim Versuch, dieses Fenster
zu öffnen,
abgestürzt ist. Sie müssen also nur
Xcode aktualisieren, um diese Abstürze für Sie zu erhalten. Okay, das ist also die
Dokumentation für Texte. Man sieht, dass
es sich um eine Struktur handelt. Und wenn Sie
ganz nach unten scrollen, überspringe
ich all das Zeug weil ich Ihnen nur zeigen möchte , dass es tatsächlich zwei
Protokollen entspricht. Aber was uns interessiert ist, dass es dem Protokoll
entspricht. Alles klar, eine andere
Sache, auf die ich
hinweisen möchte , ist, dass dies von früh
an daran erinnert wird. Dies ist ein Modifikator. Und jetzt muss es für dich
ziemlich vertraut aussehen, oder? Weil es so aussieht, als würden
wir eine Methode aufrufen. Das ist Punktnotation genau hier. Wir erstellen eine Instanz
der Textstruktur. Und dann rufen wir die Padding Methode für diese Instanz
auf. Mal sehen, ob ich es
in die gleiche Zeile lege. Es könnte für dich etwas
vertrauter aussehen. Okay, also hoffe ich, dass
sich Punkte verbinden. Kein Wortspiel beabsichtigt. Okay, um dies mit der vorherigen
Strukturstunde
zu verknüpfen ,
in der ich dir gezeigt habe
, wie man eine Struktur deklariert. Wir hatten ein paar
verschiedene Abschnitte, oder? Ganz oben würden wir unsere Immobilien
deklarieren. Und tatsächlich
gilt diese Körpereigenschaft als Eigentumsrecht. Es enthält aber auch
unseren View-Code. Dies wäre also der Ort, an den
unser View-Code geht. Und dann würden wir hier unten die Methoden
für diese Struktur
deklarieren. Okay, also denke ich, dass Sie verstehen , dass diese Struktur, die
als
Inhaltsansicht bezeichnet wird , die Hauptansicht
oder den Hauptbildschirm dieser App darstellt . Aber haben wir nicht gesagt
, dass Strukturen
allein nichts tun. Sie müssen eine Instanz
davon erstellen, damit es funktioniert. Nun, wo erstellen wir
eine Instanz der Inhaltsansicht? Dafür müssen wir einen Rücklauf
bis zum
Einstiegspunkt der App machen
, der genau hier ist. Sie können also sehen, dass dies an sich auch eine Struktur ist und der Name dieser Struktur der
Name Ihres Projekts
ist und einem
Protokoll namens App entspricht. Schauen wir uns also die
schnelle Hilfe an und sehen worum es in diesem Protokoll geht. Erstellen Sie eine App, indem Sie
eine Struktur deklarieren , die dem App-Protokoll
entspricht, implementieren Sie die
erforderliche berechnete Eigenschaft, um
den Inhalt der App zu definieren. Jetzt haben wir eine andere
Körperberechnungseigenschaft. Ich überspringe einige
dieser Szene in
Window-Gruppensachen. Ich möchte darauf hinweisen, dass wir
hier
eine Instanz erstellen,
diese wir
hier
eine Instanz erstellen, Inhaltsansichtsstruktur. Siehst du also, wie
alles zusammenpasst? Gehen wir außerdem zur
Inhaltsansicht zurück und lassen Sie mich Ihnen etwas anderes
zeigen. Dafür
öffne ich die Leinwand wieder. Und ich werde die Vorschau
fortsetzen. Sieh dir diese
Struktur hier unten an. Dies ist es, was die
Vorschau, die Sie hier sehen, angetrieben. Diese Struktur wird nicht wirklich als Teil Ihrer App
verwendet. Es ist nur für die Vorschau
in der Canvas genau hier. Es entspricht also dem
Vorschau-Provider-Protokoll. Und es hat eine Eigenschaft namens Previews,
static Schlüsselwort ignorieren. Im Moment erklären wir
das in einer zukünftigen Lektion. Und hier unten können Sie
sehen, dass eine Instanz Ihrer
Inhaltsansichtsstruktur
erstellt wird und
genau das wird hier gezeigt. Tatsächlich kann ich Modifikatoren auf
diese Instanz
anwenden und es wird ändern
, was wir hier haben. Okay, also kann ich die
Punktnotation verwenden, um Modifikatoren aufzurufen, die jetzt, wissen Sie, nur Methoden
sind, oder? Von dieser Ansicht oder
dieser Instanz. Eigentlich. Anstatt
das zu tun, warum
verwenden wir nicht den visuellen Weg und sehen,
wie er den Code ändert. Also 10, ich schaue mir diese Änderung an. Eigentlich ändere ich
das Schema in den dunklen Modus. Sie können also sehen, dass es dieser Instanz einen
Modifikator hinzufügt. Wechseln wir auch das
Gerät auf iPod touch. Sie können sehen, dass es
einen weiteren Modifikator
namens Vorschaugerät hinzufügt . Was passiert, wenn ich eine weitere Vorschau
erstelle? Weil Sie auf
diesen Button hier klicken können, wird hier unten
eine weitere Vorschau erstellt. Sie können sehen, was
mit dem Code passiert. Nun, es hat
eine andere Instanz der
Inhaltsansicht erstellt und es
hat eigene Modifikatoren. Jetzt ist dies nach einem Container
gruppiert, einem Container namens group
, den wir noch nicht
wirklich abgedeckt haben, aber wir werden in Zukunft nur wissen, dass er Ansichten
zusammenfasst. Diese Instanz der
Inhaltsansicht ist also hier oben, und diese Instanz ist
diese hier unten. Sehen Sie, ich kann dieses
Schema auf Licht ändern. Und du kannst sehen, dass es das
ändert. Und ich kann dieses
Gerät auf iPhone 12 umstellen. Und der ändert diesen
Modifikator dort. Es sind also unabhängige
Instanzen. Ich habe viel mitgenommen
und deshalb empfehle ich dir
nie, etwas auswendig
zu lernen. Je mehr Übung du bekommst, desto eher wird es für dich zur zweiten Natur
werden. Lassen Sie uns eine kurze
Zusammenfassung machen, oder? Sie haben gelernt,
Instanzen Ihrer Struktur zu erstellen. Sie haben gelernt, wie Sie
mit der Punktnotation auf
die Methoden und
Eigenschaften Ihrer Instanzen zugreifen können. Und Sie haben auch etwas
über Zugriffsebenen erfahren. So können Sie steuern
, auf welche Eigenschaften und welche Methoden
mit der Punktnotation zugegriffen werden kann. Schließlich haben Sie gesehen, wie sich
all diese
Konzepte auf eine schnelle
UI-App in Xcode beziehen. Jetzt, in den folgenden Lektionen, kehren
wir zu unserem
Kriegskartenspiel
zurück und nehmen all dieses neu entdeckte schnelle Wissen und erwecken dieses
Kriegskartenspiel zum Leben. In der nächsten Lektion
zeige ich Ihnen, wie Sie
das Button-Element verwenden , um die Benutzerinteraktion zu
behandeln. Alles klar, wir sehen uns dort.
11. 10: 10:: Hallo und willkommen. In den letzten Lektionen haben
Sie die Grundlagen
der Swift-Programmierung gelernt. Und ich habe Ihnen gezeigt, wie diese Konzepte
auf Ihr Xcode-Projekt angewendet wurden. Kommen wir nun zurück zur
Swift-Benutzeroberfläche und -Ansichten. Speziell heute möchte ich über die Button-Ansicht
sprechen. Lasst uns gleich eintauchen. Alles klar, also
habe ich einen brandneuen Swift ich hier projiziere? Ich dachte, wir würden
einen Blick darauf werfen,
einige Button-Instanzen
in einem neuen Projekt
zusammen zu erstellen einige Button-Instanzen
in einem neuen Projekt , bevor wir zum harten
Spiel
zurückkehren , um die
Button-Instanz dort zu verwenden. Also lasst uns
diese Textansicht gleich hier löschen. Beim Erstellen einiger Instanzen ist
eine Schaltfläche eine Struktur
wie dieser Text. Und wir müssen
eine Button-Instanz erstellen. Mit anderen Worten, wir müssen einen Button
instanziieren, und es ist nur eine andere
Art, es zu sagen. Gehen wir also fort
und tippen Sie Taste, gefolgt von einem Öffnen einer
linken abgerundeten Klammer. Und das wird unser Autocomplete-Menü
aufrufen. Es gibt ein paar verschiedene
Initialisierungsmethoden, mit denen wir eine Button-Instanz erstellen
können . Und diese
Initialisierungsmethoden, denken Sie daran, sind nur verschiedene Möglichkeiten eine Instanz zu
erstellen, während einige Daten
weitergegeben werden. Zwei der
häufigsten, die Sie verwenden
werden, sind diese genau hier, wo Sie eine Zeichenfolge übergeben. Und dieses
Datentyp-String-Protokoll bedeutet
einfach alles, was diesem String-Protokoll
entspricht, und ein Textstück tut es. diesem können Sie einfach einen Text
übergeben, der als Schaltflächenbeschriftung
verwendet werden soll. Und
Sie können auch einen
Codeblock übergeben, der ausgeführt werden soll, wenn diese
Schaltfläche angetippt wird. Werfen wir einen Blick auf diese
Parameter genauer. Dieser erste Parameter für
die Beschriftung der Schaltfläche ist also ziemlich einfach. Hier gibst du
einfach ein Stück Text ein. Ich rufe diesen
Button auf, Click Me. Und wenn wir aktualisieren, wird
unsere Vorschau
noch alles tun , bevor wir
den zweiten Parameter angeben. Der Datentyp für diesen
Aktionsparameter ist etwas, das Sie
noch nicht gesehen haben. Aber es sieht irgendwie aus wie eine Funktionssignatur ohne
den Funktionsnamen, oder? Dies wird als Schließung bezeichnet. Und einfach ausgedrückt, Sie können es sich als einen
Codeblock
vorstellen oder wie eine Funktion
ohne den Funktionsnamen, Sie übergeben einen
Codeblock als Parameter. Wenn die Schaltfläche angetippt
wird, wird
dieser Codeblock ausgeführt. Auch dies wird als Schließung bezeichnet. Werfen wir also einen
Blick darauf, wie wir den Verschluss
als Parameter
angeben können . Eines der einfachsten
Dinge, die Sie tun können, ist diesen Parameter hervorzuheben
und einfach die Eingabetaste zu drücken. Und Xcode
öffnet
automatisch eine Schließung, in die Sie Ihren Codeblock
eingeben können. Aber ich werde das jetzt nicht
machen, weil ich die Schritte
durchlaufen
und es wirklich auf dich
aufteilen und dir zeigen
möchte und es wirklich auf dich
aufteilen und dir zeigen was genau
du spezifizierst. Und am Ende zeige ich
Ihnen, was passiert, wenn Sie Enter
drücken und Xcode einfach die Schließung für Sie
öffnen lassen. Lassen Sie uns diese
Schließung vorerst manuell angeben. In Ordnung, also ist die Art
der Schließung, die dies erwartet, der einfachste
Typ, den Sie sehen können. Es akzeptiert keine Parameter. Diese beiden Klammern genau hier, diese beiden abgerundeten Klammern. Das ist eine Parameterliste, genau wie
Sie es tun würden , wenn Sie eine Funktion
deklarieren. Aber es ist leer, also
gibt es keine Parameter. Und dann siehst du als nächstes einen Bindestrich gefolgt von einem
Größeren als Symbol. Und du weißt, dass das Rückgabetyp
bedeutet, oder? Und es kehrt ungültig zurück. Leere bedeutet nichts. Es gibt also
nichts zurück und es
akzeptiert nichts. Es ist ganz einfach
ein Codeblock. Alles klar, jetzt, da
Sie den Typ
der Funktion kennen , dann erwartet sie, wir weiter und geben Sie es an. Also lösche ich das. Und ich öffne
ein Paar geschweifte Klammern. Und ich muss nichts
zurückgeben. Ich muss keinen Parameter
angeben. Es ist ganz einfach nur
der Codeblock. Sie können dies also
mit nur einer Reihe
geschweifter Klammern angeben . Und zwischen diesen
geschweiften Klammern setzen
Sie alle gewünschten
Codeanweisungen ein. Also werde ich einfach Hello World
ausdrucken. Und das ist dein
abgeschlossener Button. Lassen Sie uns dieses Projekt ausführen
und sehen, was passiert. Okay, also waren wir in der
Mitte, die besagt, klick mich. Wenn ich darauf tippe,
läuft es die Schließung aus. Es führt den Code in der Schließung aus. Und du kannst sehen, dass es dort
unten in der Konsole jedes Mal Hello
World ausdruckt, Hello
World ausdruckt wenn ich
auf diesen Button klicke. Okay, jetzt gehen wir zurück zu unserem Xcode-Projekt,
denn das ist nur eine Möglichkeit, einen Button zu
instanziieren. Ich füge hier einen
Kommentar hinzu und rufe diese Button-Instanz
mit Schließung auf. Okay? Und dann
lege ich das auch in einen V-Stack. Eigentlich
zeige ich dir eine Kurzschrift,
coole Art, es zu tun. Ich werde es in
den Stapel legen , weil ich Ihnen ein paar andere
Möglichkeiten
zeigen wollte , Schaltflächen zu erstellen. Also werden wir zusammen ein
paar Buttons erstellen. Gehen Sie weiter und befehl
klicken Sie auf diese Schaltfläche und Sie können einfach Einbetten und V Stack
wählen. Tu das. Es legt das Element für dich
in den Stapel, obwohl es meinen Kommentar nicht dorthin
verschoben hat. Stellen wir das also genau
hin. Alles klar. Also haben wir einen Knopf und ich möchte
dir denselben Knopf zeigen, aber mit einer kurzen Hand
gibt es etwas, das als Trailing-Verschluss bezeichnet wird. Lass mich dir zeigen, was das bedeutet. Also Button-Instanz
mit abschließender Schließung, ich kopiere und
füge die
gerade deklarierte Schaltfläche ein und erstelle
eine weitere Kopie davon. Wenn also in der Parameterliste der letzte Parameter eine Schließung
erwartet, gibt es eine Kurzschrift. Und wie es funktioniert
, nehmen Sie den letzten Parameter aus
der Parameterliste
und
setzen die Schließung einfach nach
dem Methodenaufruf. Lass mich dir zeigen, was ich meine. In dieser Parameterliste ist
diese Schließung der
letzte Parameter, oder? Dies ist also ein Hauptkandidat für eine abschließende Schließungsabkürzung. Ich übernehme die Schließung selbst. Also werde ich das
aus der Parameterliste herausschneiden. Und ich füge einfach
ein Leerzeichen nach dem Ende abgerundeten Klammer und füge dann einfach
den Verschluss so ein. Und dann kann ich
die Umfangsbeschriftung
oder die
Argumentbeschriftung so aus dieser
Parameterliste entfernen die Umfangsbeschriftung
oder die
Argumentbeschriftung . Und diese zwei
Schaltflächendeklarationen sind genau das Gleiche. Es ist nur so, dass sie anders
geschrieben werden. Zum einen gibt
die Schließung innerhalb der Parameterliste an
und die andere gibt ihn mit
einem nachfolgenden Verschluss an. Und deshalb
wollte ich dir das
manuell zeigen , anstatt Xcode einfach eine Schließung für dich öffnen zu
lassen. Denn wenn Sie Xcode machen
lassen, wird
es erkennen,
dass diese Schließungsparameter, der letzte, und
es wird
es in eine nachfolgende
Schließung für Sie verwandeln . Ich bin automatisch, also
lass mich dir das zeigen. Wenn ich einen anderen Button
deklariere, verwenden wir denselben. Klicken Sie auf mich und tippen Sie dann
auf diesen Aktionsparameter, doppelklicken Sie
entweder
darauf oder ich drücke Enter und lasse Xcode die Schließung
öffnen. Es wandelt es automatisch
in einen abschließenden Verschluss um. Also dachte ich, das
wäre wirklich verwirrend für dich, wenn du das noch nie zuvor
gesehen hättest. Und so
weißt du zumindest jetzt , was eine nachfolgende
Schließung ist und warum, weißt
du, Xcode
das für dich tut. Okay, das ist also nur eine Art von Schaltfläche zu
erstellen. Beide Möglichkeiten,
Schaltflächen zu erstellen , bei denen Sie nur
einen Text als Etikett haben. Aber was ist, wenn Sie möchten, dass
Ihre Schaltfläche ein Bild oder ein Symbol oder
ähnliches
ist, nicht nur ein einfacher Text. Nun, es gibt eine andere
Initialisierungsmethode für die Schaltfläche, die
wir dafür verwenden können. Werfen wir einen Blick auf diese Button-Instanz
mit Label-Ansicht. Also lasst uns fortfahren
und Taste eingeben, eine Klammer
öffnen. Und nun schauen wir uns
diese andere Initialisierungsmethode
mit einem diese andere Initialisierungsmethode Aktions- und
Labelparameter an und
erstellt eine Schaltfläche, die ein benutzerdefiniertes Label
anzeigt. Und Sie können aus
der Raubtierliste sehen , dass mich das erste Mal zu diesem
Autocomplete-Menü zurückkehren
lässt. Wenn Sie sich diese
Parameterliste ansehen, können Sie jetzt sehen, dass dieser Aktionsschließungsparameter
der erste Parameter und dann der zweite
Parameter eine Bezeichnung ist. Jetzt können
Sie für diesen Beschriftungsparameter jede Ansicht zurückgeben, die Sie für
Ihre Schaltfläche darstellen möchten. Also lasst uns fortfahren und
diese Initialisierungsmethode wählen. Sie können die
Aktionsschließung genau hier sehen, wenn ich darauf doppelklicke,
wird es sich nicht in
eine nachfolgende Schließung verwandeln. Und der Grund dafür ist
, dass es nicht der letzte Parameter
in der Parameterliste ist. Das ist also nicht berechtigt in eine
abschließende Schließung umgewandelt zu werden. Okay, also wenn dieser
Button wieder angetippt wird, drucke
ich einfach Hello World
in die Konsole aus. Aber für das Etikett werden Sie
feststellen, dass ich eine gewisse Freiheit habe anzugeben welche Art von Ansicht
ich zurückgeben möchte. Hier gibt es also nur ein TextView
mit einem einfachen
Text
zurück , der als button bezeichnet wird. Aber ich kann, ich kann ein Bild B
zurückgeben, zum Beispiel könnte ich
einen Stapel verschiedener Ansichten zurückgeben. Du kannst
alles zurückgeben, was du willst. Lassen Sie mich die
Vorschau hier einfach fortsetzen, damit Sie die verschiedenen
Schaltflächen
sehen können , die wir deklariert haben. Okay? Was ich hier zurückgeben werde, ist vielleicht weniger Rendite
in jedem Stapel. Und ich gebe
einen Text mit der Aufschrift „Bearbeiten“ zurück. Und ich werde auch
ein Bild davor zurückgeben. Und für dieses Bild werde
ich angeben, werde
ich angeben, ich unserer Asset-Bibliothek keine Bilder
hinzugefügt habe, aber ich werde etwas verwenden, das als SF-Symbol
bezeichnet wird. Jetzt haben wir noch keine SF-Symbole
durchlaufen. Wir werden dies in
einer zukünftigen Lektion tun. SF-Symbole sind jedoch großartig. Weil es sich im Grunde um
ein Icon-Set handelt, das
mit Xcode geliefert wird und das Sie
einfach in Ihren Apps verwenden können. Und das sind ganz
besondere Merkmale
dieser SF-Symbole, die wir in einer zukünftigen
Lektion in diesem Kurs
durchlaufen werden in einer zukünftigen
Lektion in diesem Kurs
durchlaufen Es gibt eine kostenlose Mac-App namens SF-Symbole, die Sie dort herunterladen
können kann alle verschiedenen Symbole durchsuchen , die Ihnen kostenlos
zur Verfügung stehen. Also benutze ich zum Beispiel einfach
diesen Bleistift. Jeder von ihnen hat einen Namen
, den Sie einfach
angeben können und Sie
können ihn verwenden. Für das Bild der zu verwendende Initialisierer, wenn Sie S von Symbolen verwenden möchten, Systemname genannt. Und dann geben Sie
den Namen an, den Sie unter dem Symbol
gesehen haben. Bleistift Ich lege einfach den Bleistift genau hin und du
siehst, dass das Symbol erscheint. Alles klar, also
lasst uns diese App
im Simulator ausführen und schauen
uns an, was passiert. Okay, damit ich diesen tippen kann, sagt Hello World Cup, dass es Hello World heißt. Das hat gelehrt
, sagt auch helloworld. Das sind die Schließungen , die ich für
alle Tasten angegeben habe. In Ordnung, Jetzt
wissen Sie, wie Sie
eine einfache Schaltfläche mit nur
dem Text für das Etikett angeben . Sie wissen, wie Sie eine Schaltfläche angeben , mit der Sie eine beliebige
Ansicht als Schaltfläche verwenden können. Wir kehren jetzt zu unserem
Kriegskartenspiel zurück und verwandeln Deal-Button-Bild
in einen echten Button. Alles klar, also
habe ich jetzt das Kriegskartenspiel , an dem
wir bereits gearbeitet haben, war es weniger als vier oder fünf? Aber hier müssen wir hin. Und wenn Sie sich erinnern, hatten
wir ein Bild
für diesen Deal-Button verwendet. Und das ist der
View-Code dafür. Und du siehst, dass
es nur ein Bild ist. Jetzt weißt du, wie man
das in einen Button verwandelt. Also möchte ich, dass du das Video
jetzt
einfach pausierst und
es selbst ausprobierst, in deinem eigenen Projekt
genauso wie eine kleine Übung. Nachdem du
es selbst ausprobiert hast. Oder wenn du gerade stecken geblieben bist, spiele dieses Video
weiter
und wir machen es zusammen. Okay, probieren wir es zusammen aus. Also werde ich hier nur
ein bisschen Platz schaffen. Und wir
werden einen Button deklarieren. Verwenden der Schaltfläche. Öffnen wir Klammern und wählen wir diese Initialisierungsmethode für die
Aktionsbeschriftung. Jetzt, innerhalb der Aktion, werden
wir nur diesen Codeblock öffnen
, aber wir
werden noch nichts tun. Das werden wir in
der nächsten Lektion machen. Beschriften und löschen Sie diese Ansicht für die
Beschriftung innerhalb
einer Textschaltfläche . Und ich werde einfach
unser Image verschieben, wobei der Deal auf dem Etikett für unseren Button war . Und einfach so sieht
man
keine visuelle Veränderung. Wenn Sie
dies jedoch im Simulator ausführen, werden
Sie feststellen,
dass Sie darauf tippen können. Es ist ein natürlicher Knopf. Eine andere Möglichkeit, wenn Sie
Ihren Simulator
nicht starten möchten , ist, dass Sie diesen Button
direkt hier für die Live-Vorschau drücken
können direkt hier für die Live-Vorschau und ich fange absolut an. Ja. Dann kannst du weitermachen und ich
muss auf Fortsetzen klicken. Okay. Sie können jetzt im Canvas sehen, da ich Live
Preview aktiviert
habe, kann ich den Button testen. Das war Ihre erste
Einführung in die Handhabung Benutzerinteraktion
in einer schnellen UI-App. Die Stücke
kommen wirklich zusammen. Lassen Sie uns eine kurze Zusammenfassung machen. Sie haben gelernt, Schaltflächen zu
instanziieren, und das ist nur eine ausgefallene Art Button-Instanzen zu erstellen. Sie haben etwas über Schließungen erfahren und wie es sich nur codeähnliche Funktionen
ohne Funktionsnamen handelt. Und dann haben Sie etwas
über Trailing-Schließungen gelernt, die nur eine Kurzschrift sind. Und nur um Sie daran zu erinnern, Sie
eine abschließende Schließung
als Parameter in einem Methodenaufruf haben . Und dann wird es aus
dieser Parameterliste herausgenommen und stattdessen am
Ende dieses Methodenaufrufs gesetzt. In der nächsten Lektion zeige
ich Ihnen ein wichtiges Swift-UI-Konzept
, mit dem Sie Daten ändern und die Benutzeroberfläche
die Änderung automatisch erkennen und dann die Benutzeroberfläche selbst
aktualisieren können. In Ordnung, wir sehen uns
in der nächsten Lektion.
12. 11: Staatliche Eigenschaften: Hallo und willkommen. In der letzten Lektion haben
Sie etwas über die Schaltfläche „Swift UI“ und
den Umgang mit Benutzerinteraktionen erfahren. Nun, um
die Daten zu ändern und
diese Änderung in der Benutzeroberfläche dann widerzuspiegeln, müssen
wir mehr über
Statuseigenschaften lernen
, und darum geht es in dieser
Lektion. Lasst uns gleich eintauchen. In Ordnung, also
wollte ich diese Ansicht noch einmal aufrufen und das Lebenszyklusdiagramm
für nur eine Sekunde
aktualisieren. Erinnern Sie sich, als wir einen Link von den Daten
zum View-Code angezeigt haben? Nun, machen wir das mit unserem Kriegskartenspiel-Projekt. Welche Art von Daten haben
wir in diesem Projekt? Nun, wenn Sie sich
die Benutzeroberfläche hier ansehen, können
Sie sehen, dass wir
verfolgen müssen , welche Karte
der Spieler hat, welche Karte die CPU hat und dann auch die Punktzahl
des Players und der CPU. Das sind also vier Daten. Lassen Sie uns vier Eigenschaften in
unserer Inhaltsansichtsstruktur erstellen , um diese vier
Daten
darzustellen. Direkt unter der öffnenden geschweiften
Klammer der Inhaltsansicht werde
ich
fortfahren und deklariere var CPU L2
Player erste Player-Karte gleich. Und ich ahme einfach die
Autos nach, die wir dort haben. Also werden wir auch eine Karte haben. Und ich lasse mich tatsächlich
einfach, ich ändere es. Wir können etwas
anderes einsetzen, um damit anzufangen. Und dann ist die CPU-Karte gleich, sagen
wir Karte neun. Und dann lasst uns
den Spielerstand darstellen. Und das wird
eine ganze Zahl sein. Fangen wir auch mit 0 an. CPU-Punktzahl ist gleich 0. Okay, jetzt haben wir diese vier Eigenschaften, die
den Status des Spiels darstellen. Diese vier Eigenschaften
sind unsere Quelle der Wahrheit, weil sie darstellen,
wie die Benutzeroberfläche aussehen sollte. Wie spiegeln wir diese Daten
in unserer Benutzeroberfläche wider? Nun, wir müssen
diese Eigenschaften
in unserem View-Code referenzieren . Denken Sie daran, dass diese
Eigenschaften die im Rahmen
dieser Struktur
deklariert werden
, bedeutet , dass sie in einer der
Methoden in derselben Struktur
sowie in diesem Codeblock
referenziert sowie in diesem Codeblock für unser berechnetes Körpereigentum. Wenn wir also hier unten nach
dieser ersten Karte suchen ,
die genau hier ist, und wir haben eine Schnur
fest codiert, die Karte zu sagen. Anstatt dort
eine Zeichenfolge fest zu codieren, legen
wir einen dynamischen Wert ein, indem unsere
Spielerkarteneigenschaft
angeben. Aktualisieren wir also unsere
automatische Vorschau und nur um sicherzustellen, dass das läuft und alles gut ist. Und Sie können sehen, dass diese
Karte die Karte fünf ändert ,
weil dies der Wert
der Spielerkarteneigenschaft ist. Lassen Sie uns das Gleiche für
die CPU-Karte tun , anstatt die Karte drei
fest zu codieren, legen
wir die
CPU-Karte-Eigenschaft ein. Du siehst diese Änderung. Und hier unten, für die Punktzahl
anstelle einer Zeichenfolge von 0, setzen
wir unsere
Spieler-Score-Eigenschaft ein. Jetzt werden Sie hier einen Fehler
bemerken. Es sagt keine genauen Übereinstimmungen
im Aufruf des Initialisierers. Und das liegt daran, dass
wir zum
Initialisieren einer Textinstanz ein
Stück String-Daten übergeben müssen. Aber Spielerstand, denken Sie daran, Dies ist eine int-Eigenschaft, also enthält sie int-Daten. Aber wie wir das
umgehen können, ist, dass wir unser int in eine Zeichenfolge verwandeln
können. Nun, zumindest die
Stringdarstellung einer Zahl. So wie wir das tun,
können wir
eine neue String-Instanz erstellen und einfach die übergeben, wir können die ganze Zahl übergeben. Dieser
wäre also ein Spielerstand. Und wir werden das
Gleiche für den CPU-Score tun. Wir erstellen eine neue
Zeichenfolge und wir werden den CPU-Score
übergeben. Und genau so werden
unsere vier
Daten im
View-Code und wiederum in der Benutzeroberfläche
dargestellt. Jetzt müssen wir nur noch tun wenn der Benutzer auf die Schaltfläche
tippt, wir können diese Daten in
den Eigenschaften aktualisieren und
die Benutzeroberfläche automatisch
ändern lassen , oder? Nun, nicht so schnell. Warum versuchen wir das
nicht und schauen wir uns
an, was passiert. In der letzten Lektion hatten
wir dieses
Deal-Bild in einen tatsächlichen Button geändert. Im Moment ist diese
Aktionsschließung leer. Lassen Sie uns einen Code in diese Aktionsschließung
für unseren Button legen. Hier aktualisieren wir
die Karten und wir
werden auch den Spielstand aktualisieren. Wenn Sie nun versuchen,
die Eigenschaft wie hier zu aktualisieren, versuchen
wir, die
Spielerkarte gleich Karte 11 zu aktualisieren. Du wirst sehen, dass du es nicht kannst. Xcode wird sich beschweren und sagen, kann nicht
eigenschaftsselbst zugewiesen werden, ist unveränderlich. Jetzt bezieht sich selbst auf
die Instanz
einer Inhaltsansicht und unveränderlich bedeutet, dass
sie nicht geändert werden kann. Sie sehen, dass Instanzen Werttypen
sind und aufgrund der Art und Weise, wie sie im Speicher
zugewiesen werden, können
sie nicht geändert werden. Jetzt weiß ich, dass das für Sie jetzt
absolut keinen Sinn
macht , aber ich verspreche Ihnen
in einer zukünftigen Lektion, dass
wir darüber sprechen werden und dann wird
es für den Moment völlig
sinnvoll sein, nur verstehen, dass wir den Wert unserer Immobilie nur ändern
können, wenn wir einen Property Wrapper
verwenden. Ein Property Wrapper ist
ein Schlüsselwort vor
unserer Eigenschaftsdeklaration
, das sein Verhalten ändert. Jetzt spreche ich konkret über den State
Property Wrapper. Lassen Sie uns also zu
unseren Immobilienerklärungen zurückkehren und sehen, wie er
diesen State Property
Wrapper verwendet hat , um
das Verhalten
dieser Eigenschaften zu ändern das Verhalten
dieser Eigenschaften ,
damit wir die Werte
ändern können. Alles, was wir tun, ist vor dem Schlüsselwort var unserer
Immobilienerklärung, wir bei State schreiben werden. Und wenn Sie dieses
Schlüsselwort im Status hinzufügen, wird dies darauf hinweisen, dass diese
Spielerkarteneigenschaft tatsächlich eine staatliche Eigenschaft ist
und es uns
ermöglicht,
den darin enthaltenen Wert zu aktualisieren. Lassen Sie uns also
diesen
Immobilien-Wrapper vor
alle vier unserer Immobilie stellen diesen
Immobilien-Wrapper vor , damit es sich alle um
Wohnimmobilien handelt. Staatliche Eigenschaften haben zwei
besondere Merkmale. Nummer eins ist, dass Sie die darin befindlichen Daten
ändern können. haben wir bereits gesprochen. Nummer zwei ist jedoch, dass
innerhalb des
View-Codes alle Verweise auf
Statuseigenschaften alle Verweise auf
Statuseigenschaften über die Datenänderungen informiert
werden und dann Ihre Benutzeroberfläche basierend
auf diesen neuen Daten
automatisch aktualisiert wird . Gehen wir also weiter, gehen Sie zum Aktionsschluss
unserer Schaltfläche und versuchen Sie, einige dieser
Zustandseigenschaften zu aktualisieren. Und lasst uns zusehen, wie sich die Benutzeroberfläche ändert. Okay, also hier sind wir. Und wie Sie jetzt sehen können, ist
der Fehler verschwunden. Und ich kann
CPU-Karte gleich Karte 12 setzen. Und lasst uns auch den Spielstand
aktualisieren. Könnte genauso gut nur dazu kommen. Also werde ich sagen, dass
Spielerstand plus gleich eins ist. Das bedeutet, es um eins zu
erhöhen. CPU-Punktzahl
plus ist ebenfalls eins. Und das sparen wir. Dann. Machen wir eine Live-Vorschau, um zu
sehen, ob wir das schaffen könnten. In Ordnung, das
ist also eine Live-Vorschau. Wenn ich auf diesen Button tippe, wird hier
die Schließung ausgeführt. War das nicht cool? Als ich auf diese Schaltfläche tippte, haben wir die Daten in
den Statuseigenschaften aktualisiert. Stimmt's? Und weil
es in unserem View-Code auf diese
Statuseigenschaften verweist, wurden
sie benachrichtigt und die Benutzeroberfläche wurde erneut gerendert, um die neuen Daten
anzuzeigen. Jetzt ist das Problem, dass jedes Mal, wenn wir auf
die Schaltfläche tippen, die
Punktzahl erhöht, was cool ist, aber die Spielerkarten werden
nicht randomisiert. Was wir also tun können, ist, dass wir die zufällige Methode
des Kursleiters
verwenden und eine Zufallszahl
generieren können die zufällige Methode
des Kursleiters
verwenden . Und dann
hängen wir diese Zufallszahl an die Rückseite
der Kartenzeichenfolge
an, um eine neue Karte zu generieren. Werfen wir einen Blick darauf,
wie das funktionieren würde. Generiere eine Zufallszahl
zwischen zwei und 13. Denn wenn man sich die Asset-Bibliothek
anschaut, haben
wir eine Karte bis
zur Karte 14 tatsächlich. Also würde ich wahrscheinlich zwei
bis 14 generieren wollen. Also werde ich sagen, dass Spieler Rand gleich
int dot random ist. Und diese Methode ermöglicht es
uns, einen Bereich anzugeben. Sie können einen Bereich mit
dem unteren Ende des Bereichs,
Punkt, Punkt, Punkt und
dann dem oberen Ende angeben . Und es sollte inklusive sein, wenn ich mich richtig erinnere. Und wir werden es in einer Sekunde sehen. Und lasst uns noch einen erklären. CPU-Rand entspricht
Int-Punkt-Punkt-Punkt zufällig in
zwei, Punkt-Punkt-Punkt und 14. Und dann werden wir
tun, anstatt die Nummer in
der hart codierten Zeichenfolge
anzugeben, werde
ich nur die Karte angeben. Und dann füge ich
Spieler Rand hinzu und füge CPU-Rand hinzu. Nun können wir das vielleicht nicht
tun und wie
erwartet können wir es nicht. Denn wie Sie
bereits in dieser Lektion
wissen, versuchen wir
hier, eine Ganzzahl an eine Zeichenfolge
anzuhängen. Stattdessen müssen
wir
diese ganze Zahl zuerst in eine
Zeichenfolge konvertieren und die String-Repräsentation dieser Ganzzahl
abrufen. Und dort sollte das jetzt dynamisch
sein. Werfen wir einen Blick darauf und sehen, ob es das ist, was wir erwarten. Das ist perfekt. Die Karten sind randomisierend. Was nicht perfekt ist, ist
der Punktestand hier unten. Wir müssen immer noch
bestimmen, welche Seite gewinnt, und dann
die entsprechende Punktzahl erhöhen. Also werde ich diese beiden
Codeteile kommentieren , weil wir
sie nicht jedes Mal
nur um eins erhöhen wollen . Bevor wir diese Lektion
beenden, möchte
ich wirklich darauf hinweisen und betonen, wie mächtig
dieser Rahmen ist. Was wir hier machen,
ist auf einen Knopf zu tippen. Es führt diese
Schließung durch und wir ändern den Wert in
diesem Staatseigentum. Und weil die staatliche
Eigenschaft hier innerhalb
unseres View-Codes
referenziert
wird, erkennt man diese
Datenänderung und
rendert dann das , was
wir in der Benutzeroberfläche sehen, neu. Und das passiert automatisch. Alles, was wir tun, ist die Daten zu
ändern. In der Vergangenheit gab es mit dem UI-Kit dieses System nicht. Stattdessen müssten wir die Daten aktualisieren, genau wie wir es hier tun. Aber wir müssten auch
jedes View-Element manuell aktualisieren und ihm sagen, was angezeigt werden soll. Was wir also tun müssten, ist,
einen Verweis auf dieses Image zu erhalten und
dann ein Image aus diesem Asset-Namen
aus der Asset-Bibliothek zu generieren aus diesem Asset-Namen
aus der Asset-Bibliothek und dieses
Image-Asset dann auf dieses ImageView festzulegen. Und das müssten wir auch
dafür tun. Dann müssten wir es für
den Text hier und die Labels tun. Also alles, was wir manuell machen
mussten. Jetzt müssen wir
nur noch die Daten
in allen Benutzeroberflächen aktualisieren, die an diese
Statuseigenschaften
gebunden sind, um die Änderung zu erkennen
und automatisch zu aktualisieren. Jetzt ist eine
Statuseigenschaft per Definition ein Datenelement ,
von dem diese
Inhaltsansicht abhängt. Es ist nicht etwas, das andere Ansichten interessieren oder
davon abhängen würden. Und so können
wir das Keyword privat hinzufügen und
einfach die Zugriffsebene zu diesen
Daten steuern, so dass sie nur
innerhalb des Kontextes oder
des Umfangs von zugänglich
sind Kontextes oder diese
Inhaltsansichts-Struktur. Da es nur
diese Inhaltsansicht , die von diesen
Statuseigenschaften abhängt. Alles klar, wir sind fast
im Ziel. Wir müssen nur
die Kartenwerte vergleichen und dann Eigenschaften des Punktestatus entsprechend
aktualisieren. Das ist immer noch eine kurze Zusammenfassung. Jetzt lernen Sie, wie in Ihrem View-Code auf Eigenschaften
verweisen. Wir haben etwas über den
State Property Wrapper erfahren. Wir haben auch
einige neue Terminologie kennengelernt darunter fest codierte Werte, dynamische Werte und unveränderliche Werte,
was bedeutet, dass sie nicht geändert werden
können. In der nächsten Lektion
werden wir die Bedingungen durchgehen
und Werte mit if-Anweisungen vergleichen. Alles klar, wir sehen uns dort.
13. 12: Wenn die Anweisungen: Hallo und willkommen. In dieser Lektion
werden wir über
ein schnelles Konstrukt sprechen ,
mit dem Sie
Code schreiben können , der besagt, dass
dies jetzt einfach zu bedienen
ist, aber die leistungsstarke Syntax
wird es Ihnen ermöglichen drückt Logik auf einer
ganz neuen Ebene aus. Okay, mit dem gesagt, lasst uns gleich eintauchen. Alles klar, also habe ich hier einen
brandneuen Spielplatz. Ich möchte Ihnen zeigen, wie wenn
Aussagen funktionieren, bevor wir sie auf unser
Kriegskartenspielprojekt anwenden. Alles, was ich hier habe, sind ein
paar Konstanten, eigentlich mehr als ein paar, ich habe eine Reihe von Konstanten
mit verschiedenen einfachen Werten, einigen Ganzzahlen, Strings
und booleschen Werten. Und ich möchte
diese Konstanten verwenden um zu demonstrieren, wie
IF-Anweisungen funktionieren. Auch hier ist die if-Anweisung sehr mächtig, da
Sie Code basierend
auf bestimmten Bedingungen ausführen können. Also werde ich diese
Konstanten als meine Bedingungen verwenden. Werfen wir zunächst einen Blick auf eine grundlegende IF-Erklärung,
Deklaration. Ich tippe es
zuerst ein und erkläre dann jeden der Teile. Sie beginnen also mit dem Schlüsselwort
if und geben dann eine Art Wert oder Bedingung ein, die
zu einem booleschen Ergebnis ausgewertet wird. Also werde ich es einfach setzen. Und ich öffne
ein Paar geschweifte Klammern. Und hier drin werde ich einfach Hello World
drucken, oder? Und das ist an sich die
einfachste if-Aussage. Wie Sie sehen können,
beginnt mit dem
Schlüsselwort if und gefolgt von einem booleschen
Wert oder einer Art Codeanweisung, die
zu einem booleschen Ergebnis ausgewertet
wird, gefolgt von einer Reihe
geschweifter Klammern. Und in die
geschweiften Klammern
legen Sie den Code ein, den Sie ausführen möchten. Wenn die Bedingung zutrifft, ist e
in diesem Fall falsch, oder? Es wird
also nicht diesen Code ausführen, weil er nicht als wahr
ausgewertet wird. Wenn ich dieses E jedoch ändere
und stattdessen F teste, würde dieser Code ausgeführt
werden,
weil er als wahr ausgewertet wird. Jetzt kann es ziemlich
verrückt werden, weil man diese Dinge miteinander verketten
kann. Eine der Möglichkeiten,
sie miteinander zu verketten , ist die Verwendung von end, und das ist ein doppeltes kaufmännisches Und-Zeichen. Lassen Sie mich das hier also einfach
angeben. Und wie das funktioniert
ist, wenn Sie ein
doppeltes kaufmännisches Und-Und-Zeichen schreiben würden . Dann testen Sie jetzt beide Bedingungen und
weil Sie end verwenden, müssen
beide Bedingungen
wahr sein , damit
dieser Code soll ausgeführt werden. Also in diesem Fall, denn
f und g sind beide wahr, wahr und wahr bedeutet wahr. Okay? Und ein anderes Beispiel
ist, dass Sie oder verwenden können. Das sind also Doppelrohre. Der Pfeifenschlüssel,
viele Anfänger, sie sind sich nicht sicher,
wie sie ihn drücken sollen. Auf meiner Mac-Tastatur befindet sich
diese Taste direkt unter
der Entf-Taste und direkt über der Return-Taste, und es ist das Zeichen
auf der Backslash-Taste. Also muss ich die Shift gedrückt halten und ich muss den umgekehrten Schrägstrich drücken,
um das Rohr zu bekommen. Also doppelte Pfeifen, es könnte auf Ihrer Tastatur
anders sein. Dies ist ODER wenn Sie ein ODER
anstelle eines Endes verwenden und an solche
Bedingungen
verketten. Sie sagen, wenn
eine Bedingung eins wahr
ist oder Bedingung
zwei wahr ist, dann führen Sie diesen Code aus. Zum Beispiel sind f
und g beide wahr. Das wird also definitiv diesen Code
ausführen. Wenn ich f und e mache, ist
das ein falsch. Denken Sie daran, dass dieser Code weiterhin ausgeführt
wird da mindestens eine
der Bedingungen zutrifft. Auch hier kann das ziemlich
verrückt werden, weil ich mich
weiter ändern kann, ich kann weiter
oder ich kann dort sogar
ein Ende machen . Also lasst uns das machen. Aber diese Art von
wird jetzt verwirrend weil dies auf
verschiedene Arten gelesen werden kann. Ist es E und G? Und dann oder F? Oder ist es F oder E und G?
Die sehen, was ich sage. Denn wenn ich
Klammern um diese herum lege, könnte
das sinnvoller sein. Wenn ich das mache. Das heißt, wenn f
wahr ist oder E und G wahr sind, dann führe den Code aus. Ich könnte jedoch auch
Klammern so herumlegen. Wenn F oder E wahr ist und G wahr ist, führen
Sie den Code aus. So können Sie Klammern und
abgerundete Klammern verwenden, um zu unterscheiden, welche
Bedingungen zuerst ausgewertet werden sollen. Okay, bisher haben wir nur die booleschen Werte
verwendet, aber es gibt noch mehr. Ich möchte Ihnen die
Syntax für eine if-Anweisung zeigen bevor wir uns Ganzzahlen und Strings
ansehen. Zusammen mit der if-Anweisung können
Sie diese if-Anweisung auch erweitern , um eine andere Bedingung zu
testen, da dies nur
eine Bedingung testet, oder? Sie können dann
der schließenden geschweiften Klammer des ersten
Codeblocks folgen, oder? Sonst wenn, und dann
schreibst du eine andere Bedingung. Sagen wir also else-if. E, dann mach das sonst, wenn G, dann mach das. Was hier passieren wird, ist, dass es diesen Zustand
testen wird. Wenn dies als falsch ausgewertet wird, wird
es dann
den nächsten testen und es
wird herunterfallen. Wenn das falsch
ist, wird es zum nächsten
gehen. Zu jedem Zeitpunkt, während es diese Bedingungen
überprüft. Wenn einer von ihnen wahr ist, wird er in diesen Zweig
gehen. Es wird diesen
Codeblock ausführen und der Rest
überspringt. So können Sie in diesem Fall
drei verschiedene Zweige oder
Wege
testen drei verschiedene Zweige oder und nur einen auswählen, wobei
der erste wahr ist. Aber wenn man bedenkt
, dass es
diese Zweige von
diesen Bedingungen aus überprüft , meine
ich, von oben nach unten. Der erste, der das
trifft, ist also wahr. Das ist der Zweig, der
weitergehen wird. Und schließlich gibt es auch ein weiteres Merkmal
von if-Aussagen. Es kann eine Art Fang
für alle Zweige geben. Wenn keine der oben genannten
Bedingungen zutrifft, können
Sie
einen anderen Codeblock haben. Dieser Codeblock
läuft also ganz am Ende. Wenn keine der
Bedingungen zutrifft und keine
dieser Zweige ausgeführt hat. Das ist also so, als ob Ihr
Fang alle ausfallsicher sind. Und wieder
sind diese alle optional. Du kannst einen Elsif haben, du kannst keinen anderen haben wenns. Du kannst keine
anderen haben und du kannst
einfach ein anderes haben. Wenn diese Bedingung nicht stimmt, wird
er einfach hier runter kommen. Okay, also diese wenn Aussage wirklich mächtig
ist. Die Syntax ist wirklich
einfach zu verstehen, bietet Ihnen
jedoch so viel
Flexibilität, welche Codeanweisungen ausgeführt werden sollen je nachdem, was in Ihrer App
passiert. Okay, also mache ich das rückgängig damit wir hier
eine vollwertige
if-Aussage sehen können . Und ich zeige Ihnen,
wie Ganzzahlen oder
Strings möglicherweise als Bedingungen ausgewertet werden können. Jetzt habe
ich im Beispiel bisher nur auf
boolesche Werte verwiesen ,
und das ist einfach. jedoch mit
anderen Datentypen
wie Ganzzahlen und Strings arbeiten , müssen
Sie diese möglicherweise in
einer tatsächlichen Anweisung verwenden , um auszuwerten, um ein
boolesches Ergebnis zu erhalten, oder? zum Beispiel anstelle von g, Verwenden wir zum Beispiel anstelle von g,
was nur ein boolescher
Wert true ist, a.
Um
ein boolesches Ergebnis auszuwerten, muss
ich einen
Vergleichsoperator verwenden, oder? Also kann ich größer verwenden, als wenn
a größer als 0 ist, oder? Dies kann als wahr oder falsch ausgewertet
werden. Und abgesehen von größer als, hier sind noch ein paar
andere, die Sie benutzen können. Also größer als, kleiner als, größer als oder gleich, und Sie haben weniger
als oder gleich. Und dann gibt es Gleichheit. Bei Gleichheit verwenden Sie kein einziges Gleichheitszeichen
, da dies für die Zuweisung dient. Wie Sie hier oben sehen können, weisen
wir diese
Werte Konstanten zu. Um die Qualität zu vergleichen, verwenden Sie stattdessen
ein Doppelgleichheitszeichen. Also kann ich hier unten sagen, gleich 0, ist gleich 0,
und natürlich nicht. Diese Aussage hier
wird also als falsch ausgewertet. Und da dies
ein Endoperator ist, müssen diese
beiden Bedingungen zutreffen. Und weil dieser schon falsch
ist, wird er nicht in diesen Zweig
kommen. Wie auch immer. Wir können diese auch ändern. Wenn b also weniger
als drei oder vier ist, meine
ich, und wenn c gleich 10 ist. Dies sind also einige Beispiele für Vergleichsoperatoren, die als wahr oder falsch
ausgewertet werden. Jetzt
kannst du das auch für Strings tun. Sie können, Sie können
z. B. d auswerten , ist eine Zeichenfolge und Sie können testen, ob es gleich hallo ist. Das ist also eine Sache, die Sie mit Strings machen
können. Sie können immer noch größer
als oder gleich verwenden. Zum Beispiel, wenn wir h gleich Welt
gelassen hätten. Und wir können sagen, ob D größer als h
ist. Also können wir das tun. In diesem Fall wird
es das H mit dem
W. vergleichen und weil h
nicht größer als w ist, weil es vor W kommt, dann wird dies falsch sein. Eine weitere interessante
Sache, die ich Ihnen zeigen möchte ist die Verwendung des
Ausrufezeichens. Dieser wird also im Grunde genommen den booleschen Wert
umgedreht. Wenn g das war, stimmt
G, oder? Wenn ich das
Ausrufezeichen davor setze, wird
es im Grunde den booleschen Wert
umkehren. Also stimmt g. Ich habe das Ausrufezeichen. Es wird
es in „falsch“ verwandeln. Also wird es das nicht laufen lassen. Du könntest es zum Beispiel davor
stellen. Und ein Dutzend ist
ein nicht gleich 0, weil a eins ist, wie Sie dort oben sehen
können. Aber das
davor zu haben, wird
das wahr werden. Und jetzt wo ich darüber nachdenke, können
Sie auch die Ungleichheit testen. Also nicht gleich. Okay, also kann ich testen, ob ein nicht gleich
0 ist, was stimmt. Aber weil ich
dieses
Ausrufezeichen davor habe , wird
es auf „falsch“ umgestellt. So viel Flexibilität hier, und das ist nur
ein Beispiel, oder? So kompliziert muss es also nicht
sein. Jetzt möchte ich
zu unserem Kriegskartenspiel zurückkehren und mithilfe der
if-Anweisung feststellen , welche Karte größer ist, und dann entweder den
Spielerstand oder den CPU-Score
erhöhen. Alles klar, also hier habe ich
das Kriegskartenspiel-Projekt. Und wenn Sie sich diesen Teil
hier
ansehen , in dem wir die Punktzahl
aktualisiert
haben, erhöhen wir einfach die CPU und die Punktzahl des
Spielers mit jeweils
einem Deal des Buttons. Sie nun erfahren haben, ob Anweisungen auf dem
Xcode-Spielplatz vorhanden sind, bin
ich mir sicher, dass es sehr
trivial für Sie es so
zu implementieren, dass Sie Player mit
dem CPU-RAM
vergleichen und sehen welche Zahl ist größer, um zu bestimmen, welches Ergebnis aktualisiert werden soll. Nun, weil wir unsere Vermögenswerte
korrekt als das niedrigste
und ACE
mit einem Wert von 14
gekennzeichnet korrekt als das niedrigste
und ACE haben. Es ist sehr trivial zu vergleichen. Man vergleicht einfach diese
Endnummer, oder? Und im Wesentlichen
ist das die Zufallszahl. Wenn Sie also denken, dass Sie dies tun können, pausieren Sie das Video jetzt und probieren Sie es selbst aus. Du wirst viel lernen. Ich verspreche, selbst wenn du es
versuchst und es nicht verstehst, wird
die Lektion noch viel mehr
bleiben. Also mach weiter und pausiere das Video, probiere es aus und nimm
es dann auf und sieh mir zu, wie ich es hier mache. In Ordnung, also willkommen zurück. Lassen Sie uns diese
if-Anweisung implementieren, um zu sehen , welche Karte größer ist. Also fange
ich mit „if“ an. Und ich werde zuerst testen, ob die Nummer des Spielers
größer ist als die CPUs Nummer. Ordnung, ich werde
größer verwenden als, wenn das der Fall ist, dann werde ich den Spielerstand
erhöhen. Ansonsten werde ich nur
den CPU-Score erhöhen. Jetzt. Ich interessiere mich nicht für Bindungen, und deshalb vergleiche ich die
Gleichheit zwischen den
beiden Zufallszahlen nicht . Aber du könntest
das definitiv in deiner Version machen ,
wenn du möchtest. Eigentlich gibt es ein Problem
damit , wie
ich es hier mache. Die CPU hat einen unfairen Vorteil ,
da die CPU
im Falle eines Unentschieden mit
dieser else-Anweisung
den richtigen Punktestand erhält . Deshalb
muss ich den anderen Fall irgendwie testen. Also werde ich testen - ob der
CPU-Rand größer ist
als der Spieler, dann CPU-Punktzahl plus eins. Andernfalls, wenn diese beiden
Bedingungen nicht zutreffen, dann ist es ein Unentschieden und ich möchte
nichts tun. Alles klar, probieren
wir das mal aus. Also werde ich wieder auf die
Live-Vorschau klicken, und wir machen es einfach
hier im Canvas. Ich werde den Deal machen. 14 ist also definitiv
größer als fünf. Der Spieler erhält also eine Punktzahl. Jack ist definitiv,
nun, das ist ein, das ist eine 11 ist größer als 3, vier ist größer als drei. Es scheint also richtig zu
funktionieren. Herzlichen Glückwunsch, das
Kriegskartenspiel ist abgeschlossen. Sie haben gelernt, Benutzeroberflächen zu
erstellen, in Swift zu programmieren, und Sie haben
Ihre erste App fertiggestellt. Denken Sie an den ersten Tag
dieser 14-tägigen Herausforderung zurück. Wie hast du dich damals gefühlt? Warst du nervös, dass du glaubst,
du könntest das alles machen? Und jetzt schau, wie
weit du gekommen bist. Wie fühlst du dich jetzt über
App-Entwicklung? Jetzt habe ich versucht, dies
so einfach wie möglich
verständlich zu machen , und ich hoffe, dass Sie einige neue Fähigkeiten erwerben
können. Jetzt weiß ich, dass
ich das wie das Ende klingen lasse, aber es ist wirklich erst der
Anfang deiner Reise. In der nächsten Lektion erzähle
ich Ihnen, was die nächsten Schritte
sind und
wohin Sie von hier aus gehen müssen.
14. 13: Bonus-Challenge: Hallo und willkommen zur Lektion 13. Nun, in dieser Lektion, wird
es eher eine
praktische und
praktische Herausforderung sein . Ich möchte, dass du versuchst,
diese App selbst zu erstellen. Jetzt verfügen Sie über alle Fähigkeiten, die Sie benötigen, basierend auf den Lektionen eins bis 12. Und diese Übung wird eine großartige Möglichkeit sein,
das Gelernte zu verstärken und zu diesem
Zeitpunkt
auch Wissenslücken
zu erkennen , damit wir es
überprüfen und auch
herausfinden können es
überprüfen und auch
herausfinden was es ist, dass
Sie auf den neuesten Stand kommen müssen , bevor Sie fortfahren. Okay, also lass mich einfach durch diese App
gehen. Du hast einen Titel, du hast eine Anzahl von Credits, du hast ein paar Bilder. Und wenn Sie diesen Knopf drücken
, werden die Bilder nur zufällig. Wenn sie nicht übereinstimmen, verlieren
Sie Credits. Aber wenn du
drei übereinstimmende bekommst, was ich
gerade nicht tun kann. Oh, da sind wir los. Dann würdet ihr Credits gewinnen. Das ist also dem Kriegskartenspiel sehr
ähnlich, außer dass es jetzt
drei Dinge gibt , die Sie anstelle von zwei
randomisieren. Und die Image-Assets befinden sich in
der Beschreibung in einem Link. Sie können also sicherstellen, dass
Sie sich die schnappen. Dann hast du
alles was du brauchst. ob Sie denken, dass dies zu
einfach ist , ob Sie denken, dass dies zu
einfach ist oder wenn es zu
schwer ist, ich empfehle Ihnen dringend,
es auszuprobieren , weil es wirklich
der beste Weg ist, um zu lernen, auch wenn Sie stecken bleiben. Wenn Sie sich die Lösung ansehen
und herausfinden, wie
Sie das Hindernis überwinden können
, an dem Sie feststecken. Es wird besonders
bedeutungsvoll sein und es wird wirklich helfen, es
in den Speicher zu übertragen. Und diese Überzeugung über
praktisches Lernen
ist auf mein eigenes Versagen
zu Beginn zurückzuführen , als
ich versuchte, iOS zu lernen. Das ist also nicht nur etwas, das ich gelesen habe
oder etwas was ich gehört habe. Aus meiner eigenen persönlichen
Erfahrung
gibt es nichts anderes, was als
beste Art zu lernen
ersetzen kann .
15. 14: Was ist nächstes?: Du hast es geschafft. Wo gehst du von hier aus? Was lernst du als Nächstes? Nun, es gibt immer noch eine
Menge Fähigkeiten zu meistern, bevor Sie endlich
jede Art von App erstellen können, die Sie wollen. Aber ich hoffe, dass
es Ihnen geholfen hat, zumindest
das Kriegskartenspiel zu machen und
diese Herausforderung zu meistern, einige mentale Barrieren darüber zu überwinden einige mentale Barrieren darüber zu ob Sie dies schaffen können oder nicht. Denn jetzt solltest du
wissen, dass du das kannst. Und es ist nur eine Frage der Zeit. Mehr Erkenntnisse, mehr
Hindernisse überwunden
und mehr Übung, bevor
Sie Ihr Ziel erreichen, werde
ich Ihnen
die nächsten fünf Dinge mitteilen, die Sie tun
können, um Fortschritte
auf Ihrer App-Reise zu erzielen. Nummer eins oder mehrere Ansichten und Container durch
das Kriegskartenspiel, Sie haben bereits von einer Handvoll von ihnen
erfahren, wie Text,
Bildschaltflächen, Stacks, aber es gibt viel mehr VMs und Container, über die Sie
lernen können, wie Umschalter, Picker, Status, Balkenformen, Raster, Listen, und die
Liste geht einfach weiter. Jetzt zu lernen, wie man
mehr Ansichten und Container benutzt ist wie eine
Lkw-Ladung von Lego-Stücken zu bekommen. Ihre Optionen werden
sich erheblich erweitern. Nummer zwei, mehr Arten von Apps. Warum? Nun, denk darüber nach. Nichts Neues
kommt jemals von Grund auf neu. Sie greifen immer auf
Ihre bisherigen Erfahrungen zurück, was Sie gesehen haben, was Sie
getan haben, was Sie versucht haben. Wenn Sie also Ihre eigene App
erstellen möchten, können Sie an
dieser Stelle Ihrer
Reise am besten so dieser Stelle Ihrer
Reise vielen verschiedenen
Arten von Apps wie möglich
ausgesetzt werden. Mit jeder neuen App lernen
Sie
neue Architekturen, neue Muster und neue
Möglichkeiten, Dinge zu tun. Wie
navigiert man zum Beispiel von einem
Bildschirm zum nächsten? Wie lädt man
Daten aus dem Internet herunter? Wie speichert man
Daten in einer Datenbank? Und wie lässt man Benutzer Konten
erstellen und sich einloggen? Dies sind alles verschiedene Arten von Apps, denen Sie ausgesetzt sein müssen , bevor Sie dieselben
Elemente in Ihre App
integrieren können . Nummer drei, mehr,
Xcode und Swift. In dieser Herausforderung haben
wir uns mit den
Swift-Grundlagen und dem
Navigieren im nächsten Code leicht befasst , aber beide haben definitiv
mehr Tiefe. Azure Apps werden
in Ihren Projekten komplexer, werden größer, Sie werden auf
mehr Probleme und
mehr Geld stoßen . Und Sie
benötigen eine tiefere Beherrschung der
Swift-Programmiersprache. Wie lernt man
schneller und Xcode? Nun, es geht zurück darauf, mehr Apps zu
erstellen. Während Sie jede App erstellen, werden
Sie natürlich
schnellere und Xcode-Techniken lernen . Nummer 4, MVVM. Jetzt ist dieser in der Swift-Benutzeroberfläche ziemlich
wichtig. Dies ist das
Hauptarchitekturmuster und es steht für Model-View-ViewModel im
Kriegskartenspiel, das Sie gemacht haben. Wir hatten den Ansichtsteil und wir hatten einige
Dateneigenschaften darin. In einer größeren Swift-UI-App hätten
Sie jedoch Modelle, die Ihre Daten
darstellen,
und Modelle anzeigen, die Ihre Ansichten
unterstützen. Dieses Architekturmuster existiert in jeder größeren Swift-UI-App. Es ist also ziemlich
wichtig zu wissen, dass Sie Google- oder
YouTube-Suche auf MVVM durchführen, um es
auf konzeptioneller Ebene zu verstehen. Und dann, wenn Sie
das nächste Mal ein schnelles UI-Tutorial machen, versuchen Sie
entweder, das Muster
selbst zu erkennen oder wenn Sie Ihre eigenen Swift
erstellen versuche
ich definitiv , das Muster
in die Praxis umzusetzen. Nummer fünf, mehr
Apple-Frameworks. Apple hat eine Menge Frameworks , die Sie mit Ihrer App nutzen
können. Fügen Sie einfach das Framework
zu Ihrem Xcode-Projekt hinzu, lesen Sie die Dokumentation
und Sie Ihrer App
neue Funktionen hinzu,
wie maschinelles Lernen ,
Augmented Reality usw. Jetzt wird dies
etwas mehr Erfahrung erfordern da Sie die Dokumentation lesen und
verstehen müssen. Aber es ist eine gute Fähigkeit, mit dem
Training zu beginnen , denn
jedes Jahr
wird es neue Tools und neue Plattformen und
neue
Frameworks geben , die Sie lernen können. Als App-Entwickler hört
das Lernen nie auf und
Ihre Fähigkeit, hört
das Lernen nie auf und schnell zu lernen und Dinge
auszuprobieren, wird Ihren
langfristigen Erfolg wirklich bestimmen. Dies sind die fünf Bereiche, die
ich Ihnen empfehle
, Fortschritte
auf Ihrer App-Reise zu erzielen. Ich möchte Ihnen vielmals dafür danken, dass Sie diese Herausforderung durchgehalten haben
und mit mir gelernt haben. Ich hoffe, du hattest eine
tolle Erfahrung. Und wenn du es getan hast,
teile es bitte mit deinen
Freunden und deiner Familie. Bitte hilf mir,
das Wort zu verkünden und erzähle allen von
Code mit Chris. Ich schätze dich so
sehr und danke dir mich
Teil deiner App-Reise sein
lässt. In Ordnung, wir sehen uns
in der nächsten Lektion.