本文将带你了解IOS开发入门iOS-Swift3常用语法，希望本文对大家学IOS有所帮助。

常量和变量
   在Swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量
   使用let来定义常量,定义之后不可以修改
   使用var来定义变量,定义之后可以修改
   ?123456//定义标示符表明是变量还是常量!//let  常量let age : Int = 24//var  变量var  name = "qiuxuewei"var PI:Double = 3.1415
   注意事项:
   常量:是指向的对象不可以再进行修改.但是可以通过指针获得对象后,修改对象内部的属性
   在真实使用过程中,建议先定义常量,如果需要修改再修改为变量(更加安全)
   ?123456789//定义常量View 和 btn 可以利用指针指向的不可修改的对象,对对象内属性进行更改,推荐使用let定义常量let view  = UIView(frame: CGRect(x: 16, y: 64, width: 100, height:  100))view.backgroundColor = UIColor.red let btn = UIButton(type:  UIButtonType.custom)btn.frame = CGRect(x: 8, y: 8, width: 64, height:  64)btn.setTitle("确定", for:  UIControlState.normal)btn.backgroundColor =  UIColor.greenview.addSubview(btn)
   Swift中数据类型
   Swift中的数据类型也有:整型/浮点型/对象类型/结构体类型等等
   整型
   有符号
   常用:Int : 和平台相关(默认,相当于OC的NSInteger)
   Int8 : 有符号8位整型
   Int16 : 有符号16位整型
   Int32 : 有符号32位整型
   Int64 : 有符号64位整型
   无符号
   UInt : 和平台相关(常用,相当于OC的NSUInteger)(默认)
   UInt8 : 无符号8位整型
   UInt16 : 无符号16位整型
   UInt32 : 无符号32位整型
   UInt64 : 无符号64位整型
   浮点型
   Float : 32位浮点型
   Double : 64浮点型(默认)
   ?1234// 定义一个Int类型的变量m,并且赋值为10var m : Int = 10//  定义一个Double类型的常量n,并且赋值为3.14let n : Double = 3.14
   Swift是强类型的语言
   Swift中任何一个标识符都有明确的类型
   即如果将一变量定义为整型,就不可对他进行浮点型的赋值
   ?12345678// 定义变量时没有指定明确的类型,但是因为赋值给i一个20.20为整型.因此i为整型var i = 20//  错误写法:如果之后赋值给i一个浮点型数值,则会报错// i = 30.5 // 正确写法var j = 3.33j = 6.66
   Swift中在进行基本运算时必须保证类型一致
   ?12345//对不同类型的变量/常量进行运算需要将其转化为相同类型的let a = 20let b = 13.14let c = Double(a)  + bprint(c)
   逻辑分支
   分支即if/switch/三目运算符等判断语句,通过分支语句可以控制程序的执行流程
   if语句
   在Swift的判断句中必须有明确的真假
   不再有非0即真
   必须有明确的Bool值
   Bool有两个取值:false/true
  //判断句必须有真假值var d:Int = 2;if d  != 0 { }else{ } var score = 99if score < 60  {    print("不及格")}else if score <  80{    print("及格")}else if score <  100{    print("优秀")}else{    print("毕业")} //可选类型,因为只有声明成可选类型后,才可以判断是否为空let  ifView :UIView? = UIView(); if ifView !=  nil{    print("有")}else{    print("没有")}
   三目运算符
   跟OC格式保持一致
   //三目运算符a == score ? a : score
   guard
   guard是Swift2.0新增的语法
   它与if语句非常类似，它设计的目的是提高程序的可读性
   guard语句必须带有else语句，它的语法如下：
   当条件表达式为true时候跳过else语句中的内容，执行语句组内容
   条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw
  guard 条件表达式 else {    //  条换语句    break}语句组
  //guardvar Age = 18func online(age:Int) ->  Void{    guard age >= 18 else  {        print("回家去")        return    }    print("可以上网")}online(age:  Age)
   switch
  //switch  用法//sex:0 -> 男  sex:1 -> 女let sex = 0//普通用法 - case后可以不跟break(默认会有break)switch  sex{case 0:    print("男")case  1:    print("女")default:    print("未知")} //可判断多个值switch  sex{case 0,1:    print("正常人")    //如果case穿透需要加此关键字//     fallthroughdefault: break//     print("不正常")} //如果希望出现之前的case穿透,则可以使用关键字fallthroughlet Sex =  0 switch Sex {case 0:    fallthroughcase  1:    print("正常人")default:    print("其他")} //浮点型的switch判断let  f = 3.14switch f {case  3.14:    print("π")default:    print("not  π")} //可判断字符串let sexStr = "人妖"switch sexStr {case  "男":    print("男")case  "女":    print("女")default:    print("人妖")} //区间判断//swift中的区间常见有两种//开区间:0..<10  表示:0~9,不包括10//闭区间:0...10 表示:0~10score = 59switch score{case  0..<60:    print("不及格")case  60..<80:    print("及格")case  80...100:    print("优秀")default: break}
   循环
   for循环
   在swift3以后摒弃了C语言常用的 var i = 0; i < 6; i++ 格式
   //for 循环//0-4循环for i in 0 ..< 5   {    print(i)}//0-5循环for i in 0 ... 5  {    print(i)}//2次循环不需要变量for  _ in 0 ..< 3{    print("Hello  world!")}
   while循环
   while的判断句必须有正确的真假,没有非0即真
   var aa = 0while aa < 10 {    //在swift3以后摒弃了  a++ 操作 改为 a+=1    aa += 1}print(aa)
   repeat while循环
   swift中将 do-while 改为 repeat-while
   var bb = 0repeat  {    print(bb)    bb += 1} while bb  < 10
   字符串
   OC和Swift中字符串的区别
   在OC中字符串类型时NSString,在Swift中字符串类型是String
   OC中字符串@”“,Swift中字符串””
   使用 String 的原因
   String 是一个结构体，性能更高
   NSString 是一个 OC 对象，性能略差
   String 支持直接遍历
   Swift 提供了 String 和 NSString 之间的无缝转换
   //字符串let str = "I am  qiuxuewei" //遍历字符串for cc in  str.characters{    print(cc)} //字符串截取  将String转化为NSSring 操作 (xxx as NSString)let MyName = (str as  NSString).substring(from: 5)  //字符串与其他类型数据拼接let tempHeight : Double  = 1.83let tempHeight1 = "身高 \(tempHeight) cm"let tempHeight2 =  "身高" + "\(tempHeight)" + "cm" //字符串格式化 -  用于保留n位小数或格式化时间格式let min : Int = 9;let doc : Int = 8; //let time : String  = String(format: <#t##string#>, arguments: <#t##[cvararg]#>)let  time: String = String(format: "%02d分 : %02d秒", arguments: [min,  doc])
   数组
   数组（Array）是一串有序的由相同类型元素构成的集合
   数组中的集合元素是有序的，可以重复出现
   Swift中的数组
   swift字典类型是Array，是一个泛型集合
   数组分成:可变数组和不可变数组
   使用let修饰的数组是不可变数组
   使用var修饰的数组是可变数组
   //数组//b不可变数组let arr1 : [String] =  ["邱学伟","王珂惠","妈妈"]let arr2 =  ["邱学伟","王珂惠"]let arr3 =  ["邱学伟","职坐标学习","不羁阁","疯火科技"] //可变数组var  arrM1 = arr3;var arrM2 : [Any] = ["身高",1.83  ]  //添加元素arrM1.append("10000000") //删除元素//删除最后一个元素并且会把最后一个元素返回arrM1.removeLast()//移除指定下标元素arrM1.remove(at:  0)  /遍历数组//通过下标遍历for i in 0..
   字典
   字典允许按照某个键来访问元素 字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合  键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的 Swift中的字典  Swift字典类型是Dictionary，也是一个泛型集合
   Swift中的可变和不可变字典 使用let修饰的数组是不可变数组 使用var修饰的数组是可变数组
   ?12345678910111213141516171819202122232425262728293031323334353637383940414243//字典//不可变字典let  dict1 : Dictionary=  ["name":"邱学伟" as AnyObject,"age":24 as  AnyObject]let dict2 : [String : AnyObject] = ["name" :  "邱学伟" as AnyObject, "height" : 1.83 as AnyObject]let  dict3 : [String : Any] = ["name" : "邱学伟", "age"  : 24] //可变字典var dictM1 : Dictionaryvar dictM2 : [String : Any]var dictM3 =  ["name" : "邱学伟", "age" : 24] as [String :  Any] //操作字典//增dictM3["height"] =  1.83 //删dictM3.removeValue(forKey: "age") //改dictM3["老婆"]  = "王珂惠" //遍历字典//keyfor key in dictM3.keys{//     print(key)} //valuefor value in dictM3.values {//     print(value)} //key和valuefor (key,value) in dictM3 {    print(key  , value)} //字典合并var dictM4 = ["学历" :  "本科","电话" : "110"] as [String : Any]for  (key,value) in dictM3 {    dictM4[key] =  value}
   元祖
   swift新增数据类型 类似于数组或者字典 可以用于定义一组数据
   //定义元组 常用作函数的返回值let tuple2 = (crazyfire1 :  "ZAR",crazyfire2 : "扩散",person : 6) //常用的定义方法 let tuple1  = ("ZAR","扩散","Wish",6);let (crazyfire1,crazyfire2,person1,personNumber)  =  ("ZAR","扩散","Wish",6) //用法tuple2.crazyfire1 let  error = (errorCode : 404, errorInfo : "Not  Found")print(error.errorCode)print(error.errorInfo)
   可选类型
   在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)  在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强语言)  但是开发中赋值nil,在所难免.因此推出了可选类型
   可选取值: 有值/空值
   //可选类型//错误写法!//var  optionalNameError : String = nil//正确定义写法//定义方法1:var optionalNameRight :  String? = nil//定义方法2:var optionalName : Optionalclass  person{    var optionalName :  Optional} //可选类型拆包optionalName = "xiaoming" //一般在拆包时需要对可选类型进行判断,是否为空//此种写法容易产出崩溃点let  xxxName = "呵呵哒的" + optionalName! //定义var phoneNum :  String?  phoneNum = "+86  110" //swift中如果进行强制解包操作会崩溃,所以在解包的时候需要进行判断if phoneNum != nil{    var  changePhoneNum = "new" +  phoneNum!} //可选绑定,判断phoneNum是否有值,1如果没有值直接跳过,2如果有值拆包后将值赋值给tempPhoneNumif  let tempPhoneNum = phoneNum  {    print("解包后有值")} //可选类型应用场景let  URLString = "www.qiuxuewei.com"let URL : NSURL? = NSURL(string:  URLString) //创建NSRequest对象//需要先判断可选类型数据是否有值if URL !=  nil{    let request = NSURLRequest(url: URL! as  URL)} if let tempURL = URL {    let request = NSURLRequest(url:  tempURL as URL)}
   函数
   即为OC中的方法 定义格式:
   func 函数名(参数列表) -> 返回值类型  {    代码块    return 返回值}
   函数的四种类型:
   //函数//1.没有参数,没有返回值func  run() ->  Void{    print("跑跑跑...")}run() //其中如果函数木有返回值,  " -> Void "可以省略!func run2()  {    print("省略后,跑跑跑...")}run2()  //2.有参数,没有返回值func  callPhone(PHONE : String) -> Void{    print("打电话给  \(PHONE)")}callPhone(PHONE: "110") func callPhone2(PHONE  : String){    print("打电话给 \(PHONE)")}callPhone2(PHONE:  "119") //3.没有参数,有返回值func readMsg() ->  String{    return  "今天早起学习了么?"}print(readMsg()) //4.有参数,有返回值func add(number1 :  Double, number2 : Double) -> Double{    return number1  + number2}print(add(number1: 100, number2: 9.99))
   默认参数 某些情况,如果没有传入具体的参数,可以使用默认参数
   //默认参数func makeSport(type : String = "篮球") ->  Void{    print("打\(type)")}makeSport()makeSport(type:"排球")
   可变参数 swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数 它们必须具有相同的类型  我们可以通过在参数类型名后面加入（…）的方式来指示这是可变参数
