ios开发-Swift快速入门

普通变量

var i = 100var i:Int = 100var i:String = "hello"let c=i+i //c不能改变 

可选类型

//可选类型 任何已知类型后面紧跟？ 即可代表 可选类型 如 Int？var str = “Hello”var num:Int? = str.toInt()  //nil 表示 值缺失//强制解析：在变量或者常量后面添加 ！  注意：必须可选类型的变量和常量缺失油脂的时候才解析成功var num1: Int? = 10var num2: Int? = 20if num1 != nil && num2 != nil{    let sum = num1! + num2!}else{    print(“num1 或者 num2 为 nil ，不能强制解析")}//可选绑定：可以用在 if 和 while 语句中来对可选类型的值进行判断并把值赋给一个常量或者变量var str3: String! = “SWIFT”if var tmp = str3{    }else{    //str3的值为nil 不能解析}//隐式解析可选类型 ： 在已有类型后添加! 如 Int！ 适用于被赋值之后不会重新变为nil的变量var possibleStr: String! = “aaa”print(possibleStr)

字符串链接

var a = "sat"var b = "we"var c = a+bc="\(a)\(b)"

数组定义

var arr = [12,34,"hello",str]var arr = String[]()var arr:[Any] = [“sw”,12,[“ios”:23],Fruit(name:”aaa”)]var arr:[Any] = [Fruit(name:”bbb"),Fruit(name:”aaa")]

dictionary 字典

