Swift2 Video Tutorials

  1. letztes Jahr

    GLSS

    12 Dec 2015 Administrator

    [center]Swift2 Tutorials[/center]

    #1 Variablen und Konstanten

    Dieses Swift Tutorial auf deutsch ist der Einstieg in eine faszinierende Technologie, die uns auf Jahre hinweg begleiten wird. Denn mit Swift2 hat Apple eine sehr gute Sprache noch einmal besser gemacht. Die Swift Tutorial Video Serie ist ein Einstieg in die wichtigsten Grundlagen. Am Ende der Reise entwickelst Du sogar eine erste App für iOS9!

    Im ersten Video stehen Variablen und Konstanten im Vordergrund. Wenn Du von einem Objective-C Hintergrund kommst, kennst Du vielleicht Klassen wie NSArray und NSMutableArray? Wenn Daten verändert wurden, gab es wie beim Array häufig separate Lösungen. In Swift ist dies komplett anders. Zum einen kann jedes Objekt variabel (veränderbar) oder konstant (nicht veränderbar) sein.

    Hinzu kommt, dass auch die primitiven Datentypen einfach über ein Schlüsselwort als Konstante (let) bzw. als Variable (var) angelegt werden können. Wie das genau funktioniert, erfährst Du in genau diesem Video.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #2 - Variablennamen

    Grundlegend wichtig ist für die Arbeit mit Swift natürlich so einiges. Da klingt ein Video mit Basiswissen zu Variablennamen schon fast wie eine Zumutung? Oder gar eine Beleidigung Deiner Fähigkeiten? Weit gefehlt!

    Natürlich reden wir über Basiswissen. Aber in Swift findest Du selbst als gestandener Programmierer noch einige wirklich tolle neue Details.

    Variablen und Konstanten in Swift sind besonders. Es ist die erste Sprache mit der ich durchgehend und unglaublich konsequent Unicode (UTF-8) Unterstützung erlebt habe. Du wirst begeistert sein!

    Ein Smily als Variablen? Warum nicht! Wie wäre es mit japanischen oder chinesischen Schriftzeichen? Kein Problem! Oder π als Platzhalter für die Kreiszahl Pi? Nichts leichter als das!

    Insgesamt faszinierend, in teilen eher ein Nebenprodukt (wie die Smilies) und an vielen Stellen auch wirklich nützlich. Sprechender Code ist bei der Entwicklung immer wichtig. Warum also nicht sogar in der nativen Sprache die Inhalte kenntlicher machen - angefangen beim Variablennamen?

    Du wirst nicht glauben, welche Variablennamen möglich sind. Aber, am besten schaust Du Dir das zweite Video aus dem Swift2 Tutorial einfach kurz an. Viel Spaß dabei!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #3: Typ Annotationen

    Swift ist typsicher. Das bedeutet, dass Variablen und Konstanten einen festen Datentyp besitzen, der auch nicht wie bspw. wie in PHP oder JavaScript wahllos geändert werden kann. Eine Variable wird bei der Deklaration auf einen Typ festgelegt. Das können bspw. primitive Datentypen wie Int, Double oder Bool sein. Auch der Typ String, der unter Swift keine Klasse mehr ist (sondern ein struct), wäre neben anderen komplexen Datentypen eine mögliche Option.

    Swift ist bei der Erkennung und Verwaltung der Datentypen unglaublich effizient. Wird die Variable bei der Deklaration initialisiert, erkennt Swift den Datentyp automatisch. Bis auf wenige Ausnahmen ist es nicht nur überflüssig in diesem Fall manuell einen Datentyp zu nennen. Es verstößt sogar gegen guten Stil und wird ausdrücklich nicht empfohlen. Die Syntax soll wo immer es geht auf unnötiges verzichten.

    Was aber, wenn Du eine Variable nur deklarierst, also vielleicht erst später oder im Zweifel auch gar keinen Wert zuweist? Ein prominentes Beispiel: Die Eigenschaften einer Klasse. Oder auch die Parameter eine Funktion bzw. Methode? Die Antwort: Typ-Annotationen. Dabei handelt es sich um Hinweise zum Datentypen.

    Und wie Du die genau mitteilst, zeigt Dir Video #3 im Swift2 Tutorial.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #4: Daten ausgeben mit print()

    Was unter Objective-C das NSLog und bis Swift1.2 das println() war, ist seit Swift2 nur noch print(). Daten in der Konsole ausgeben ist in Zeiten von einem Debugger zum Glück nicht mehr die gängige Methode zur Fehlersuche. Es kann aber trotzdem mal einfacher sein eine Liste von 20 Werten auszugeben, als immer wieder mit dem Debugger eine Schleife Zeile für Zeile durchzuarbeiten.

    Wenn Du von Swift1 noch println() gewohnt bist, lernst Du in diesem Video wie es ab jetzt funktioniert. Der Zeilenumbruch ist nur noch ein sogenannter Terminator für die Ausgabe. Er kann wegfallen oder auch durch andere Zeichen ersetzt werden. Mehr dazu im Video.

    Klingt nach trivialen Inhalten? Trotzdem sind auch diese Grundlagen für das Verständnis für die Praxis wichtig. Getreu dem Motto - Don't be to cool to go to school! - empfehle ich von ganzem Herzen, die vermeintlich einfachen Lektionen nicht zu überspringen. Ich kenne das Phänomen selbst: Diese sehr einfachen Inhalte sind schnell erklärt und bildlich vom Zuschauer nachvollzogen. Aber: Starte mal einen Editor mit nichts als weißer Fläche darin. Schon wendet sich das Blatt. Eine Sprache verstehen und sie "sprechen" zu können, sind zwei verschiedene Paar Schuhe.

    Das alles - und noch viel mehr - wirst Du brauchen, wenn die erste iOS-App mit Swift2 auf dem Programm steht.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #5: Kommentare in Swift

    Software wird gut, wenn der Quellcode lesbar und erweiterbar ist. Je besser und sprechender der Code ohne zusätzliche Dokumentation zu verstehen ist, desto besser hat der Entwickler gearbeitet.

    Neben gut gewählten Bezeichnungen für Variablen, Klassen und Methoden sind auch zusätzliche Kommentare ein wichtiger Schritt auf dem Weg zum optimalen Verständnis. Zudem sind Kommentare auch bei der Entwicklung nützlich. Immerhin kannst Du ganze Codeabschnitte zum Testen auch deaktivieren. Dabei spricht man vom "auskommentieren".

    Alles in allem sind Kommentare im Quellcode also sehr wichtig. Selbst wenn Sie wie ein alter Hut klingen, solltest Du die beiden wichtigen Kommentararten und ihre Anwendung auch in Swift kennenlernen.

    Genau dafür ist dieses Video gedacht. Viel Spaß damit!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #6: Semikolon in Swift

    Das Semikolon spielt in vielen Programmiersprachen eine besondere Rolle. Fast alle Sprachen mit denen ich sonst regelmäßig arbeite, fordern dass jede Anweisung am Ende der Zeile beendet wird - mit dem Semikolon. PHP, C/C++, Java, JavaScript und Co. und auch Objective-C sind heiße Kandidaten dieser Kategorie.

    In Swift spielt das Semikolon nun eine neue Rolle. Es ist am Ende der Zeile nicht notwendig, kann aber genutzt werden um Statements zu beenden. So kannst Du in einer Zeile mehrere Anweisungen unterbringen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #7: Datentypen in Swift

    In jeder Programmiersprache gibt es unterschiedliche Datentypen. Das geht von Zeichenketten, über ganze Zahlen bis hin zu Zahlen mit Nachkommastellen. Je nach Sprache werden auch Wahrheitswerte und andere Arten über spezielle Datentypen abgebildet. Genauso ist es in Swift auch.

    In diesem Teil vom Swift2 Tutorial lernst Du die primitiven Datentypen kennen. Sie sind wichtig, um Variablen und Konstanten zu erzeugen.

    Außerdem lernst Du die Typsicherheit von Swift kennen. Variablen und Konstanten müssen nicht mehr wie unter Objective-C explizit mit einer Typannotation deklariert werden. Der Swift-Kompiler oder Pre-Prozessor ist sehr intelligent und zuverlässig. In Swift werden Typen wirklich nur dann fest vorgegeben, wenn dies der Funktion dient. Ziel ist es immer, die Syntax möglich schlank und aufgeräumt zu halten.

    Ich zeige Dir, dass Swift trotz einem anderen ersten Anschein sich stark von bspw. Sprachen wie PHP und JavaScript unterscheidet. Die Datentypen werden erkannt, die Variablen und Konstanten aber darauf festgelegt.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #8: Typumwandlung

    Es gibt häufiger Situationen, in denen unterschiedliche Datentypen miteinander verrechnet werden sollen. Das funktioniert nicht immer gleichermaßen, manchmal ist dies gar nicht einfach möglich und in anderen Fällen kann es zu Rechenfehlern kommen.

    In diesem Video im Swift2 Tutorial lernst Du die Grundlagen der Typumwandlung unter Swift kennen. Außerdem zeige ich Dir, was es dabei unbedingt zu beachten gilt.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #9: Tuples

    In vielen Fällen gibt es zu einem Wert mehr als nur eine Ausdrucksweise. Ein tolles Beispiel sind Fehler. Sie können einen Fehlercode haben sowie eine oder mehrere Fehlermeldungen (zum Beispiel eine kurze und eine ausführlichere).

    Oder mehrere Rückgabewerte einer Funktion bzw. Methode? Auch nur über Dictionaries oder Container-Klassen / Models möglich. Es musste ein Dictionary oder ein vergleichbares Konstrukt geschaffen werden.

    Mit Tuples gibt es nun Wertepaare, über die mehrere zusammengehörige Werte gruppiert werden können. Die x- und y-Koordinaten, Fehlercode und -meldung oder auch mehrere Rückgabewerte in Methoden, lassen sich damit perfekt abbilden.

    Mehr Informationen findest Du inkl. einiger Beispiele im neunten Video des Swift2 Tutorials.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #10: Optionals

    Optionals sind ein syntaktisches Stilmittel, das auf evt. nicht vorhandene Werte hinweist. Ein Wert in der Variablen ist "optional".

    Dabei kann jeder Datentyp als Optional gekennzeichnet werden. Das ist ein großer Unterschied zu Objective-C Zeiten. Hier wurde teilweise gegen nil entwickelt - allerdings nur bei Referenzen. Wurde ein Objekt übergeben, musste geprüft werden ob der Wert vielleicht "nil" ist. Aber: Es funktionierte nur bei Objekten. Außerdem gab es keine Syntax um dies von Beginn an klarzustellen.

    Optionals lösen das Problem. Bei der Verarbeitung muss ein Entwickler damit rechnen, dass in der entsprechenden Variablen kein Wert hinterlegt wurde - sowohl bei primitiven als auch bei komplexen Datentypen.

    Im Video lernst Du Optionals kennen!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #11: Strings

    Ohne Zeichenketten ist eine höhere Programmiersprache nahezu nutzlos. Das sie in Swift verfügbar sind, überrascht daher wenig. Dennoch gibt es gerade im Vergleich zu Objective-C einige Unterschiede, vereinfachte String-Literale und Aspekte wie die Stringinterpolation, die Du als Swift-Entwickler kennen solltest.

    In diesem Teil vom Swift Tutorial, lernst Du wichtige String-Features kennen. Die nutzen wir an verschiedenen Stellen im weiteren Verlauf. Darüber hinaus begegnen sie Dir bei der täglichen Arbeit mit iOS immer wieder.

    Ein wichtiger Hinweis für Objective-C Entwickler: In Swift ist ein String ein struct, also ein Value-Type. Das bedeutet vereinfacht ausgedrückt: Wenn ein String kopiert wird, wird der Wert kopiert. Bei Objective-C war ein String ein Reference-Type, genau genommen eine Instanz der Klasse NSString. Es wurde nicht der Wert kopiert, sondern die Referenz auf das Object.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #12: Arithmetik

    Um grundlegende Rechenoperationen durchzuführen benötigst Du was? Ok, Zahlen zum rechnen. Darüber hinaus sind aber auch Operatoren wichtig. Da gibt es auf niedrigster Ebene zum Beispiel das Rechenzeichen für Plus, Minus, Mal und Geteilt. Eine Programmiersprache muss dies ebenfalls abbilden.

    Zusammengefasst spricht man von der Arithmetik. Sie umfasst unter anderem die Grundrechenarten wie die Addition, Subtraktion, Division und die Multiplikation.

    In diesem Video lernst Du die wichtigsten Grundlagen kennen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #13: Der Remainder Operator (Modulo in Swift)

    n jeder höheren Programmiersprache gibt es die Modulo Operation. Das gilt natürlich auch für Swift. Mit dem sogenannten Restwertoperator kann der Restwert einer Ganzzahldivision bestimmt werden.

    In Swift gibt es an vielen Stellen kleine Verbesserungen und Optimierungen. Das zieht sich quer durch die ganze Sprache. Und selbst bei einem so unscheinbaren Operator (dem Prozentreichen '%'), hat Apple etwas verbessert.

    In diesem Video vom Swift2 Tutorial lernst Du, dass der Remainder Operator im Gegensatz zur reinen Module-Operation auch mit negativen Werten umgehen kann. Und noch wichtiger: Sogar mit Kommastellen!

    Alle Details rund um Modulo, Remainder Operator und den Restwert findest Du in diesem Video. Viel Spaß dabei!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #14: Inkrementieren / Dekrementieren in Swift

    Inkrementieren und Dekrementieren von Variablen ist zum Beispiel in Java oder Objective-C mit einem speziellen Operator möglich. Ebenso ist dies in Swift umgesetzt. In diesem kurzen Video erfährst Du, wie in Swift den Wert erhöhen bzw. verringern kannst.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #15: Vergleichen von Werten

    Vergleiche sind das Salz in der Suppe. Deshalb bietet Swift Dir als Entwickler auch eine ganze Reihe verschiedener Vergleichsoperatoren an. Benötigt werden sie zum Beispiel bei if-Bedingungen, Schleifen und Fallunterscheidungen mit Switch. Ein Thema, worüber wir also unbedingt gesprochen haben sollten.

    Einige Vergleiche kennst Du sicherlich bereits aus dem Mathematik-Unterricht! Sind Werte gleich? Ist Wert A größer als B? Ist B kleiner oder gleich A? Das sind die bekannten Vertreter. Ebenso wichtig ist gerade bei der Software-Entwicklung auch eine Prüfung auf Ungleichheit.

    In diesem Video lernst Du die grundlegenden Operatoren an einigen Beispielen kennen. Sie sind die Vorbereitung auf viele Themen wie logische Operatoren und Kontrollstrukturen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #16: Logische Operatoren

    Bedingungen werden über den Vergleich von Werten definiert. Ist Wert A größer als Wert B? Ist Wert B kleiner oder gleich Wert C? Beispiele gibt es in der Programmierung einige.

    Im letzten Teil vom Swift2 Tutorial ging es um die einzelnen Vergleiche, die isoliert stattfinden können. Was aber, wenn Wert A kleiner oder gleich Wert B sein soll, aber gleichzeitig auch größer als Wert C sein soll? Theoretisch müssten zwei Bedingungen verschachtelt werden. Das erhöht zum einen die Komplexität der Software. Hinzukommt: In einer Schleife ist das nicht ohne weiteres möglich. Es muss zu Beginn der Schleife geprüft werden.

    Die Antwort bieten logische Operatoren. Sie übertragen die Aussagenlogik auf die Programmierung, auch in Swift. Einfacher ausgedrückt ermöglichen sie die Verknüpfung mehrerer Bedingungen.

    Zu unterscheiden gilt es speziell zwischen dem logischen ODER und dem logischen UND. Und genau darum geht es in diesem Video. Viel Spaß dabei!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #17: Arrays in Swift

    In jeder modernen Programmiersprache gibt es Arrays. Das sind Listen gleicher Datentypen, die in der gleichen Variable abgespeichert werden. Allerdings hat in dieser Variable jeder Wert einen eigenen Index. Genau so ist es in Swift auch.

    Auch unter Swift beginnen Array-Indizes bei Null und steigen an. Das erste Element ist unter dem Index "0", das zweite unter dem Index "1" usw. erreichbar. Daraus ergibt sich das ein Element n immer im Index n-1 zu finden ist.

    Im heutigen Teil vom Swift2 Tutorial lernst Du, wie Arrays erzeugt werden, neue Elemente angehangen werden, ein Array deklariert wird und wie Elemente entfernt werden können. Natürlich darf auch der lesende Zugriff auf die Elemente nicht fehlen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #18: Dictionaries verwenden

    Ein Dictionary in Swift ist eine Datenstruktur, die einem Array gar nicht unähnlich ist. Vieles "fühlt" sich ähnlich an. Ein großer Unterschied ist die Adressierung von Werten. In einem Array sind alle Werte unter einem numerischen Index erreichbar. In einem Dictionary wird dieser numerische Index durch einen (nahezu) beliebigen Wert ersetzt.

    Das Konzept ist nicht nur Gegenstand von Swift, sondern gab es bspw. in Form vom NSDictionary auch bereits im Objective-C Umfeld. Für die Arbeit mit den verschiedenen iOS-Frameworks, den CocoaTouch Klassen und der API sind sie daher extrem wichtig.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #19: Swift Sets

    Sets sind genau wie Dictionaries und Arrays Datenstrukturen. Dabei gleichen sie Arrays noch mehr, da die Werte nicht unter einem speziellen Schlüssel abgespeichert werden.

    In einem Set sind die Werte im Gegensatz zum Array unsortiert abgespeichert. Das sollte immer im Hinterkopf bleiben, denn bei der Verarbeitung ist die Reihenfolge nicht festgelegt.

    Ein Beispiel hilft, dies zu verdeutlichen. Wenn Du Namen protokollierst, und dabei nur die Anwesenheit der Teilnehmer erfassen willst, reicht ein Set in den meisten Fällen aus. Immerhin müssen nur die Namen erfasst werden. Wenn Du aber eine Warteliste mit Namen erstellst, spielt die Reihenfolge natürlich eine zentrale Rolle. In diesem Fall wäre ein Array die bessere Wahl.

    In diesem Teil vom Swift2 Tutorial lernst Du, wie Du mit Sets in Swift umgehst. Viel Spaß dabei!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #20: for ... in Schleifen verwenden

    Mit for ... in Schleifen kannst Du in Swift viele Anwendungsfälle abdecken. Unter anderem kannst Du Arrays und Dictionaries sehr bequem verarbeiten.

    Auch hier hat Apple erneut etwas Feenstaub verstreut! So kannst Du bspw. gezielt die Variable für den Schlüssel oder den Wert ausblenden und so den lokalen Namespace aufgeräumt halten.

    Auch in Kombination mit dem Range Operator kann die for-in Schleife Dein bester Freund sein. Egal ob geschlossene oder offene Ranges, beide Fällen können wunderbar abgedeckt werden.

    Wie genau die Schleife funktioniert, lernst Du in diesem Video.Viel Spaß dabei!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #21: while-Schleifen

    Swift while-Schleifen erinnern in vielerlei Hinsicht an das Objective-C Pendant. Wenn Du iOS-Apps entwickeln möchtest, ist dies aber nur ein Teil vom großen Ganzen.
    Eine while-Schleife ist immer dann perfekt geeignet, wenn Du im Vorfeld die genaue Anzahl der Wiederholungen nicht kennst. Natürlich kann auch hiermit einfach ein Array verarbeitet werden. Ich nutze dafür allerdings lieber for-Schleifen.

    Ich zeige dir in diesem Video wie eine while-Schleife mit Swift funktioniert, wie sie aufgebaut wird und worauf Du unbedingt achten musst. Viel Spaß dabei!

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #22: Fehlerbehandlung mit try/catch

    Swift Fehlerbehandlung erinnert in vielerlei Hinsicht an die Exceptions anderer Sprachen. Streng genommen handelt es sich aber nicht um Exceptions als eigene Instanz. Stattdessen werden Fehler als enum deklariert, die vom ErrorType erben. Auch Apple spricht nicht von Ausnahmebehandlung.

    Methoden signalisieren über das Keyword "throws" an, dass sie ggf. Fehler werfen. Das zwingt Entwickler dazu sie beim Aufruf entsprechend zu behandeln. Hier gibt es verschiedene Wege.

    Und auch hier gibt es im Gegensatz zu anderen Sprachen wieder neues in Swift. Erste Grundlagen zur Fehlerbehandlung lernst Du in diesem Video.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    #23: Funktionen in Swift nutzen

    Funktionen spielen in Swift eine zentrale Rolle. Es besteht die Möglichkeit einzelne Funktionen losgelöst von Klassen (class) und Strukturen (struct) zu definieren. Ebenfalls wichtig: Closures, bei denen es sich um anonyme Funktionen handelt. Sie sind den Blöcken aus Objective-C sehr ähnlich. Zu guter letzt gibt es natürlich weiterhin Methoden im Kontakt der Objektorientierung.

    In diesem Video lernst Du mit Swift Funktionen zu definieren, Parameter festzulegen und lernst das Konzept der Rückgabewerte kennen.

    ---------------------------------------------------------------------------------------------------------------------------------------------------------

    Vielen Dank an Jan Brickmann für die tollen Videos.
    Wir wünschen allen viel Spaß und Erfolg beim Zuschauen und Lernen :)

    Blog: http://codingtutor.de/

 

oder registriere Dich, um zu antworten!