Swift 01

---

Swift最基本的语法变化

1.导入框架使用 import UIKit (例);
2.定义标识符时,要决定是变量还是常量;
3.语句结束时可以不加分号,前提是一行中只有一行语句 
  有多行语句时还是需要加分号; 
4.打印结果时使用 print("") ,与OC对比不需要添加@符号     

Swift 变量&常量

• 变量

  • 使用 let 定义常量,定义后的常量不能修改;
  • 使用 var 定义变量,定义后的变量可以修改;

• 如何使用

    import UIKit 
     
    //常量 
    let a : Int = 10  
    
    //变量 
    var b : Int = 10  
    
    //输出 
    print(a,b)    
  

• 注意点

  • 定义前应该先定义为常量,需要时在转换成变量,防止被意外修改
  • 是指向的对象不可以再进行修改.但是可以通过指针获得对象后,修改对象内部的属性

• 数据推导

  • 如果在定义一个标识符时直接赋值,则会根据赋值数据类型推导出标识符的数据类型
  • 所以这时可以省略标识符类型
  • 查看标识符类型 Option + 左键

Swift 基本运算

• Swift基本运算中没有隐式转换
• 需要在数据类型一样的情况下才可以进行运算
• Int 转 Double 例 Double(m)

Swift 逻辑分支

• if分支

  • if后面没有括号
  • 没有非零/非nil 即真
  • 需要真正判断true/false

• 三目运算符

  • 与OC一样

• guard (守卫)

  • Swift 2.0后新语法,方便使用,增强代码可读性
  • 判断为true时,执行代码块
  • 判断为false时,执行else {} 内的代码
  • 跳转语句一般为return / break / continue

      guard 条件表达式 else { 
      // 条换语句 
      break 
      } 
      语句组    

• Switch
  • 基本使用与OC一样,Switch后面不带括号
  • case可以有多个值,值之间用逗号隔开
  • case结束默认带break,所以可以不写
  • 如果需要穿透,则需要用到关键字fullthrough
  • Switch支持多种数据类型 如浮点型 , 字符型
  • 可以使用区间判断
    • 半开半闭区间: 0..<10 0~9,不包括10;
    • 闭区间: 0...10 0~10,包括10;

Swift循环

• for循环

  • 常规写法

     for var i = 0 ; i < 10 ; i ++ {
        print (i)
     }    

• 区间for循环

   for i in 0..<10 { 
      print(i) 
   }  
   
   for i in 0...10 {
      print (i)
   }  
  

• 特殊写法

  for _ in 0..<10 {
      print (i)
  }
  

• while 和 do while

  • while后面必须要有正确的真假,没有非0即真

  • while后面可以没有括号
    *do while跟OC有很大的区别,使用repeat代替do

     let a = 0
     repeat {
        print (a)
        b++
     }while a < 20  
    

Swift字符串

• 与OC字符串的区别

  • OC字符串是NSString,Swift字符串是String
  • OC字符串需要使用@,Swift字符串不需要,""即可

• 定义字符串

    //不可变字符串
    let str = "Hello Swift"
    
    //可变字符串
    var strM = "Hello Swift"
    strM = "Hello Pisces" 
  

• 获取字符串长度

  let count = str.characters.count

• 遍历字符串

    var str = "Hello Swift"
    for c in str.characters {
        print (c)
    }
  

• 字符串拼接

   //两个字符串拼接
   let str1 = "Hello"
   let str2 = "Swift"
   let info = str1 + str2
   
   //字符串与数据类型拼接
   let name = "Pisces"
   let age = 20
   let info = "My name is \(name) , I'm \(age)years old"
   
   //字符串的格式化,比如时间 03:04
   let min = 3
   let sec = 4 
   let time = String (format: "%02d:%02d", arguments: [min, sec]) 
  

• 字符串的截取

    //最简单的方式就是转换成NSSring来截取
    
    let str = "Hello Swift"
    //从第0个位置开始截取到第几个位置
    var subStr = (str as NSString).substringToIndex(5) 
    //从第几个位置开始截取
    subStr = (str as NSString).substringFromIndex(6) 
    //从第几个位置开始截取,截取多长
    subStr  = (str as NSString).substringWithRange(NSRange (location: 0,length: 11))
  

Swift数组

• Swift数组类型是Array , 是一个泛型集合

  • 定义一个不可变数组
    let array :[NSObject] = ["Swift",2.0]
  • 定义一个可变的数组 必须初始化才能使用还需要注意数据类型
    var arrayM : [String] = [String]()
arryM = ["Swift"]

