G

GLSS

Administrator

Zuletzt aktiv [hidden]

  1. letztes Jahr
    j M Y, g:ia \G\M\TO

    [center]

    Swift Tutorial - Grundlagen für Ein- und Umsteiger

    [/center]

    #1: Variablen, Konstanten und Playgrounds

    Auftakt zu einer neuen Themenserie: Apple Swift. Die Sprache hebt ab und übernimmt in Windeseile den iOS und Mac OS X Markt. Swift ist dabei sowohl für Einsteiger als auch für Objective-C Experten ein Thema. Die gesamte iOS-Bibliothek steht auch unter Swift zur Verfügung. Selbst externe Bibliotheken, die nur in Objective-C verfügbar sind, können über Bridging-Headers einfach weiterverwendet werden.

    Im ersten Video dazu lernst Du erste Grundlagen und die Xcode-Playgrounds kennen. Du arbeitest mit eigenen Variablen, Konstanten und lernst das Swift Konzept zur Unterscheidung von "Mutable" und "Immutable" kennen. In Swift kann jeder Datentyp als "veränderbar" bzw. "nicht veränderbar" deklariert werden. Unter Objective-C waren dafür noch separaten Datentypen notwendig. Ich zeige Dir am Beispiel, wie das geht.

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

    #2: Datentypen in Swift

    Swift ist eine typsichere Sprache. Apple ist aber eine Gradwanderung gelungen. Der Interpreter ist unglaublich stark und erfordert nicht wie bspw. Objective-C die exakte Annotation vorab. In diesem Video lernst Du die grundlegenden Datentypen kennen.

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

    #3: Optionals verwenden

    Mit Swift führt Apple neue Konzepte, Sprachelemente und eine überarbeitete Syntax ein. Dazu gehören auch die sogenannten Optionals. Ein Optional-Typ signalisiert, dass der Wert einer Variable vielleicht nil (nicht vorhanden) ist. Eine ähnliche Konvention gab es unter Objective-C, aber keine explizite Möglichkeit dieses Konzept mit der Sprache durchzusetzen. Hier erfährst Du wie Du sie benutzt.

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

    #4: Tuples in Swift verwenden

    Apple hat in Swift einige neue Features eingebaut. So gibt es nun bspw. auch Tuples. Wie Du mit dieser Struktur arbeitest, lernst Du in diesem Video.

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

    #5: Dictionaries und Arrays verwenden

    Arrays und Dictionaries gehören unter Swift zum Handwerkszeug. In diesem Video lernst Du beide Konstrukte näher kennen.

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

    #6: Schleifen verwenden

    Schleifen sind in jeder Programmiersprache ein wichtiges Instrument. Auch in Swift werden damit die üblichen Aufgaben erledigt. Dazu gehört natürlich bspw. Die Verarbeitung von Arrays oder auch Dictionaries.

    Für die Erforschung der Schleifen in Swift bietet sich Dir mit den Xcode Playgrounds das perfekte Werkzeug. Und mit denen zeige ich Dir in diesem Video, wie Du den Einstieg in Schleifen findest.

    Der Aufbau der for-Schleife ist zum Beispiel ähnlich wie unter Java und Objective-C. Es gibt darüber hinaus aber auch viele Neuerungen. Spannend sind Schleifen auch mit dem neuen Range-Operator, der ebenfalls ein Thema im Video ist.

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

    #7: Strings verwenden und verarbeiten

    Strings sind auch in Swift und iOS-Apps die Building-Blocks. Ohne sie geht nichts. Daher sind ein Grundverständnis und einige grundlegende String-Operationen extrem wichtig. In diesem Video lernst Du wie leere Strings erkennst und wodurch die sich überhaupt auszeichnen. Du lernst Strings per Konkatenation zu verbinden und außerdem per Interpolation Variablen direkt in Strings zu integrieren.

    Auch Strings zu vergleichen ist im Alltag immer wieder notwendig. Deshalb findest Du in diesem Video eine Einführung in das Thema Stringvergleiche. Spannend ist in dem Zusammenhang speziell die intelligente Unterstützung von UTF-8, die sich quer durch Swift zieht. Auch dazu findest Du Details in diesem Video.

    In gleichem Maße ist auch die Stringlänge immer wieder eine wichtige Information. Bei dem jetzigen Stand der Technik eine Kleinigkeit. Da durch UTF-8 gar nicht mehr alle Zeichen auf einer Tastatur abzubilden wären, kannst Du in Swift mit speziellen UTF-8 Escape-Sequenzen Sonderzeichen erzeugen. In diesem Zusammenhang ist die Länge der Zeichenkette nicht mehr so trivial. Auch dazu findest Du einen Einstieg.

    Insgesamt ist das Video eine Rundreise durch die Welt der Strings in der Sprache Swift. Du findest viele wichtige Informationen und einen Einstieg in die Verarbeitung von Zeichenketten.

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

    #8: Arrays in Swift

    Unter Swift werden natürlich auch Arrays verwendet. Dieses Basiselement ist eine geordnete Sammlung von Daten, die nahezu alternativlos ist. Mit den nun sogar nativ in Swift verfügbaren Sets und Dictionaries gibt es zwar vergleichbare Konstrukte. Für geordnete Listen gleicher Datentypen wird aber nunmal das Arrays verwendet. Grund genug, die Arbeit mit Arrays unter Swift näher anzuschauen.

    Du lernst wie Du Arrays initialisierst und Swift den Datentyp bestimmen lässt. Über Typ-Inferenz wird genau wie bei primitiven Datentypen der notwendige Typ ermittelt. Außerdem zeige ich Dir, wie Du Arrays deklarierst. Auch wichtige Operationen wie das Prüfen ob Elemente vorhanden sind, ist Thema im Video.

    Darüber hinaus lernst Du Methoden zur Manipulation kennen. Dazu gehören das Einfügen von Elementen per Insert, das Entfernen von Inhalten über removeAtIndex oder removeLast. Auch der Range-Operator kann in Verbindung mit Arrays verwendet werden. Wie genau, erfährst Du ebenfalls im Video.

    Zum Abschluss lernst Du kennen, wie Du mittels einer for..in Schleife über Arrays iterieren kannst.

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

    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/

  2. j M Y, g:ia \G\M\TO
    G GLSS beginnt die Unterhaltung iOS mit Swift [Video Tutorials].

    [center]

    iOS mit Swift [Video Tutorials]

    [/center]

    Interfaces mit Autolayout

    Es gibt mittlerweile viele iOS-Geräte mit unterschiedlichen Auflösungen. Um jedem Nutzer gerecht zu werden, müssen Deine Apps überall ansprechend aussehen. Sie müssen auf den vorhanden Platz reagieren. Dazu bietet Apple im UiKit die sogenannten Autolayouts an. Du positionierst nicht mehr jedes Element auf den Pixel genau. Stattdessen legst Du Constraints fest. Die Beschreiben, wie Deine UI-Elemente anzuordnen sind. Zentriert in der aktuellen View? Der Abstand relativ zum oberen Rand beibehalten? Oder zum nächstgelegenen View-Element? Mit Autolayout-Constraints ein Kinderspiel.

    Gemeinsam legen wir das Interface für einen Umrechner fest. Die App wird als Universal-App sowohl auf dem iPhone als auch auf dem iPad nutzbar. Der Benutzer gibt in ein das UITextfield eine natürliche Zahl ein. Die App berechnet dann die Fakultät dieser Zahl (n!). Die Berechnung erfolgt über die Multiplikation aller natürlichen Zahlenvon eins bis einschließlich der genannten Zahl selbst. Die Fakultät von 3 ist also zum Beispiel sechs, also 1x2x3. Für die Ausgabe legen wir zwei Label fest, eines für die Aufgabe und ein weiteres für das Ergebnis. Die notwendige Logik wird in einem späteren Video vervollständigt.

    Konkret legen wir über Layout-Constraints Abstände fest, legen die Breite und Höhe fest und sorgen mit den Alignment Constraints für die gewünschte Ausrichtung (Horizontal Center in Container). Wir nutzen in Xcode die Storyboard Vorschau sowie den Pin- und den Align-Dialog. Du lernst außerdem einen einfachen Trick kennen, mit dem Du über eine UIView zwei Elemente wie UILabels oder UIButtons sehr einfach zentrieren kannst. Hinweis: Ohne diesen Trick ist es ziemlich umständlich.

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

    Swift 1.2: Neuerungen und automatische Migration mit Xcode

    Mit Swift 1.2 hat Apple einige Neuerungen rund um die die neue Sprache veröffentlich. Vieles passiert im Hintergrund oder bietet neue Möglichkeiten. Eine Anpassung wirkt sich aber unmittelbar auf Entwickler aus. Der bestehende Code wird dadurch ungültig. Ursache ist eine Änderung beim Casting von Objekten. Das Keyword “as” konnte vorab frei verwendet werden. Jetzt ist es streng an Optionals angelehnt. Dazu gibst Du als Entwickler das neue Objekt mit “as?” als Optional zurück. Alternativ kannst du mittels Optional-Unwrapping die Konvertierung erzwingen. Dazu verwendest Du als Keyword “as!”.

    Diese Änderung ist unglaublich simpel. Bei bestehenden Projekten und Quellcode hat sich allerdings durchaus Auswirkungen. Bei einzelnen Dateien sicher gar kein Aufwand etwas zu ändern. Wenn Du aber ein umfangreicheres Projekt geschrieben hast, kannst Du die Migration mit Xcode weitestgehend automatisch vornehmen. Ich zeige Dir im Video, wie das geht.

    Insgesamt hat die Version 1.2 von Swift natürlich auch viele positive Änderungen mitgebracht. Dazu gehört zum Beispiel eine verbesserte Geschwindigkeit! Bereits beim Übersetzen des Quellcodes ist das spürbar. Statt immer alle Dateien neu zu kompilieren, werden nur noch geänderte Dateien neu übersetzt. Hier spricht Apple von “incremental builds”. Auch zur Laufzeit ist die Performance in manchen Szenarien besser als bei Objective-C. Dieser Trend könnte sich in Zukunft fortsetzen, wenn noch mehr Teile der Standardbibliothek nativ in Swift vorliegen.

    Spannend sind auch die neuen if/let bindings und eine weitere Mikrooptimierungen. Insgesamt wurde auch das Zusammenspiel mit Objective-C noch weiter verbessert. Es ist deutlich spürbar, dass Apple klar die Absicht hat einen Nachfolger für Objective-C zu formen.

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

    UISplitViewController mit Swift

    Der UISplitViewController ist mit dem Navigation Controller vergleichbar. Er stellt zwei Anzeigebereiche bereit, die Master- und Detailview. Der SplitViewController selbst stellst jedoch keine Inhalte dar. Er ist nur eine Art Container. Sichtbare Inhalte werden über verbundene Views angezeigt - die Master- und Detailviews. Eine Auswahlmaske wird bspw. als Tabelle in der Masterview angezeigt. In der Detailview werden ausführliche Informationen zum ausgewählte Eintrag dargestellt. So könnte in der Masterview eine Liste mit Rezepten existieren. Wählst Du eines aus, werden Dir Zutaten und Hinweise zur Zubereitung in der Detailview angezeigt.

    Die Technologie ist seit iOS 3.2 vorhanden. Bisher stand sie allerdings nur auf dem iPad zur Verfügung. Seit iOS8 ist die UISplitView, auch dank der neuen SizeClasses, auf jedem iOS-Gerät verwendbar. Das Besondere: iOS kümmert sich selbstständig um die sinnvollste Darstellung. Auf einem iPad im Querformat, also den horizontalen und vertikalen SizeClasses “regular”, wird die Masterview als ständig präsente Seitenleiste angezeigt. Hochkant im Portraitmodus wird sie auch hier ausgeblendet, kann aber jederzeit eingeblendet werden. Auf den kleineren Geräten, wie früheren iPhones, wird die MasterView-Ebene aus Platzgründen ebenfalls nur auf Wunsch angezeigt.

    In diesem Video zeige ich Dir die grundlegende Verwendung. Im ersten Schritt bereiten wir einen MasterViewController vor. In dem werden Farben angezeigt. Wählt der Benutzer einen Eintrag, ändern wir im zweiten Schritt die Hintergrundfarbe der Detailview entsprechend ab. Du lernst also erste Schritte mit dem UISplitViewController zu gehen.

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

    TouchID unter iOS mit Swift nutzen

    Mit dem Begriff TouchID wird im iOS- und Apple-Universum die Authentifizierung über den Fingerabdruck zusammengefasst. Der Scanner ist im Homebutton integriert. Eingebaut wird er im iPhone seit dem 5S aufwärts sowie in den neueren iPad- und iPad-Mini Modellen.

    Bei der Einführung im Rahmen von iOS7 stand TouchID zunächst nur für interne Applelösungen bereit. Seit iOS8 können Entwickler ebenfalls darauf zurückgreifen. Grund genug, dass in diesem Video mit Swift auszuprobieren.

    Um den TouchID-Sensor herum ist ein kleiner Metallring. Der erkennt die Berührung und leitet den Scan ein. Wichtig ist, dass Apple hier viel Wert auf Datenschutz und Sicherheit legt. Es werden keine Bilder vom Fingerabdruck gespeichert. Stattdessen handelt es sich um eine mathematische Darstellung. Ein guter, wenn auch ungenauer, Vergleich sind Hashwerte wie SHA oder MD5. Auch hier wird lediglich eine mathematische Darstellung berechnet. Sie kann nur per Brute-Force Angriff entschlüsselt werden.

    Zusätzliche Sicherheit bietet der Secure Enclave. Die Fingerabdruckdaten werden verschlüsselt abgelegt und nur von der Secure Enclave verwendet. Diese Einheit bestätigt, ob der erkannte Abdruck den registrierten Daten entspricht. Der Chip ist laut Apple von den restlichen Bereichen des OS abgeschirmt und kann somit gar nicht direkt angegriffen und ausgelesen werden. Die Kommunikation beschränkt sich also folglich auf Eingabedaten und Wahrheitswerte, die zurückkommen.

    Wichtig ist, dass keinerlei Daten in der iCloud oder irgendwo bei Apple gespeichert werden. Der Zugriff, die Authentifizierung und auch die Datenhaltung der biometrischen Informationen geschieht nur lokal. Zugriff ist von außen nicht möglich. Nur der Secure Enclave kann die Daten auswerten. Sie werden auch nicht in Backups erfasst und so durch die Hintertür ausgelesen.

    Spannend an TouchID ist auch die Lernfähigkeit. Nach und nach ergänzt der Sensor sein Bild vom Finger und kann immer zuverlässiger arbeiten.

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

    UIStackView in iOS9

    UIStackView ist eine weitere Erleichterung bei der Interface Gestaltung von Oberflächen für iOS-Apps. Ziel ist es, die Anzahl der notwendigen Autolayout Constraints zu verringern und das Interface erweiterbar zu halten.

    Unter iOS sind Autolayout-Constraints das Mittel der Wahl wenn es um die Interface Gestaltung geht. Autolayout ist die Antwort auf die Fragen, die durch die gestiegene Zahl der verschiedenen Displaygrößen und Auflösungen entstanden sind. Webseiten nutzen responsive Layouts mit CSS und JavaScript. Die Anfänge der Universal-Apps sah vor, dass zum Beispiel für iPad und iPhone getrennte Storyboards entworfen wurden. Spätestens mit iOS8 und den SizeClasses sind die Interfaces adaptiv geworden. Es war für Entwickler noch nicht so einfach dynamische Interfaces zu entwerfen, die sich an die vorhandenen Ressourcen anpassen.

    Mit iOS9 hat Apple das Spiel noch weiter verbessert. Es gibt nun mit UIStackView einen Weg um View-Elemente automatisch anzuordnen. Dabei können Sie horizontal oder vertikal angeordnet werden. Zwischen den Elementen kann automatisch Abstand freigehalten werden. Außerdem kann die Verteilung des zur Verfügung stehenden Platzes kontrolliert werden. Unheimlich nützlich ist zum Beispiel die gleichmäßige Aufteilung auf die einzelnen Elemente.

    Apple selbst sieht dies als bevorzugten Weg, um Interfaces zu gestalten. Und dazu gibt es auch allen Grund. Wie Du in diesem Video sehen wirst, ist es extrem logisch und einfach damit umzugehen. Lediglich in den Beta-Versionen von Xcode7 (UIStackView ist erst ab Xcode7 bzw. IOS9 verfügbar) gab es noch das ein oder andere Problem und ungewollte Verhalten. Die Zukunft gehört den Stackviews, wo immer dies sinnvoll ist. Zusammen mit Autolayout Constraints spielen sie ihre volle Stärke aus.

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

    iOS9 mit Swift2, am Beispiel von 15 Apps

    Steig in die Entwicklung mit Apples neuer Sprache Swift ein. Du lernst Swift2 kennen und steigst mit umfangreichen Apps in die Programmierung realer Apps ein. Bei jeder App werden verschiedene Technologien verwendet, miteinander verbunden und so die Entwicklung realitätsnah vermittelt. Einen direkteren Blick hinter die Kulissen der Entwicklung einer echten App geht fast nicht.

    Los geht es mit Grundlagen der Sprache im Swift Crashkurs. Anschließend lernst Du immer mehr iOS-Frameworks kennen und nutzt sie in der Praxis.

    Zu den Anwendungen gehört eine...

    • einfache App zur Berechnung des Body-Mass-Index
    • Rezeptesammlung mit UITableView
    • Bildergalerie auf Basis der UICollectionView
    • Apps zum Abruf von Synonymen von einer JSON-API
    • Einkaufsliste mit CoreData
    • Timer-App
    • ein Würfelbecher mit SpriteKit
    • App die ihre Inhalte per JSON-API aus WordPress abruft
    • Kartenanwendung, die Orte anzeigt, speichert und auffindbar macht
    • vollständige Tabata-Timer App
    • RSS-Reader App, der die Grundlage der App zu Deinem Blog sein kann
    • Soundboard Anwendung, das witzige Geräusche abspielt und eigene aufnimmt
    • LiveErgebnisse App die per PushNotification Neuigkeiten signalisiert
    • Anwendung die über In-App Einkäufe Inhalte freischaltet
    • Instagram ähnliche App, die Daten im Parse.com Backend speichert

    Alle wichtigen iOS-Frameworks werden behandelt. Außerdem lernst Du den sicheren Umgang Xcode, Playgrounds und dem Workflow bei der Entwicklung.

    Im Kurs werden auch AutoLayout, Sizeclasses und andere wichtige Themenbereiche abgedeckt. Es geht nicht nur um Faktenwissen, sondern um ein Gesamtverständnis der Materie.

    Der Kurs umfasst mittlerweile über 27 Stunden Videomaterial, inkl. einiger Bonuslektionen, Quiz und Übungsaufgaben mit Musterlösungen zu jedem Kapitel.

    Das Training ist mehr als nur eine Sammlung einzelner Tutorials. Die genutzten Technologien stellen einen gezielten Mix dar. In jeder App werden weitere Technologien eingeführt, die in der täglichen Praxis als Entwickler wichtig sind.

    Und das besondere bei einem Videotraining: Es bietet mir als Trainer die Möglichkeit Dir nicht nur das WIE zu vermitteln. Gleichzeitig kann ich, wo dies dem Verständnis hilft, das WARUM erläutern und meine Entscheidungen begründen. In einem Buch geht das nur begrenzt.

    Der Kurs - iOS9 mit Swift2, am Beispiel von 15 Apps - richtet sich an Einsteiger und Umsteiger. Erste Programmiererfahrung sind optimal. Auch erster Kontakt mit Begriffen wie Objekten, Klassen und Instanzen ist von Vorteil.

    Gleichermaßen kommen auch erfahrene Entwickler hier voll auf ihre Kosten. Ich wähle bewusst einen Mittelweg und nehme den Entwickler mit jeder App zunehmend weniger an die Hand. Es kommt also jeder auf seine Kosten.

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

    iOS mit Swift: NSTimer mit Swift verwenden

    Ein NSTimer kann wunderbar für eine Stoppuhr oder für einen Teatimer verwendet werden. Außerdem gibt es auch unzählige Beispiele für zeitgesteuerte Abläufe, bei denen der Benutzer nicht unmittelbar den zeitlichen Fortschritt sehen muss. Aber auch ohne Darstellung der abgelaufenen Zeit, muss diese berechnet werden. Die Lösung ist der NSTimer.

    Bei der Arbeit mit dem NSTimer gibt es zwei wesentliche Herausforderungen. Zum einen muss das Verständnis für den Timer vorhanden sein. Die Klasse selbst hilft nur dabei die verstrichene Zeit zwischen zwei Intervallen zu erfassen.

    Periodisch ruft der "scheduledTimer" einen Selektor auf. In dieser Methode, die wir in diesem Video implementieren, erfassen wir die verstrichene Zeit seit dem letzten Aufruf. Genau diese Zeit wird anschließend zur Gesamtzeit hinzuaddiert.

    Der zweite Knackpunkt ist ein Timer, der pausiert und wieder fortgesetzt werden kann. Auch diese Herausforderung meistern wir in diesem Video gemeinsam.

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

    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/

  3. j M Y, g:ia \G\M\TO
    G GLSS beginnt die Unterhaltung Swift2 Video Tutorials.

    [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/

  4. j M Y, g:ia \G\M\TO
    G GLSS beginnt die Unterhaltung Programmieren lernen mit Swift [Video Tutorials].

    [center]Programmieren lernen mit Swift | Video Tutorials[/center]

    #1: Variablen verwenden

    Dieses Training schließt für viele Einsteiger eine Lücke. Wenn Du eine App im iOS-Universum entwickeln möchtest, kommen auf Dich zwei Themen zu. Zum einen musst Du die Programmiersprache kennenlernen. Das ist im Apple Umfeld mittlerweile Swift. Zudem musst Du das CocoaTouch Framework kennenlernen. Die vielen Frameworks, Klassen, Methoden und Bestandteile von Apps sind darin enthalten. Das sind bereits zwei Baustellen. Wenn Du aber komplette Einsteiger bist, gab es kein gezieltes Angebot – bis jetzt.

    Programmieren lernen, die Herausforderung

    Wenn Du nun gar nicht weißt, welche Elemente eine Programmiersprache bietet, was die verschiedenen Begriffe bedeuten oder wofür sie genutzt werden, hast Du drei Baustellen. Das kann nicht funktionieren. Du findest bei der Recherche immer wieder neue Fragen…

    …Und deshalb habe ich kompletten Einsteigern bisher immer Java empfohlen. Da geht es vor allen Dingen um das Grundverständnis für die Basiselemente. Was sind Variablen und Datentypen? Wie arbeiten die Grundrechenarten? Wie und warum verwendet man Bedingungen? Datenstrukturen wie Arrays nutzen und mit Schleifen verarbeiten. You name it. Diese Themen führt der Kurs ein.

    Im ersten Teil geht um die Variablen. Wie verwendest Du Sie? Wie funktioniert das im Hintergrund? Wo liegen die Daten eigentlich? Wie definierst Du mit Swift Variablen und Konstanten? Wo ist der Unterschied?

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

    #2: Datentypen verstehen

    Variablen bieten Speicherplatz für Werte im Speicher. Im ersten Video wurde bereits klar, dass alle Werte nur in Form von 1 und 0 abgelegt werden. Das wird of zitiert, aber nur die wenigsten verstehen was dahintersteckt.

    Darauf baut Video #2 auf, denn es gibt nicht die pauschale Variable. Jede Variablen hat einen Datentyp. Und der definiert eigentlich nur, wie viel Speicherplatz benötigt wird.

    In diesem Video geht es also einmal um die Theorie, aber eben auch um die Datentypen selbst - erklärt am Beispiel von Swift. Dazu gehören die Integerwerte (Int), Double und Float für Zahlen mit Nachkommastelle, Bool für Wahrheitswerte, Character für einzelne Zeichen und String für Zeichenketten.

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

    #3: Statements und Anweisungen

    Statements in Swift unterscheiden sich nur unwesentlich von anderen Sprachen. Dieses Video ist ganz besonders für Einsteiger gedacht, die noch nicht genau Wissen wie ein Programm allgemein aufgebaut ist.

    Am Ende des Tages besteht Quellcode aus einer Reihe verschiedener Statements, also Anweisungen. Die ersten Statements haben wir bereits genutzt, also wir Variablen und Konstanten angelegt haben.

    Um eine bessere Vorstellung davon zu bekommen, wie Programme zusammengesetzt sind, schauen wir uns nun den Aufbau an.

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

    #4: Strings / Zeichenketten

    In den ersten beiden Videos hast Du speziell Variablen und numerische Datentypen kennengelernt. Die logische Fortsetzung sind nun Textinhalte, also die Zeichenketten. Der Datentyp heißt String.

    Dieses Konzept gibt es in nahezu jeder Sprache, selbst bspw. bei JavaScript und PHP, wo bisher der Typ einer Variable gar nicht spezifiziert wird.

    In der Historie gab es auch bspw. in Sprachen wir C ein sehr verwandtes Konzept. Die sogenannten char-Arrays sind eigentlich nur eine Sammlung verschiedener Buchstaben und/oder Zeichen. Werden sie hintereinander ausgegeben, ergeben sich Wörter. :)

    Ein essentielles Feature, das nicht nur bei Swift eine Rolle spielt. Eine wichtige Etappe - wenn Du Programmieren lernen möchtest.

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

    #5: Kommentare

    Wenn Du an Deinen Projekten arbeitest bist Du voll im Thema. Alle Bestandteile sind Dir mehr oder weniger klar. Wenn Du alleine entwickelst, erkennst Du in der Regel sogar jede Zeile, die Du geschrieben hast wieder. Bis .... das irgendwann nicht mehr so ist.

    Was noch bei der Entwicklung unvorstellbar wirkt, ereilt Dich nach einige Wochen oder Monaten: die Erinnerungen verblassen. Das geht soweit, dass Dir vielleicht die Bedeutung einzelner Abschnitte verloren geht. Um Dich davor zu schützen, und auch um anderen Entwicklern das Verständnis leichter zu machen, gibt es Kommentare. Und genau die schauen wir uns in diesem Video an.

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

    #6: Rechnen

    Das EAV-Prinzip steht für Eingabe, Ausgabe und Verarbeitung. Gerade im letzten Schritt stehen häufig Berechnungen mit auf der Agenda. Sei es die Umrechnung, eine Berechnung oder einfach Folgerechnung.

    Zusammengefasst steht dieser Thema unter der Überschrift Arithmetik. Und die beschäftigt uns im heutigen Video. Es geht konkret um die Grundrechenarten. Du siehst wie Du addieren, subtrahieren, multiplizieren und dividieren kannst. Außerdem siehst Du, was es gerade bei der Division zu beachten gibt.

    Darüber hinaus lernst Du den Modulo Operator kennen.

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

    #7: Werte zuweisen

    Werte hast Du bereits im ersten Video der Programmieren lernen mit Swift Serie zugewiesen. Allerdings gibt es da doch einen großen Unterschied zu anderen Sprachen. Das gleichzeitig in einer if-Bedingung zu verpacken, funktioniert bspw. nicht. Außerdem sprechen wir in diesem Video über die sogenannten Compound-Assignments.

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

    #8: Inkrement / Dekrement

    Variablen inkrementieren und dekrementieren ist ein wichtiges Feature, dass in vielen Sprachen eine verkürzte Schreibweise für "jetziger Wert plus 1" bzw. "jetziger Wert minus 1" darstellt. Die Operatoren ++ respektive -- können beim lesenden Zugriff auf Variablen angehangen oder vorangestellt werden. So wird der Wert anschließend oder bereits im Vorfeld erhöht (Inkrementieren) bzw. verringert (Dekrementieren).

    In diesem Video lernst Du alle wichtigen Features kennen, die 1:1 auf viele andere Sprachen übertragen werden können.

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

    #9: Bedingungen und Fallunterscheidung

    Bedingungen und Fallunterscheidungen sind wichtige Elemente, die im Quellcode die Logik verzweigen und an Vorraussetzungen knüpfen können. Grund genug, sich das mal genauer anzuschauen.

    Was sind if-Bedingungen? Wie setzen sie sich zusammen? Wie werden sie eingesetzt? Was sind switch-Statements und wie wird die Fallunterscheidung durchgeführt?

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

    #10: Vergleiche

    Im letzten Video ging es um die Bedingungen ganz allgemein. Dabei haben wir bereits unbewusst einen Vergleich hinterlegt, aber nicht im Detail darüber gesprochen. Das gilt es natürlich heute nachzuholen.

    Im Detail geht es um die Vergleiche wie "größer", "kleiner", "größer oder gleich", "kleiner oder gleich", "ungleich" und "wahr" oder "nicht wahr". Außerdem kombinieren wir die einzelnen Vergleiche mit logischen Operatoren.

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

    #11: Arrays

    Die Arrays sind in Swift und anderen Sprachen ein wichtiges Element zur Datensammlung. Dabei geht es um Listen von Daten des gleichen Typs. Ein Array ist kein eigenständiger Datentyp. Genau deshalb spricht man auch von einem Integer-Array, einem String-Array und so weiter.

    Du lernst konkret wie Du Arrays initialisierst, wie Du sie deklarierst, Daten einfügst und löscht, prüfst ob Inhalte enthalten sind und wenn ja, wie viele dies sind.

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

    #12: Dictionaries

    Dictionaries sind neben den Arrays eine weitere wichtige Datenstruktur. Ähnlich wie in einem Array werden mehrere Werte (Values) in einer Variable hinterlegt. Der Zugriff erfolgt aber nicht über die Indizes, sondern über einen weitestgehend frei definierbaren Schlüssel (Key). Darum spricht man auch von sogenannten Key/Value-Paaren.

    Du lernst wie Du Dictionaries initialisierst, wie Du sie deklarierst, Daten einfügst und löscht, prüfst ob Inhalte enthalten sind und wenn ja, wie viele dies sind.

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

    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/

  5. j M Y, g:ia \G\M\TO
    G GLSS beginnt die Unterhaltung SWIFTY - LERNE, IN SWIFT ZU PROGRAMMIEREN!.

    Swifty - Lerne, in Swift zu programmieren!

    Swifty. Wer lust hat Privat oder auch Beruflich die Apple Swift Programmiersprache etwas näher kenne zu lernen, ist mit dieser App sehr gut aufgehoben. Warum? Ganz einfach, die App ist wirklich sehr gut und schlicht aufgebaut und es ist angenehm damit zu arbeiten.
    Das Lernprogramm hat eine sehr gute Aufstellung.. Man fängt mit den Grundlagen an und hört dann mit Closures auf. So kann auch jeder Anfänger ohne Programmierkenntnisse hier was erreichen. ;-)

    -image- -image-
    -image--image-

    Swifty Beschreibung:

    Lerne zu programmieren: einfach, lustig und wo auch immer du bist! Mit Swifty und seinen über 200 interaktiven Tutorial-Häppchen war es noch nie leichter und spaßiger, mit dem Programmieren zu beginnen.

    Swifty wurde kürzlich als eine der Besten Neuen Apps in mehr als 70 Ländern und als Teil des "Programmieren Lernen"-Features vorgestellt! Hurra!

    ◆ Die Nutzer lieben Swifty (und umgekehrt):
    "Das ist die beste Einführung in Programmieren, die ich je benutzt habe. Ernsthaft. Die beste überhaupt. Vielen, vielen Dank dafür!"
    "Swifty ist fantastisch! Ich glaube, ihr habt die beste Programmier-Lernerfahrung und -App aller Zeiten gemacht!"

    ◆ Die Presse meint dazu: "Dieses Format macht es ideal, unterwegs und in kleinen Sprints zu lernen." - Lifehacker
    "Swifty ist eine gute Art, ... iOS-Entwicklung auszuprobieren ohne zu tief eintauchen oder viel Geld ausgeben zu müssen." - GeekWire (App of the Week)

    Swifty ist die mit Abstand einfachste und lustigste Art, dich mit Swift und programmieren im Allgemeinen vertraut zu machen. Beginnend mit den absoluten Grundlagen führt dich Swifty zu fortgeschrittenen Themen wie Optionals und Closures!

    Dein Pfad zu (Swift-)Ruhm und Ehre:
    01) Swift-Grundlagen

    1. Variablen
    2. Bools
    3. Verzweigungen
    4. Arrays
    5. Dictionaries
    6. Strings
    7. Schleifen
    8. Funktionen
    9. Klassen
    10. Strukturen
    11. Optionals
    12. Enums
    13. Closures

    ◆ Die ersten drei Kapitel gehen auf uns; alle anderen können mit einem einzigen In-App-Kauf freigeschalten werden! Einmal gekauft, bist du bei allen zukünftigen Erweiterungen und Updates mit von der Partie. Ziemlich gut, oder?

    ◆ Swifty ist auf dein iDevice zugeschnitten, egal ob du ein iPhone, iPad oder einen iPod touch verwendest. Richtig, das beinhaltet sowohl dein neues iPhone als auch das iPad 2 deiner Großeltern.

    Hol' dir Swifty noch heute und starte deine Reise in die Welt der iOS- und Mac-Entwicklung!

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

    Swifty - Lerne, in Swift zu programmieren auf Deutsch IOS Download
    https://itunes.apple.com/de/app/swifty-learn-how-to-code-in/id886315617?mt=8

    Viel Spaß damit!!
    Swift-Support Team

  6. j M Y, g:ia \G\M\TO

    Ja z.B. :)

  7. j M Y, g:ia \G\M\TO

    Hallo Jan und herzlich Willkommen.
    Gerne kannst du auch deine Videos hier im Forum Posten, natürlich mit einem verweis auf deinen Blog.

    Bei Interesse kannst du mich gerne Privat anschreiben. ;)

    Viele Grüße
    GLSS

  8. j M Y, g:ia \G\M\TO
    G GLSS schrieb in SIGABRT .

    Hi,
    versuche es mal damit :)

    • Select your project file in the Project Navigator
    • In the sidebar with "Projects" and "Targets," select your app under "Targets"
    • Click the Info tab
    • Expand "Custom iOS target properties" if necessary
    • Look for something like "Main nib file base name." If you see it, click it and change it to "Main storyboard file base name."
    • Make sure the name to the right matches the name of your storyboard file
    • Now build and run.

  9. vor 2 Jahren
    j M Y, g:ia \G\M\TO
    G GLSS beginnt die Unterhaltung Was gibt es neues in Swift 2?.

    Heute mal ein anderes Video. BenchR hatte gestern einen Talk bei den Cocoaheads Dresden gehalten und dachte, dass das Thema sicher für einige von euch ganz interessant ist. Deswegen hat er davon einen Mitschnitt gemacht und hier hochgeladen.
    Danke an T-Systems für die Räumlichkeiten und danke an Pit für die Organisation!

  10. j M Y, g:ia \G\M\TO

    Hier finden Sie eine Anleitung, wie man Internet APN Einstellungen für Mobilcom-Debitel auf den iOS sowie Android Geräten einstellt.
    Bei Fragen bitte Registrieren oder Anmelden.
    Bei Mobilcom-Debitel können die ganz normalen D und E Netz Einstellungen verwendet werden!

    Schritt 1
    Tippen Sie auf dem Startbildschirm auf Einstellungen.

    Schritt 2
    Wählen Sie im Menü den Punkt Mobiles Netz.

    Schritt 3
    Drücken Sie auf den Punkt Mobiles Datennetzwerk.

    Schritt 4
    Tippen Sie in das Feld Name, APN, Benutzer und Password die dazu gehörigen Daten ein.

    Für Vodafone (D2) geben Sie:
    Name: Vodafone
    APN: web.vodafone.de
    Username: (leer)
    Password: (leer)

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

    Für T-Mobile (D1):
    Name: T-Mobile D
    APN: internet.t-mobile
    Proxy:(leer)
    Port: (leer)
    Nutzername: t-mobile
    Passwort: tm

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

    Für O2 (E Netz):
    Name: O2
    APN: internet
    Username: (leer)
    Password: (leer)
    MCC: 262
    MNC: 07

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

    Für E-Plus & (Base):
    Name: e-plus
    APN: internet.eplus.de
    Username: eplus
    Password: gprs

    Schritt 5
    Jetzt einfach die Einstellungen Speichern und das Gerät am besten Neustarten!
    Jetzt sollte das 3G/4G/E/G Zeichen, je nach Internet-Verfügbarkeit erscheinen.

    apn mobilcom debitel

Mehr