DEV Community: Davmi Jose Valdez Ogando

100 Days of Swift - Day 11

Davmi Jose Valdez Ogando — Fri, 15 Apr 2022 12:17:24 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 11 - Protocols
(Maybe just call them interfaces?)

So protocols are in swift what interfaces are in any other language, but here protocols are a bit on steroids, and here is why. You have your usual stuff around them, access modifier, define the behavior of whoever implements them, you can abstract the concrete class by using the protocol in a parameter, etc.

What makes them powerful is the fact that they serve sort of an abstract interface when matched with Extensions, these allow you to modify data types (structs and protocols) to add a desire behavior and at the same time when paired with protocols it helps them have a default functionality, so whenever a class implements the protocol it doesn't have to build the body of all the protocol member's (so an abstract class).

Man this journey makes my brain hurts a bit.

100 Days of Swift - Day 10

Davmi Jose Valdez Ogando — Fri, 15 Apr 2022 04:38:19 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 10 - Classes

Straight outta the intro we are let known the main difference between structs and classes. Classes enable inheritance in our code, and if you come from a OOP background you already know the importance of this feature.

Overriding methods is done by using the override keyword, and in order to avoid a class from being further extended you can always use the final keyword.

Another big difference is that structs are value types while classes are reference types. This means that copying the instance of a class and modifying a property results in the property value being changed on both variables, while if try the same with a struct each variable will hold a different value.

100 Days of Swift - Day 8 (and 9)

Davmi Jose Valdez Ogando — Fri, 15 Apr 2022 02:59:12 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 8 (and 9) - Structs

In swift structs are the most commonly used data type. Almost everything is a struct from integers to strings.

