Learn Swift 4 with Bob: The Intermediate to Advanced Swift

Learn Swift 4 with Bob: The Intermediate to Advanced Swift
Learn Swift 4 with Bob: The Intermediate to Advanced Swift

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 17.5 Hours | 5.52 GB
eLearning | Skill level: All Levels


Functional Programming, Protocol Oriented, Value Oriented, Generic Protocols, Object Oriented, Swift 4

There are 10 chapters in this course. From Chapter 1 to 4, you will get a firm understanding of both Intro to Functional, and protocol, and Object Oriented Programming. In Chapter 5, you will fully understand how objects are created and removed. In Chapter 6 and 7, you will learn how to create value oriented swift code along with protocol generics and enums. In the last chapter, you will acquire various advanced and hidden tips about the Swift Programming Language.

Prerequisites

This course is designed for Swift intermediates. So, I won’t cover the basics. You may visit the lecture notes and go to prerequisites. You will find a list of items you are expected to know. There is a YouTube video for each concept, so if you ever get stuck, you can always learn and come back. In a nutshell, you should be already be familiar with switch statement, conditional statement, basic operators, functions, and basic object oriented programming.

Questions

Do you know why Swift engineers have implemented optionals? Do you know what completion handlers and how to design one for your project? Do you know retain cycle within closures and delegates? Do you know the difference between autoclosures, trailing closures, and @escaping closures? Do you know how to create custom operators. Do you truly understand the statement, “Swift is a protocol oriented programming language”, and know how to use default protocols such as Equatable, Comparable, Sequence, and Iterator Protocol. Lastly, do you know the difference between normal and recursive enums? If you can’t answer all of these questions, I recommend you to take this course and start learning with me.

What Will I Learn?

  • Learn the difference between classes and structs and which one to use
  • Learn how to create generic enums, structs, classes, protocols
  • Get a taste of functional programming with trailing, auto, and escaping closures
  • Understand how objects are created and removed through Automatic Reference Counting
  • Understand potential retain cycle in closures, delegate, and class variables
  • Understand Swift is a protocol oriented programming language
  • Apply protocols such as Equatable, Comparable, Sequence, and IteratorProtocol
  • Execute Swift files using Terminal/Command Line
  • Functional Programming
+ Table of Contents

Introduction
1 Course Overview

Chatper 1_ The Swift Fundamentals
2 Introduction
3 Lesson 1_ Optionals
4 Lesson 2_ Optional Chainings
5 Lesson 3_ Guard and Defer Statement
6 Lesson 4_ Intro to Error Handling
7 Lesson 5_ Type Casting
8 Lesson 6_ Intro to Generics
9 Lesson 7_ Subscripts
10 Lesson 8_ Class vs Struct
11 Lesson 9_ Set and Tuple
12 Lesson 10_ Extension
13 Lesson 11_ Intro to Operators
14 Lesson 12_ Typealias
15 Conclusion

Chapter 2_ Object Oriented Swift
16 Introduction
17 Lesson 1_ Convenience Init
18 Lesson 2_ Computed Property
19 Lesson 3_ Property Observers
20 Lesson 4_ Failable Init
21 Lesson 5_ Override Method_ Init_ Property
22 Lesson 6_ Two Phase Init
23 Lesson 7_ Type Property and Method
24 Lesson 8_ Singleton Pattern
25 Conclusion

Chapter 3_ Intro to Functional Swift
26 Introduction
27 Lesson 1_ Intro to Closures Part 1
28 Lesson 2_ Intro to Closures Part 2
29 Lesson 3_ Lazy Init with Closures
30 Lesson 4_ Capture Lists
31 Lesson 5_ Trailing Closures
32 Lesson 6_ Completion Handlers
33 Conclusion

Chapter 4_ Protocol Oriented Swift
34 Introduction
35 Lesson 1_ Intro to Protocols
36 Lesson 2_ Protocol Extension
37 Lesson 3_ Protocol as Type
38 Lesson 4_ The Delegate Pattern
39 Lesson 5_ The Data Source Pattern
40 Conclusion

Chapter 5_ Memory Management
41 Introduction
42 Lesson 1_ Automatic Reference Counting
43 Lesson 2_ Delegate Retain Cycle
44 Lesson 3_ Closure Retain Cycle
45 Lesson 4_ Escaping and Autoclosures
46 Conclusion

Chapter 6_ Functional Programming
47 Introduction
48 Lesson 1_ Intro to Functional Paradigm
49 Lesson 2_ Filter
50 Lesson 3_ Map
51 Lesson 4_ Reduce
52 Conclusion

Chapter 7_ Generic Protocols
53 Introduction
54 Lesson 1_ Intro to Associated Type
55 Lesson 2_ Protocol Extension and Type Constraints
56 Lesson 3_ Override Protocol Associated Type
57 Lesson 4_ Protocol Pitfalls
58 Lesson 5_ Type Eraser
59 Conclusion

Chapter 8_ Advanced Enums
60 Introduction
61 Lesson 1_ The Enum Basics
62 Lesson 2_ Static and Mutating Methods with self
63 Lesson 3_ Nested Enum
64 Lesson 4_ Protocol Oriented Enum
65 Lesson 5_ Recursive Enum
66 Lesson 6_ Generic Enum
67 Lesson 7_ Error Handling with Result Type
68 Conclusion

Chapter 9_ What’s New in Swift 4
69 Introduction
70 Lesson 1_ Access Control
71 Lesson 2_ Keypaths
72 Lesson 3_ Generic Subscripts
73 Lesson 4_ JSON Parsing with Codable
74 Lesson 5_ Advanced Codable
75 Lesson 6_ Advanced Dictionary
76 Conclusion

Chapter 10_ Advanced Swift
77 Introduction
78 Lesson 1_ Nested Generics and Recursive Enum
79 Lesson 2_ Advanced Operators
80 Lesson 3_ Advanced Error Handling
81 Lesson 4_ Equatable and Comparable Protocol
82 Lesson 5_ Sequence and Iterator Protocol
83 Lesson 6_ Intro to Test Driven Swift
84 Conclusion


Download from Turbobit

Download from DepositFiles

Download from Rapidgator