//可变参数func sum(numbers : Double...) ->  Double{    var total : Double =  0.00    for number in numbers  {        total +=  number    }    return  total}print(sum(numbers: 1,2,3))
   引用类型(指针的传递) 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要在函数内部将传递值设置为变量 因为需要在内部改变其值
   //交换两个值//值传递func swap1( a:Double,  b:Double){    var b = b    var a =  a     let temp = a    a =  b    b = temp     print("交换后:  a\(a) ,b\(b)")}swap1(a: 1, b: 9)
   类
//类class  Person :  NSObject{     //存储属性    //1>如果类型是结构体或类,定义为可选类型    //2>如果是基本数据类型,定义时直接初始化0  / 0.0    var name : NSString?    var  age = 0    var height = 0.00 } class student :  Person {     //存储属性    var  chineseScore = 0.0    var mathScore =  0.0     //计算属性,由其他属性值计算而来    var  totalScore :  Double{        //可省略get//         get{            return  chineseScore + mathScore//         }    }     var avgScore : Double{        return  ( chineseScore + mathScore ) *  0.5    }     //类属性,设置或者获取属性值必须通过类名进行获取    static  var scoreCount : Int = 2;} let stu = student();stu.name =  "邱学伟"stu.age = 18stu.chineseScore = 119stu.mathScore =  120stu.totalScorestu.avgScorestudent.scoreCount
   自定义构造函数
  class Animal : NSObject{    var  type : String?    var name :  String?     //自定义构造函数    init(type  : String, name : String)  {        self.type =  type;        self.name = name;    }} let  cat = Animal(type: "猫", name: "咪咪")cat.typecat.name
   字典转模型式自定义构造函数
  //字典转模型 构造方法class Dog :  NSObject{    var master : String = ""    var  age : Int = 0     init(dict : [String : Any])  {        self.master =  dict["master"] as!  String        self.age =  dict["age"] as! Int    }}let 哈士奇 = Dog(dict:  ["master" : "邱学伟", "age" :  10])哈士奇.master哈士奇.age
   swift支持类的继承,此写法是继承自其他类本类的构造方法
   //字典转模型 构造方法class Dog : Animal{    var  master : String = ""    var age : Int =  0     init(dict : [String : Any])  {        super.init(type:  "猫科", name: "二哈")        self.master  = dict["master"] as!  String        self.age =  dict["age"] as! Int    }}let 哈士奇 = Dog(dict:  ["master" : "邱学伟", "age" :  10])哈士奇.type哈士奇.name哈士奇.master哈士奇.age
   类的运算符重载
   在Java中熟悉的语法,大多数人都不会陌生 注意在自定义的类中不可以继承自NSObject,  NSObject是用OC封装的,有大量OC语法特性.
   class Person: AnyObject {    //运算符重载:    func  sum(num1 : Int,num2 : Int) -> Int  {        return num1 +  num2    }    //参数类型不同    func  sum(num1 : Double,num2 : Double) -> Double  {        return num1 +  num2    }    //参数个数不同    func  sum(num1 : Int,num2 : Int,num3 : Int) -> Int  {        return num1 + num2 +  num3    }}   

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标移动开发之IOS频道！