A while back I looked into the Swift programming language but had so many other things on at the time that I didn’t get far with it, so let’s try again but from the basics. <\/p>\n
This post is the equivalent of a cheat sheet<\/em> of the basics of Swift. <\/p>\n Note: ofcourse there’s no way I could include everything about a language in a single post, so this in non-exhaustive and primarily aimed at understanding key points of the language to get us up and running quickly.<\/em><\/p>\n What are the absolute basics I need to know about Swift?<\/strong><\/p>\n Interestingly constants in Swift (using the let<\/em> keyword) are evaluated at runtime, unlike some other languages, hence they can be assigned at runtime.\n<\/li>\n In the above b<\/em> is equivalent to Int(round(1.2))<\/em> and c<\/em> attempts to convert the string to an Int.\n<\/li>\n Value and Reference Types<\/strong><\/p>\n As mentioned above, many types are value types in Swift, these include structures, enumerations and tuples as well as the basic types, Int, Bool etc. which is probably expected, however Array, Dictionary and Set are also value types which might not be expected.<\/p>\n Classes are reference types, and just like many other languages – the big difference between value and reference types is how they’re passed between functions.<\/p>\n Value types are passed by passing a copy of the instance (in other words any changes made are not reflected in the calling code reference). Reference types are passed by reference and hence changes to the instance are reflected in the original instance.<\/p>\n Swift uses COW (copy on write) for assignment of value type instances, however not all value types get this.<\/p>\n Conventions<\/strong><\/p>\n I always believe that when you write code in different languages you should try to write in the conventions and idioms of that languages. <\/p>\n Comments<\/strong><\/p>\n Single line comments start with \/\/ and block comments \/* *\/, one difference to some other languages is we can also nest block comments, for example \/* \/* *\/ *\/<\/p>\n nil and Optionals<\/strong><\/p>\n As mentioned earlier nil<\/em> is the Swift equivalent of NULL, null etc. Swift has optionals (or nullables) which also extend to the String type, hence the syntax String?<\/em> means String is optional\/nullable and we therefor also have syntax such as the following to ensure person<\/em> is not nil<\/p>\n To unwrap an optional we use !, i.e. <\/p>\n Swift also include the nil coalescing operator f<\/p>\n Arrays<\/strong><\/p>\n Arrays are declared using fairly standard [] syntax, i.e.<\/p>\n Dictionary<\/strong><\/p>\n Dictionaries can be declare using a key\/value array syntax, i.e. <\/p>\n Set<\/strong><\/p>\n Sets are simply unordered arrays in essence so can be declared using the same syntax but we need to supply an explicit type to Swift, for example<\/p>\n Strings<\/strong><\/p>\n A string is a struct, hence passed by value and uses standard string syntax as per this example “Hello”<\/em> but also a character is a single string value, i.e. “a”<\/em>.<\/p>\n String interpolation uses the \\(…) syntax, for example<\/p>\n Tuples<\/strong><\/p>\n Most languages seem to include a Tuple type, Swift is no different, we declare a tuple like this <\/p>\n and as we’re not using named parameters, access to the values in the tuple are accessed via<\/p>\n Alternatively we can declare the tuple with named params, i.e.<\/p>\n Now we can access via the names, i.e.<\/p>\n Switch statements<\/strong><\/p>\n Switch statement are very similar to C# etc. except they do not (be default) fall-through to the next case statement, hence break<\/em> is only needed where we need to exit a case block before the end. The default<\/em> case is also not a requirement like it is for exhaustive switch statements.<\/p>\n Let’s look at some examples<\/p>\n We can also use compound cases, i.e. <\/p>\n For integers we can also use ranges do switch on, for example<\/p>\n We can extend this further using the where<\/em> keyword, for example if a value is within a range of values and where it also matches another predicate<\/p>\n Next up, we can value bind a tuple within the case clause, basically meaning we have a way to get the actual value and assign it as part of the matching process, i.e. <\/p>\n So in the above we actual switch on a (0, 0) tuple pattern but then for any other we just assign the first parameter to x<\/em> and discard the second.<\/p>\n I mentioned that break<\/em> is used in some case, for example<\/p>\n On the other hand, if we actually do want our cases to fall-through then we can use the fallthrough<\/em> keyword, i.e. <\/p>\n Loops<\/strong><\/p>\n We’ve seen earlier that ++ and — do not exist in Swift, so the C#\/Java\/C++ way of looping is not going to exist, instead Swift generally uses a syntax more in line with enumerables using ranges (denoted by start<\/em>…end<\/em> to denote the start and end of a loop)<\/p>\n So this works rather like C# foreach<\/em>, hence as you’d expect, we can iterate over array items and dictionaries using pretty much the same syntax, i.e. <\/p>\n With dictionaries we simply deconstruct the tuples of key\/value like this<\/p>\n While loops also exist, and in these we will need to use the += or -= , for example<\/p>\n Functions<\/strong><\/p>\n Functions are written in the form<\/p>\n So this means we’d write an add<\/em> function like this<\/p>\n Calling our add<\/em> function requires that we supply the names of the parameters, so to call this function we’d use the following<\/p>\n In some cases we’d prefer to have anonymous arguments, i.e. not requiring the developer to supply the names, this would require the named parameter to be prefixed by a discard, i.e. <\/p>\n and now we can just supply the arguments by index, i.e. <\/p>\n Interestingly we can also declare function parameters with two names, for example<\/p>\n In this case the first name for<\/em> is the external name, i.e. the caller uses, whereas the second name request<\/em> is the name used internally within the actual function. <\/p>\n Default values for parameters are also supported, for example<\/p>\n Variadic arguments can be used, only one parameter can be variadic however, unlike some languages where this must be the last parameter of a function, due to variable names being used, the variadic argument can be in any position, for example<\/p>\n and we can call this using the following<\/p>\n Many of the other standard syntax exists, such as function overloading, passing functions (which are first class objects in Swift) as arguments etc.<\/p>\n One interesting addition is the requirement to mark functions which change state as mutating<\/em>, for example, assuming the following code was part of a Container class which changes the internal storage when we add items<\/p>\n Guards<\/strong><\/p>\n The guard<\/em> keyword can be used for preconditions on a functions, for example<\/p>\n Closures<\/strong><\/p>\n Swift supports closures and we can assign closures to variables like this<\/p>\n Swift comes with a special syntax for trailing closures<\/em> whereby a function is passed into another function without the need to supply the parenthesis, for example if we have a function like this<\/p>\n We can ofcourse supply one of our previously defined closures like this<\/p>\n but we can also supply the closures as a trailing closure like this<\/p>\n There’s an alternative syntax that allows us to access closure parameters using the parameter index, so for example<\/p>\n Properties<\/strong><\/p>\n We can declare properties on our types like this<\/p>\n Operator overloading<\/strong><\/p>\n Operator overloading is supported, here’s an example<\/p>\n We can also define custom operators, for example<\/p>\n Structs, Classes, Protocols & Enums<\/strong><\/p>\n I’m not going to spend too much time on these four types as they would take up a lot of space in this post (which is already long) but suffice to say we can create a struct, class, protocol and enum (an enum is more like the enums in Java than C# and is a type that may also include functionality). The syntax for each of these is pretty much as expected<\/p>\n A struct is a value type (as discussed previously) and can have properties, methods etc. Structs are heavily uses in Swift. A class is a reference type and as one would expect, can also have properties, methods etc. A protocol is similar to a C# interface bordering on an abstract type as it can contain default functionality.<\/p>\n Enums are able to have values (options) as well as functionality, so here’s a simply example<\/p>\n Extensions<\/strong><\/p>\n Swift also has the ability to create extension methods (as per C#). The extension method can be used on protocols, structs classes etc.<\/p>\n If you’re used to C# extension methods then you’ll know that they allow us to extend frameworks or other libraries (as well as our own) which methods without the need to change the actual types themselves. The syntax for Swift extension is as follows<\/p>\n Namespaces\/Modules<\/strong><\/p>\n It appears that Swift does not (in this current release) have a concept of namespace or modules (or at least not as namespace like units). So what do we do?<\/p>\n The most obvious way of duplicating a namespace (well to a point) is to host code within classes, structs or enums. In the case of a classes and structs we’d want to hide and make private the init()<\/em> <\/p>\n With enums, if they do not contain cases then they cannot be instantiated, hence we can now just include the functions or whatever we want into an enum.<\/p>\n Exception handling<\/strong><\/p>\n Swift uses a slightly different syntax to many other languages, it still has a try<\/em> and a catch<\/em> but the try does not wrap all code that may throw an exception. Exceptions in Swift are of type Error. So instead of wrapping code in a try<\/em> block we wrap it in a do<\/em> with try<\/em> for specific lines, i.e.<\/p>\n In the above we declare our do<\/em> block and our method getString<\/em> potentially throws an error. We therefore try<\/em> to call this method and if all is well, we’ll do something with the returns string. Otherwise we try to catch the error if it’s a MyError.StringError (some error we’ve previously declared in this case) otherwise the catch all takes care of things.<\/p>\n What might our StringError look like? Well as Swift loves it’s enums, we’d potentially declare custom error conditions like this<\/p>\n Swift still uses the concept of throwing errors, so our method getString<\/em> might look like this <\/p>\n One neat feature Swift has around errors is that we can convert them to an optional, so for example<\/p>\n In this case if getString<\/em> throws and error it’s converted to a nil. If, on the other hand we know that the method will not throw an error, for example maybe it throws an error if some member variable has not been set and we know it has been set, then we can disable error propogation using<\/p>\n Generics<\/strong><\/p>\n This “Swift basics” has a lot of topics, I’ve tried to reduce down to bare minimum of functionality most developers would look for or expect within a language. One last one feature we’ll cover is generics. <\/p>\n As somebody who started using generics\/templates way back in my C++ days and was surprised at the lack of them in Java and C# in their early days and even Go today (if I recall). It’s nice to see Swift has generics and uses the fairly standard syntax of <T> (well in some ways fairly standard), i.e.<\/p>\n Swift doesn’t have the concept of default(T)<\/em> like C#, so instead we would use nil (Optional.None).<\/p>\n We can type constrain our generic parameters, for example if had an add<\/em> method which should only work on MyClass<\/em> types we would declare the method like this<\/p>\n Now, I said that Swift uses fairly standard syntax “well in some ways fairly standard”. The difference is when we declare protocols with, what’s called Associated Types<\/em>. In the case of protocols we declare an associatedtype<\/em> within the protocol, for example<\/p>\n When we come to implement the protocol we declare the type via the typealias<\/em>, for example<\/p>\n Ofcourse MyContainer<\/em> itself might take generic parameters and hence we might have<\/p>\n And I think that’s more than enough for this post, other posts will probably focus more on specific parts of the language that are of interest.<\/p>\n","protected":false},"excerpt":{"rendered":" A while back I looked into the Swift programming language but had so many other things on at the time that I didn’t get far with it, so let’s try again but from the basics. This post is the equivalent of a cheat sheet of the basics of Swift. Note: ofcourse there’s no way I […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[286],"tags":[],"class_list":["post-9015","post","type-post","status-publish","format-standard","hentry","category-swift"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/9015","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/comments?post=9015"}],"version-history":[{"count":5,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/9015\/revisions"}],"predecessor-version":[{"id":9217,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/9015\/revisions\/9217"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=9015"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=9015"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=9015"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
\r\nvar a: Int = 1 \/\/ variable, explicit type\r\nvar b = 1 \/\/ variable, implicit type\r\nlet s = "Hello" \/\/ constant, implicit type\r\nlet dbl = 42.9 \/\/ constant double, implicit type\r\nlet fl: Float = 42.9 \/\/ constant float, requires explicit type\r\n<\/pre>\n
\r\nlet million = 1_000_000\r\nlet binary = 0b1010\r\nlet oct = 0o52\r\nlet hex = 0x2a\r\n<\/pre>\n<\/li>\n
\r\nlet a = Double(42)\r\nlet b = Int(1.2)\r\nlet c = Int("123")\r\n<\/pre>\n\r\ntypealias counter = Int\r\ntypealias Predicate = (s: String) -> Bool\r\n<\/pre>\n<\/li>\n
\r\nlet a = b > 0 ? "+ve" : "-ve or zero"\r\n<\/pre>\n<\/li>\n
\r\nif a > 0 {\r\n}\r\n<\/pre>\n<\/ul>\n\n
\r\nif a > 0 {\r\n} else {\r\n}\r\n\r\n\/\/ is preferred over\r\n\r\nif a > 0\r\n{\r\n}\r\nelse\r\n{\r\n}\r\n<\/pre>\n<\/li>\n\r\nlet fn = person?.firstName\r\n<\/pre>\n
\r\nif person.firstName != nil {\r\n let fn = person.firstName! \r\n}\r\n<\/pre>\n\r\nlet a = b ?? c\r\n<\/pre>\n
\r\nlet a = [21, 22, 23] \r\nlet c = a + [45, 46] \/\/ concat the two arrays\r\n<\/pre>\n
\r\nlet d = ["A": "1", "B", "2"]\r\nlet empty = [:] \/\/ empty dictionary\r\n<\/pre>\n
\r\nlet s: Set = [1, 2]\r\n<\/pre>\n
\r\nlet s = "\\(count) items"\r\n<\/pre>\n
\r\nlet t1 = (1, "One")\r\n<\/pre>\n
\r\nlet n = t1.0\r\nlet s = t1.1\r\n<\/pre>\n
\r\nlet t1 = (idx: 1, name: "One")\r\n<\/pre>\n
\r\nlet n = t1.idx\r\nlet s = t1.name\r\n<\/pre>\n
\r\nswitch color {\r\n case "red":\r\n print("it's red") \r\n default:\r\n print("not red")\r\n}\r\n<\/pre>\n\r\nswitch color {\r\n case "red", "white", "blue": \r\n print("it's red, white or blue") \r\n default:\r\n print("not red, white or blue")\r\n}\r\n<\/pre>\n\r\ncase 0...<10:\r\n print("less than ten")\r\ncase 10...20:\r\n print("between 10 and 20")\r\n<\/pre>\n\r\nswitch a {\r\n case 0...10 where a % 2 == 0\r\n print("Event num between 0 and 10")\r\n}\r\n\r\nTuple matching exists where we can match all parameters or some, using a discard to ignore a parameter, for example\r\n\r\n[code language="csharp"]\r\nlet t = (0, 2)\r\nswitch t {\r\n case (0, 0):\r\n \/\/ do something\r\n case (0, _):\r\n \/\/ only care about first item\r\n case (_, 0):\r\n \/\/ only care about second item\r\n}\r\n<\/pre>\n\r\nlet t = (0, 2)\r\nswitch t {\r\n case (0, 0):\r\n \/\/ do something\r\n case (let x, _):\r\n \/\/ get's the first item assigns as x\r\n}\r\n<\/pre>\n\r\nswitch a {\r\n case (let a) where a % 2 == 0\r\n if(a == 4) {\r\n break\r\n }\r\n\r\n print("Even number between 0 and 10 but not 4")\r\n}\r\n<\/pre>\n\r\nswitch a {\r\n case (let a) where a % 2 == 0\r\n print("Is even")\r\n fallthrough\r\n case 4\r\n print("Is 4")\r\n}\r\n<\/pre>\n\r\nfor i in 1...10 {\r\n print(i)\r\n}\r\n<\/pre>\n\r\nlet a = [1,10,200]\r\n\r\nfor i in a {\r\n \/\/ do something with i\r\n}\r\n<\/pre>\n\r\nfor (a, b) in dictionary {\r\n \/\/ do something with a and\/or b\r\n}\r\n<\/pre>\n\r\nwhile i < 10 {\r\n i += 1\r\n}\r\n\r\nrepeat {\r\n i += 1\r\n} while i < 10\r\n<\/pre>\n\r\nfunc funtionName(arg: argType) -> returnType { \r\n}\r\n<\/pre>\n\r\nfunc add(a: Int, b: Int) -> Int {\r\n return a + b\r\n}\r\n<\/pre>\n\r\nadd(a: 1, b: 2)\r\n<\/pre>\n
\r\nfunc add(_ a: Int, _ b: Int) -> Int {\r\n return a + b\r\n}\r\n<\/pre>\n\r\nadd(1, 2)\r\n<\/pre>\n
\r\nfunc data(for request: URLRequest) -> Srring {\r\n \/\/ do something\r\n}\r\n<\/pre>\n\r\nfunction fn(s: String = "Hello") -> Void {\r\n}\r\n<\/pre>\n\r\nfunc addThenMultiply(values: Int..., multiplier: Int) -> Int\r\n{\r\n for v in values {\r\n \/\/ do something\r\n }\r\n\r\n return somevalue\r\n}\r\n<\/pre>\n\r\naddThenMultiply(args: 1, 2, 10, multiplier: 9)\r\n<\/pre>\n
\r\nmutating func add(item: MyClass) -> Void {\r\n}\r\n<\/pre>\n\r\nfunc doSomething(i: Int) -> Void {\r\n guard i >= 0 else {\r\n return \r\n }\r\n\r\n print("Positive")\r\n}\r\n<\/pre>\n\r\nvar c = { print("Inside Closure") } \/\/ () -> Void\r\nvar d = { return 123 } \/\/ () -> Int\r\n<\/pre>\n\r\nfunc fn(f: () -> Int) -> Void {\r\n}\r\n<\/pre>\n\r\nfn(f: d)\r\n<\/pre>\n
\r\nfn {\r\n return 987\r\n}\r\n<\/pre>\n\r\nlet op = (Int, Int) -> Int = { return $0 + $1 }\r\n\/\/ or shorthand version\r\nlet op = (Int, Int) -> Int = { $0 + $1 }\r\n<\/pre>\n\r\nprotocol SomeType {\r\n var error: String { get set } \/\/ read\/write\r\n var instance: String { get } \/\/ readonly\r\n}\r\n<\/pre>\n\r\nextention Math {\r\n static func +(lhs: Math, rhs: Math) -> lhs.value + rhs.value \/\/ assuming value exists on Math somewhere\r\n}\r\n<\/pre>\n\r\nextension Math {\r\n \/\/ prefix style op\r\n static prefix func -><- (value: Int) -> Math\r\n}\r\n\r\n\/\/ in use\r\nlet x = -><- 100\r\n<\/pre>\n\r\nstruct MyStruct {\r\n}\r\n\r\nclass MyClass {\r\n}\r\n\r\nenum MyEnum {\r\n}\r\n\r\nprocotol MyProtocol {\r\n}\r\n<\/pre>\n\r\nenum Color {\r\n case red\r\n case white\r\n case blue\r\n \/\/ ... etc.\r\n\r\n func isRed() -> Bool {\r\n self == .red \/\/ .red shows abbreviated syntax\r\n } \r\n}\r\n<\/pre>\n\r\nextension String {\r\n func appendOne() -> String {\r\n return self + "1"\r\n }\r\n}\r\n<\/pre>\n\r\n@available(*, unavailable) private init() {}\r\n<\/pre>\n\r\ndo {\r\n let s = try getString()\r\n\r\n \/\/ do something with s\r\n} catch MyError.StringError {\r\n print('String Error occurred') \r\n} catch MyError.SomeOtherError(let errorCode) {\r\n print('Some Other Error occurred, error code: \\(errorCode)') \r\n} catch {\r\n print('Unhandled exception occurred \\(error)')\r\n}\r\n<\/pre>\n\r\nenum MyError: Error {\r\n case StringError\r\n case SomeOtherError(errorCode: Int)\r\n}\r\n<\/pre>\n\r\nfunc getString() throws -> String {\r\n throw MyError.StringError \r\n}\r\n<\/pre>\n\r\nlet s = try? getString()\r\n<\/pre>\n
\r\nlet s = try! getString()\r\n<\/pre>\n
\r\nfunc get<T>(index: Int) -> T {\r\n return someValue; \r\n}\r\n<\/pre>\n\r\nmutating func add<T: MyClass>(item: T) -> Void {\r\n}\r\n<\/pre>\n\r\nprotocol Container {\r\n associatedtype Item\r\n mutating func add(item: Item)\r\n func get(index: Int) -> Item\r\n}\r\n<\/pre>\n\r\nstruct MyContainer: Container {\r\n typealias Item = MyClass\r\n\r\n mutating func add(item: Item) {\r\n \/\/ mutate something\r\n }\r\n\r\n get(index: Int) -> Item {\r\n \/\/ return something\r\n }\r\n}\r\n<\/pre>\n\r\nstruct MyContainer<T>: Container {\r\n typealias Item = T\r\n<\/pre>\n