• 声明一个Array的类型可以使用以下代码之一

     //尖括号内为类型
     var arrayM1 : Array<String> 
     
     var arrayM2 : [String]
  

• 声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的

• 对数组的基本操作

     var arrayM : [String]
     array = ["Hello"]
     
     //添加数据
     array.append = "Swift"
     //移除元素
     array.removeFirst()
     //更改数据
     array[0] = "Pisces" 
     //查看数据
     array[角标] 
  

• 数组的遍历

  • 遍历数组可以使用一般的for 循环 或者 for in

  • 遍历数组的同时获取下标值

    let names = ["Swift","Pisces","JYD"]
    for (index,name) in names.enumerate() {
        //下标
        print (index)
        //数据
        print (name)
    }
    

• 数组的合并

    //只有相同类型的数组才能合并
    var array1 = ["hellow" , "Swift"]
    var array2 = ["Pisces", "JYD"]
    var array = array1 + array2
  

  • 不建议在一个数组中放多种数据类型

Swift字典

• Swift的字典类型是Dictionary,也是一个泛型集合

  • Swift中使用let修饰的字典是不可变字典
  • Swift中使用var修饰的字典是可变字典

• 在声明一个Dictionary类型的时候可以使用下面的语句之一

    var dict1 : Dictionary <Int,String>
    var dict2 : [Int:String] 
  

• 声明的字典需要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的

    //定义字典的同时,进行初始化
    var dict = ["name" : "Pisces","age" : 21]
    
    //Swift中任意对象,通常不使用NSObject,使用AnyObject
    var dict2 : Dictionary <String,AnyObject>
    dict2 = ["code" : "Swift","author" : "JYD"]
  

• 对字典的基本操作

    var dict = ["name" : "Pisces","age" : 21]
    
    //添加数据
    dict["height"] = 1.88
    
    //删除数据
    dict.removeValueForKey("height")
    
    //修改数据(二选一)
    dict["name"] = "JYD"
    dict.updateValue(20 , forKey:"age")
    
    //查看字典
    dict
  

• 字典的遍历

  • 字典的遍历可以分为遍历字典中所有的值或者所有的键以及所有的键值对

    //遍历所有的键值对
    for (key,value) in dict {
        print (key) 
        print (value)
    }
    

  • 使用for in的方法去遍历

• 字典的合并

    //字典的合并不能使用相加的方式
    var dict1 = ["name" : "Pisces","age" : 20]
    var dict2 = ["height" : 1.88,"weight" : 70]
    
    for (key,value) in dict1 {
        dict2[key] = value
    }  
  

元组

• 元组是Swift特有的,OC并没有相关类型

• What is this?

  • 它是一种数据结构，在数学中应用广泛
  • 类似字典或数组
  • 可以用于定义一组数据
  • 组成元组类型的数据可以称为“元素”

• 元组常见写法

    //定义一个"人"的元组
    let person = (name : "Pisces",age : 21, height : 1.88) 
    
    //取值(方式二选一)
    print(person.name)
    print(person.0) 
  

Swift可选类型

• 概念

  • 在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
  • 在Swift中nil是一个很特殊的类型,因为和真实的类型不匹配所以是不能赋值的
  • 但是开发中赋值nil,在所难免.因此推出了可选类型

• 定义可选类型

  • 一般的定义方法
    let str : Optional<String> = nil
  • 语法糖(经常使用)
    let str : String? = nil

• 可选类型的基本使用

  • 使用print直接打印可选类型的值都会带有Optional

  • 强制解包就没有Optional

  • 强制解包会很危险,程序容易崩,所以使用可选绑定获取可选类型的值,先判断可选类型是否为空,不为空时才打印

    //定义可选类型
    var name : String? = nil
    //赋值 
    name = "Swift"
    //强制解包 
    print("name!")
    //可选绑定 
    if let name = name {
        print("name")
    } 
    

Swift类型转换

• is : 判断一个实例是否为某一个类型
• as : 把一个实例转化成某一个类型
  • as?把实例转成可选类型
  • as!转成具体的类型,但是注意:如果不是该类型,那么程序会崩溃

例子

     //定义一个数组
     var array : [AnyObject] = [21 , "Swift"]
     
     //获取数组中的值
     let object = array.first
     
     //判断实例是否为某一类型
     if object is Int {
        print ("是整型")
     }else {
        print ("非整型") 
     }
     
     let age = object as? Int 
     
     print (age) //结果: Optional(21)
     
     let codeNmae = array[1] as! String
     
     print (codeName) //结果: Swift