var dict = ["name":”lalal","age":"16"]dict["sex"]="Female"print(dict)print(dict["name"])

for&while循环

var arr = String[]()for index in 0..100{     arr.append("Item\(index)")}print(arr) //0-99for value in arr{     print(value)}for (key,value) in dict{     print("\(key),\(value)")}var i = 0while i<arr.count{     print(arr[i])     i++}

条件流程

var arr = String[]()for index in 0..100{     arr.append("Item\(index)")}print(arr) //0-99for value in arr{     print(value)}for (key,value) in dict{     print("\(key),\(value)")}var i = 0while i<arr.count{     print(arr[i])     i++}

函数

func sayHello(name:String){     print(name)}sayHello("play")var fun = sayHellofun("Zzz")//->()设置返回值func getNums()->(Int,Int){     return (2,3)}let(a,b ) = getNums()//可变参数：在参数类型后面添加 … 表示该参数可以接受多个参数值func sum(numbers: Int…) -> Int{    var total: Int = 0    for num in numbers{        total += num    }    print(total)    return total}//In-Out 形参func swap(inout a: Int , inout b: Int){    let tmp = a    a = b    b = tmp}var a:Int = 1var b:Int = 3swap(&a,&b)////函数作为参数形式func multiplyTwoIns(a: Int, b: Int) -> Int{     return a*b}//var math: (Int, Int) -> Int = multiplyTwoInsfunc printRES(math: (Int,Int) -> Int, a:Int,b:Int){     print(math(a,b))}printRES(multiplyTwoIns,3,5)////函数作为返回值类型func squre(num: Int)-> Int{     return num*num}func cube(num: Int)-> Int{     return num}func getMathFunc(#type: String) -> (Int) -> Int{     switch(type){         case "squre":         return squre          default:              return cube     }}var mathFunc = getMatrhFunc(type:"other")print(mathFunc(5))

嵌套与闭包

//嵌套func getMathFunc(#type: String) -> (Int) -> Int{    func squre(num: Int)-> Int{     return num*num    }    func cube(num: Int)-> Int{     return num    }     switch(type){         case "squre":         return squre          default:              return cube     }}var mathFunc = getMatrhFunc(type:"other")print(mathFunc(5))//闭包  { (形参列表) -> 返回值类型 in 可执行表达式 }func getMathFunc(#type: String) -> (Int) -> Int{     switch(type){         case "squre":         return {(num: Int) -> Int in                 return num*num           }         default:              return {(num: Int) -> Int in                 return num*num*num          }     }} var mathFunc = getMatrhFunc(type:"other")print(mathFunc(5))//////利用上下文推断var squre: (Int) -> Int = {(num) in return num*num}var squre: (Int) -> Int = {num in return num*num}//省略形参名，通过$0,$1 ...来引用第一个、第二个参数var squre: (Int) -> Int = {$0*$0}print(squre(3))//尾随闭包var result: Int = {    var result = 1    for i in 1…$1{        result *= $0    }    return result}(4,3)print(result)function someFunction(num: Int , fn:(Int) -> ()){}someFunction(20,{})//使用尾随闭包调用函数的格式someFunction(20){}

枚举

enum Season{    case spring = 1，Summer,Fall,Winter}var weather:Season//weather = Season.Summerweather = .Summerprint(Season.spring.rawValue)//原始值/*enum 枚举名：原始值类型{    case 枚举值 = 原始值}*/  var play:[Pler]//关联值enum Planet{    case Earth(weight: Double , name: String)    case Mars(den: Double, name: String,weight:Double)}var p1 = Planet.Earth(weight: 1.0,name:”diqiu”)var p2 = Planet.Mars(3.95,”jingxing”,1.0)switch(p2){//将关联值绑定到变量或者常量来提取    case Planet.Earth(var weight, var name):        print(weight)    case let Planet.Mars(den: d, name:b,weight:w):        print(d)}

面对对象

class Hi{     func say(){          print("Hi")     }    final play(){} //不能被继承}var hi=Hi()hi.say()class Hello:Hi{     var _name:String          //构造     init(name:String){          self._name = name     }          //重写     override func say(){         print(self.name)      }    //方法内参数出第一个默认为外部参数名 需要在参数名前加 _ 来取消    func eat(参数){    }    //类方法    class func wwat(){        }}var h = Hello(name:"AAA")h.say()//结构体struct JKReact{    //mutating func …… 为可变方法 可以更改实例化的存储属性    mutating func moveByX(){    }}//多态向上转型父类调用子类的构造方法 可调用其他方法为父类的方法、子类重写的方法向下转型运算符1> as： 强制将运算符前面的引用变量转换为后面的类型2> as? 可选形式的向下转换（向下转换只能在具有继承关系的两个类型之间进行）

计算属性

class User{    var first: String = ""    var last: String = ""        //定义计算属性    var fullName: String{        //定义计算属性的getter方法，该方法的返回值由first、last两个存储属性决定        get{            return first +”-“+ last        }    //定义计算属性的setter方法，该setter方法将负责改变该实例的first、last两个存储属性        set(newValue){            var names = newValue.componentsSeparatedByString("-“)            self.first = names[0]            self.last = names[1]        }    }    init(first: String , last: String){        self.first = first        self.last = last    }}let s = User(first:"geek",last:"hello")print(s.fullName) //调用get方法s.fullName = “geek-aa” //调用set方法

属性观察者

//willSet(newValue) 被观察的属性即将被复制之前自动调用的方法//didSet(oldValue) 被观察的属性被复制完成之后自动调用的方法class Person{    //存储属性    var name: String = "" {        willSet{            if(countElements(newValue)>6) || (countElements(newValue)<2)            {                print(\(newValue))            }            else{                print(“人名不符合要求，设置成功")            }        }        didSet{            print(“人名设置符合要求，设置成功")        }    }}var p =Person()p.name=“aaa"

下标

struct JK{    var x: Int    subscript(index: Int) -> Int{        get{            switch(index){                case 0:                    return self.x            }        }        set{            switch(index){                case 0:                    self.x = newValue            }        }    }}var rect = JK(x:20)rect[0]=20

可选链

1.使用可选链访问方式：将强制解析的感叹号换成？ ， 在隐式解析的后面也添加 ？ 后缀

2.可选链会自动判断程序访问的关联实例是否为nil

类型属性

static 定义枚举的类型存储属性、计算属性、类型方法，使用可选类型，系统将其初始化为nilstatic var desc : String?static var maxArea: Int{    get{} set{}}static func ser(){}class 定义类的类型计算属性、类型方法class var desc : String{    set{} get{}}class func abs(){} 

嵌套类型

//在类型内部嵌套类型class User{     var holidays:[Weekday]     var location:Point     init(holidays:[Weekday],location:Point){         self.holidays = holidays         self.location = location      }     struct Point{         var latitude: Double         var longitude: Double          var position: Orirntation         enum Orientation{              case Up,Left,Bottom,Right          }     }     enum Weekday{          case Monday,Tuesday     }}

拓展

[修饰符]extension 已有类型{     //添加新功能}修饰符可以省略，或者是private、internal、public其中之一，类型可以是枚举、结构体和类其中之一extension String{     static var data:[String:Any] = [:]          var length: Int{          get{}          set{}     }          func substringFromStart(start: Int,toEnd: Int) -> String{          ……     }          static func valueOf(value:Bool) -> String {         return "\(value)"      }}String.data["swift"] = 89var str = "a"str.length = 5var subStr = str.substringFromStart(5,toEnd:10)String.value(true)//拓展可以增加构造器  //枚举拓展

协议 （类似接口）

语法格式：[修饰符] protocol 协议名:父协议1，父协议2，...{     //协议内容}修饰符：可以省略，也可以是private/internal/public之一协议只能继承协议 不能继承类Struct结构体名:第一个协议,第二个协议,...{     //实现协议要求}Class 类名:SuperClass(父类),第一个协议,第二个协议,...{}