To declare a struct it is done like this: struct Person { var name: String} and initialize it we can do it this way: var person = Person(name: "Davmi)".

Structs the same way they contain properties, can have calculated properties, and not only that but methods and even static members too. What is more surprising is that you can even have access modifiers for structs, this makes me want to wonder what are the differences between a struct and a class?.

The most important thing one can find in a struct is the observables didSet and willSet these 2 will trigger themselves as when either a property has changed or a property will change, in my opinion these are the best features of the language.

100 Days of Swift - Day 6 (and 7)

Davmi Jose Valdez Ogando — Wed, 13 Apr 2022 00:32:23 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 6 (and 7) - Closures

Closures are a variable containing a function to be executed, for javascript developers this is not a new topic since they do it all the time, but for .Net developers is something almost equivalent to an action.

Writer note:
Is really interesting finding the difference between these languages

A closure in swift looks like this:
`
let myClosure = {
(name: String) in
print("This is the closure I (name) have created")
}

Closures can get complicated, since I see how something similar to callback hell can happen. For instance this sounds complicated to read, is complicated to do and just....

"A Closure that accepts a closure with a parameter as a parameter"

Maybe my english is wrong, but as I am still a novice to give more notes about this, I'll just drop this link which works as a base of how powerful (and fragile) working with this type of closures can be, other use case? not sure, but I have to say that implementation of a reduce method just looks so clean.

100 Days of Swift - Day 5

Davmi Jose Valdez Ogando — Tue, 12 Apr 2022 22:22:09 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 5 - Functions

Functions are a little bit special for swift, first of all return keyword is not required, function keyword gets boiled down to func, and return statements are specified with -> DataType; kind of bonkers if you ask me but hey, gotta get use to it.

In the other hand here we get an interesting concept, "parameter labels", these allow for a function to have an internal and external name for a passed parameter, ex:

func greet(to name: String) -> String { "Hello! \(name)" }; greet(to: "Davmi");

To get rid of the required parameter name when calling a function we can use the discard operator, the same way print() does not require the parameter to be set print(nameOfParameter: "") we can change our greet function like this:

func greet(_ name: String) -> String { "Hello! \(name)" };

And then the function can be called like: greet("Davmi");

Variadic functions are totally different, while on c# with have the params keyworks, on swift we use ... after the param type, so a variadic function would be

func variadicFunc(numbers: Int...)

In swift all parameters are immutable, in order to pass by reference (modify the value of the parameter), you need to add the ampersand symbol &.

100 Days of Swift - Day 4

Davmi Jose Valdez Ogando — Mon, 04 Apr 2022 00:09:32 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 4 - Looooooooops

For loops For loops are done on a python way (maybe swift did it first?) but without the required indentation. So if you want to loop through [1,2,3,4] you'd do: for number in [1,2,3,4] { print(number) }

PS: Discard (the underscore _ ) is accepted if you don't want/need the actual variable

While loops
Nothing fancy to see here
Repeat Loops
Basically do whiles
Breaking and skipping in loops
While the keyword continue is just your everyday reserved word, breaks are really interesting.

Swift supports something called "labeled statements". Imagine the following nested loop:

for option1 in options { for option2 in options { // do code here } }

Like in other languages, if we use the keyword break it will exit the inner loop only, inside a function we could add a return but that's if we are inside a function, so how do we exit the parent? well you give it a label and then you tell swift to break label_name; example:

outerLoop: for option1 in options { for option2 in options { break outerLoop; } }

Pretty neat in my opinion.

100 Days of Swift - Day 3

Davmi Jose Valdez Ogando — Sat, 02 Apr 2022 15:11:40 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 3 - Operators and conditions

This day was about operators, most of them (arithmetic, comparison, etc) works about the same the only difference being that parenthesis are not required inside if statements.

For switch statements, break; is not required / used, so if you want to execute the next condition in another case you need to use the reserved keyword fallthrough.

Now "range" operators are a bliss for numerical comparisons and array checking, the half-open range ..< or ..> implies that the range is not inclusive ex: 1..<5 is 1,2,3,4. Where the full range operation is inclusive so 1...5 is 1,2,3,4,5.
On the same fashioned way one can print specifics inside an array with this operator, ex:

let rangedArray: [Int] = [1,2,3,4]; print(rangedArray[1...]);

prints:
[2, 3, 4]

100 Days of Swift - Day 2

Davmi Jose Valdez Ogando — Wed, 30 Mar 2022 21:35:24 +0000

Continuation of Hacking With Swift 100 Days of Swift

Day 2 - Arrays, Dictionaries, Sets and Enums

Arrays are a standard, type declaration is not. instead of int[] in swift we do [Int]
Sets are quite simple, just use the named reserved function Set. Have in mind that these guys are unordered, not random, just unordered.
Talking about functions, in swift you only use func nameOfFunction(property: type), as a definer, but when you call them you need to do it weirdly as nameOfFunction(property: value).
Tuples like in .Net are fixed size, but have the advantage that can be named (iirc Named tuples only come later in .Net 8 or something).
Dictionaries are declared like in JavaScript, which btw accessing a none existing key instead of throwing an error returns nil (null in other languages, let's not talk about undefined), if you don't want nil to show you can use dictionary["nonExistingKey", default: "fallback string"]. Lastly, for type declaration we go as [String: otherType] ex [String: Double].
Enums are declared differently, but just a bit. Inside each option of an enum you'd have to add the reserved keyword case, which results in enum Directions { case north; case south } and for specific values inside enums, works exactly like .Net. ALERT: the semicolon is only needed since this is an enum declared as a one liner, in a line break enum the semicolon is not required. Enums in swift can also have an associated value, where we can create something like enum Weather { case sunny; case windy(speed: Int) } and we would get windy(speed: 25) as a result.

Side note:
I need to look up for swift naming standards eventually.

100 Days of Swift - Day 1

Davmi Jose Valdez Ogando — Tue, 29 Mar 2022 22:47:03 +0000

Today I started the journey on becoming an iOS native developer. Coming from 4+ years of .Net and Xamarin experience, mobile has been my passion for a while now.

After some side gigs, I've finally managed to get a Mac. Therefore starting today I'll do my best to keep on a streak and follow Hacking With Swift 100 Days of Swift which has been suggested by a friend to start learning the language.

Summary:

Day 1 - Variables, Simple data types and string interpolation

The first day as to be expected is a run down on how the language works. Declaring strings, integers, doubles and booleans.

Coming from .Net the moment you see a var you may immediately understand that it refers to a variable, what's a little bit shocking for JavaScript enthusiasms is the fact that let is used for constants.

The variable types don't have to be specified at the time you declare them, since swift is smart enough to assume the data type given the value assigned. But in case you want to add a type right after it is done like this: let myVariable: Int = 42;. Semicolons are optionals unless you want to write multiple sentences in the same line (am sure I'll use them just like always).

For the always useful String Interpolation in swift you only need "This is a string with some value: \(variable)" for it to work, nice to remember and will try not to confuse it with "string and ${variable}".

So far so good but this are just the basics, might try to do Day 2 later too.