option click a variable to see where ti si doesn't need semicolonswift is typed with type inference. Type doesnt change once set var firstName = "Chip" var isActive = true var myVariable :Int //Float, Double,Bool, String, Character let daysInWeek = 7 //constant print("d") swift doesnt convert int to double, Double(temp) to convert. Swift does not implicitly convert one type into another. let city = "Los Angeles" var temp = 75 print("The high for \(city) is \(temp) degrees." ) ////////////////////////////////////// if number >= 5 { } else { } ////////////////////////////////////// switch number { case 5 : case 7: case 8...10: //closed range operator, doesnt need break default: break } ////////////////////////////////////// var some_collection = 1...10 // 1..<10 //half open range operaor 1...99 for each_item in some_collection { print("a") } ////////////////////////////////////// functions constant parameter func myfunc(name:String){ // name is set as constant print("myfunc \(name)") } myfunc("mort") variable parameter func myfunc(var a:Int){ // a is set as variable and can be changed a += 1 print("myfunc \(a)") } myfunc(1) set return value func myfunc() -> String{ return "Hello" } myfunc() default value func myfunc2(name:String = "My name"){ return "myfunc \(name)" } myfunc2() myfunc2("mort") multiple parameters: first parameter can be implicit, others should be named func myadd(a:Int = 10, b:Int=20) -> String{ return "result = \(a), \(b)" } myadd(45) myadd(b:200) myadd(45, b:200) external param name func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
In this version of the You can now use these external parameter names to call the function unambiguously:
Arrays are zerobased, typed, var makes it variable, let makes it constant let days = [13, 17, 19] var myarr : [String] myarr = ["a", "b"] myarr.append("c") myarr += ["d"] myarr.insert("e", atIndex:0) myarr.removeLast() myarr.removeAtIndex(3) myarr.count for each_item in myarr { } for (index, value) in shoppingList.enumerate() { print("Item \(index + 1): \(value)") } Dictionaries, associative array, map, hash table key can be any object all keys one type, all values one type var namesOfIntegers = [Int: String]() namesOfIntegers[16] = "sixteen" namesOfIntegers = [:] // namesOfIntegers is once again an empty dictionary of type [Int: String] var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] products.updateValue("Bicycle", forKey:73) //if exists update if not add. returns old value or nil products[55] = nil //remove key/val pair products.removeValueForKey(73) //remove key/val pair products.count for (key,val) in products { } Tuple: ("Hey", 13.5, true, 5) var myTuple=(5, "abcd") func getSongAndDuration() -> (String, Int){ return ("song name", 5) } let temp = getSongAndDuration() print("\(temp.0) with length of \(temp.1)" ) OR NAME TUPLE ITEMS func getSongAndDuration() -> (name:String, length:Int){ return ("song name", 5) } let temp = getSongAndDuration() print("\(temp.name) with length of \(temp.length)" ) let (mysong, mylength) = getSongAndDuration() // name new variables optionals if the value can be nil. use ? vat temp :Int? if temp != nil{ print("the temprature is \(temp!)") // ! is forced unwrapping, works if we know the optional variable has a value and not just nil, otherwise get runtime error } Optional var states = ["AZ":"Arizona", "CA":"California"] var nv = states["NV"] // the result is optional because the key may or may not be present var ca = states["CA"] if let fullName = states["AZ"]{ print(fullName) // if optional is not nil. it already forced unwraps it print(nv) //"nil" //string nil print(ca) //Optional("California") } else{ print("not found") } enum enum weekdays { case sat case sun case mon } var day:weekdays day = weekdays.sat day = .sat //we already know the type or var day2 = weekdays.sat switch day2{ case .sat: cae .sun: case .mon: } closure func myfunc(){ } //simplest closure, but it is unused { println("hi") } let myclosure = { println("hi1234") } func performFivetimes(closureparam:() -> ()){ for i in 1...5{ closureparam() } } performFivetimes(myclosure) performFivetimes( {println("hey") ; println("you're a bad ass")} ) //a function that takes no arameters and returns nothin func test () -> () { } //a closure that takes no arameters and returns nothin var testclosure = { () -> () in } //sorted is a function in swift //sorted(array_to_sort, closure_to_compare) let unsortedArr = [5 ,2, 6, 8 , 10, 4] let sortedArr = sorted(unsortedArr, {(a:Int, b:Int) -> Bool in return a<b}) sortedArr create bits of code and start passing them arround (code injection) Class Player { / either set default values or initialize var name : String func sayHi(){ println("Hi") } init(name){ //reserved keyword we don;t need func for it , to set default values self.name = name } deinit { //cleanup code. doesnt take any parameters, doesnt return any values. you dont need it unless g.g. close db connection. calling deinit is not under your control. swift uses automatic reference counting ARC } } var jake = Player() // this will instantiate jake.name = "2" class GoldPlayer:Player{ //inheritance func newMethod(){} override func sayHi(){super.sayHi()} } when calling class functions we can leave first param unnamed but the rest shoud be named when calling Accessibility private: only accessible from within the same source code file internal: default, accessible across code files, but must be within the same compiled module public: accessible from any module that has imported yours, e.g. frameworks across deiffrent projects final: make function unoverridable or class for a method to be public its class has to be public and vice versa for other accessibility levels var firstName: String var lastName:String var fullName:String{ get{ //return computedproperty return firstName + " " + lastName } set{ //split "newValue" into two pieces var nameArr = newValue.componentsSeparatedByString(" ") firstName = nameArr[0] lastName = nameArr[1] } } init(first:String, last:String){ firstName = first lastName = last } } var per = Person(first:"Jen", last:"Barber") per.fullName = "mor sha" //calls setter per for a comouted property we dont need a set method. you can omit get block class Person { class var a : Int{ return 5 } //class variable lazy var lv = 4; // will not be evaluated unless requested var firstName: String var lastName:String var fullName:String{ //return computedproperty return firstName + " " + lastName } init(first:String, last:String){ firstName = first lastName = last } class func {} //class level method } Person.a property observers: run some code whenever some property changes add a code block right at the end of the property definition class Player{ var name:String = "Ali"{ willSet{ println("about to change to \(newValue)") } didSet{ println("Have changed name from \(oldValue)") } } } var p = Player() p //nothing prints p.name = "john" //prints you cant add observers to lazy prperties just regular ones Structure vs class Strucures are value types (pass by value) value is copied. Int, double, float, bool, String, array, dictionary classes are rereence types (pass by referenece) original object just change class to struct if you want it to be pass by value and any changes to it not affecting its original form when it gpes to a function when you define a struct wift will automatically generate a memberwise initializer for you even if you haven't defined an init Structs do not take part in inheritance, or have deinit object identity check only works for objects not structs(string, int array ,...). checks references === //identical to !== //not identical to Nil coalescing operator ?? we may have a value or we may be nil. if we have a value in the optional we'll use that if not we'll provide a substitute variable and we'll use that instead var personalSite:String? let defaultSite="http://www.google.com" var website:String if personalSite != nil{ website = personalSite! } else{ website = defaultSite } OR var website = personalSite ?? defaultSite type check if object is ClassName object as ClassName (e.g. cast from parent to child) OR try to see if it is of that type then down cast let childObject = object as? ClassName //returns optional if childObject != nil { childObject!.method() } //use ! to forcibly unwrap it before accessing any of its functionality OR also mix unwrpping as before in the if itsefif let childObject = object as? ClassName { childObject.method() // no need for ! } Any(anything), AnyObject(has to be obj) Use is, as, as? to check and downcast As long as you import framerowkrs swift strings which are structures and not technically objects they are bridged to objctive-c nsstring objects. var obj:AnyObject obj = "" obj = tuple or closure wont work protocol a list of methods that you want some class to perform and or properties you want a class to have protocol CleanerProtocol { func cleanFloors() func emptyTrash() -> Bool //properties var brokenBulbs: Int {get} //readonly or read write } class MyClass : SuperClass, CleanerProtocol{ func cleanFloors(){} func emptyTrash() -> Bool{ return true} var brokenBulbs: Int {return 55} } Extension add our own new methods and properties to an existing type without subclassing it. And you don't have to have the source code for it. extension String { //add methosd or properties that you'd like func reverseWord(){return " "} } var a = "" a.reverseWords() Generics Get all benefits of strongly typed objects in returns. Instead of using let myInts = [123, 456, 789, 345, 678, 234] let myStrings = ["red", "green", "blue"] let myObjects = [Player(), Player(), Player()] func displayArray<T>(theArray:[T]) -> T{ println("Printing the array:") for eachItem in theArray { print(eachItem) print(" : ") } println() let finalElement : T = theArray[theArray.count-1] return finalElement } var finalInt = displayArray(myInts) ++finalInt var finalString = displayArray(myStrings) finalString.uppercaseString |