Swift基础

• 简介
  • 2014年推出
• 特点
  • 语法简单,代码简洁,使用方便
• 创始人
  • Chris Lattner在2010年开始设计
• Playground
  • 所见即所得
  • 语法特性发生改变时,可以快速查看
• 基本语法
  • 导入框架时,有时不需要""
  • 定义标识符时必须制定该标识符是常量还是变量
    • 格式: 标识符 : 类型
      • let : 定义常量
      • var : 定义变量
  • 当一行语句结束时,不再需要写;
  • 打印使用print,直接换行
• 变量和常量
  • 注意:
  • 1>在开发中优先使用常量,只有在需要修改时更改为变量
  • 2>常量的意思: 指向对象不可修改(指针不可以修改)
    • 可以通过指针拿到对象,修改内部的属性
• 在swift中创建对象,类()
  • 在swift中使用枚举: 类型.具体类型
• swift类型
  • 整型
  • 浮点型
• swift类型推导
  • 如果一个标示符在定义时有直接复制,那么可以根据后面赋值的类型,来推导出前面标示符的类型,那么就可以省略前面标示符的类型
  • 可以通过快捷键:option + 左键,查看标示符类型
• swift中的基本运算
  • 必须保证类型是一致的
    • 因为swift中没有隐式转化
• 逻辑分支
  • if语句
    • 1>判断句可以不加()
    • 2>判断句结果必须是一个真假值
  • 三目运算符
    • let score = 98
      let result = score >= 0 ? "成绩正确" : "成绩有误"
• guard
  • Swift2.0新增语法
  • 语法:当满足条件判断就跳过else; 当不满足条件判断时就执行else
  • 应用场景: 函数中

• func onLine2(age : Int) -> Bool {
      guard age >= 18 else{
          print("不能上网")
          return false
      }
      print("可以上网")
      return true
  }
  //调用函数
  onLine2(19)

• switch

  • let direction = 0
    switch direction {
    case 0:
        print("north")
    case 1:
        print("south")
    case 2:
        print("east")
    default :
        print("west")
    }

  • case中可以判断多个条件
    • 如果想判断多个条件可以通过,分割

    • switch direction {
      case 0, 1:
          print("north--east")
      default:
          print("south--west")
      }

  • 特殊用法
    • 1>可以判断浮点型

      • let r = 1.23
        switch r {
        case 1.23:
            print("lian")
        default:
            print("jie")
        }

    • 2>可以判断字符串

      • let m = 20
        let n = 10
        let opration = "/"
        var result : Int
        switch opration {
        case "+":
            result = m + n
        case "-":
            result = m - n
        case "*":
            result = m * n
        case "/":
            result = m / n
        default:
            print("非法操作符")
        }

    • 3>判断区间
      • 全闭区间: 0~10 0…10
      • 半开区间: 0~9  0..<10

      • let scores = 35
        switch scores {
        case 0..<60:
            print("不及格")
        case 60..<70:
            print("及格")
        case 70..<90:
            print("良好")
        case 90...100:
            print("优秀")
        default:
            print("成绩错误")
        }

• 循环
  • 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循环中没有用到i,可以将i用_代理

      • for _ in 0..<10 {
            print("MJHee")
        }

  • while
    • 不要()
    • 判断句必须有真假

    • var w = 10
      while w < 20 {
          w++
          print("MJHee")
      }

  • do...while
    • 注意: 在do...while循环中,不要使用do,而是使用repeat代替do

    • repeat {
          w++
          print("YHee")
      } while w < 30

• 字符串
  • 介绍
    • string是结构体,性能更高; NSString是一个OC对象,性能略差
    • string支持直接遍历
    • swift提供了string和NSString之间的无缝转换
  • 使用
    • 遍历字符串

      • var str = "MJHee"
        for s in str.characters {
            print(s)
        }

    • 字符串拼接
      • 两个字符串拼接

        • let str1 = "I Love"
          var str2 = " RiZhao"
          str2 = str1 + str2

      • 字符串与其他数据拼接
        • 格式: (变量/常量名称)

        • let iage = 18
          let iheight = 1.89
          let str3 = "age is (iage), height is (iheight)"

      • 字符串的格式化

        • let min = 2
          let second = 3
          let time = "0(min) : 0(second)"
          let itime = String(format: "%02d : %02d", arguments: [min, second])

    • 字符串截取

      • let urlString = "www.MJBaby.com"
        let prefixString = (urlString as NSString).substringToIndex(3)
        //www
        let middleString = (urlString as NSString).substringWithRange(NSRange(location: 4, length: 6))
        //MJBaby
        let subfixString = (urlString as NSString).substringFromIndex(11)
        //com

      • 提示: 不要使用string方法截取, index非常不好创建
        • urlString.substringFromIndex(index: Index)
      • 解决方法:
        • 建议将string-->NSString-->截取
        • String-->NSString: 只需要在string后面跟上: as NSString
• 数组
  • 类型:
    • Array
    • 可变数组 var修饰
    • 不可变数组 let修饰
  • 初始化
    • 不可变数组
      • 数组定义的写法一:
        

        let names : Array<String> = ["Jack", "Lucy", "Sara"]

      • 数组定义的写法二:

        let nameArr : [String] = ["MJHee", "YHee"]

      • 数组定义的写法三:
        

        let nameArray = ["MJHee", "hmj", "HMJ"]

    • 可变数组
      • 数组定义的写法一:
        

        var names1 : [String] = ["hmj", "lxx"]
        names1.append("HYH")

      • 数组定义的写法二:
        

        var names2 : [String] = [String]()
        names2.append("HMJ")

  • 基本操作
    • 1.添加元素
      

      names3.append("MJHee")
      names3.append("HeeYH")
      names3.append(12)
      names3.append(true)

    • 2.删除元素
      

      names3.removeLast()
      names3.removeAtIndex(0)

    • 3.修改元素

      names3[1] = "MJBaby"

    • 4.取出数组中的元素

      names3[1]

  • 遍历数组
    • 1>通过下标值遍历
      

      for i in 0..<names3.count{
          print(names3[i])
      }

    • 2>forin方式

      for item innames3{
          print(item)
      }

    • 3>区间遍历

      for i in 0..<2{
          print(names3[i])
      }
      for item innames3[0..<2]{
          print(item)
      }

  • 合并数组

    • let array1 = ["hmj", 23, "+86 12344555"]
      let array2 = [1.70, "China"]
      let array3 = array1 + array2
      //不同类型的数组合并
      let name1 = ["hyh", "mj"]
      let ages1 = [12, 23, 18]
      var array4 = [AnyObject]()
      for item in name1{
          array4.append(item)
      }
      for item in ages1{
          array4.append(item)
      }

• 字典
  • 初始化
    • 不可变字典
      • 1>初始化方法一:
        

        let dict1 : Dictionary<String, AnyObject> = ["name" : "hmj", "age" : 23]

      • 2>初始化方法二:
        

        let dict2 : [String : AnyObject] = ["name" : "hmj", "age" : 23]

      • 3>初始化方法三:
        

        let dict3 = ["name" : "hmj", "age" : 23]

    • 可变字典
      • 1>初始化方式一
        

        var dictA1 = Dictionary<String, AnyObject>()

      • 2>初始化方法二:
        

        var dictA2 = [String : AnyObject]()

      • 3>初始化方法三:
        

        var dictA3 = ["name" : "hmj", "age" : 23]

  • 基本操作
    • 1>添加元素
      

      dictA["name"] = "hmj"
      dictA["age"] = 23
      dictA["height"] = 1.70
      dictA["like"] = 13

    • 2>删除元素
      

      //dictA.removeAll()
      dictA.removeValueForKey("like")

    3>修改元素

    dictA["age"] = 18

    • 注意: 通过该方式来修改元素,如果有对应的键就修改,没有对应的键则添加元素
    • 4>取出

      dictA["age"]

  • 对字典的遍历
    • 1>遍历字典中所有的键
      

      for key in dictA.keys{
          print(key)
      }

    • 2>遍历字典中所有的值

      for value indictA.values{
          print(value)
      }

    • 3>遍历所有的键值对

      for (key, value) indictA{
          print(key)
          print(value)
      }

  • 字典合并

    • var dict1A = ["name" : "hmj", "age" : 23]
      let dict2A = ["phone" : "+86 1234556"]
      for (key ,value) in dict2A{
          dict1A[key] = value
      }

      • 注意: 字典无论类型是否一致,都不可以通过直接相加来合并
• 元组
  • 简介
  • 定义
    • 定义元组方式一:
      

      let tem1 = ("hmj", 23, 1.70)

    • 定义元组方式二:最常用

      let tem2 = (name : "hmj", age : 23, height : 1.70)

    • 定义元组方式三:
      

      let (name, age, height) = ("hmj", 23, 1.70);

  • 使用

    • let error = (404, "Not Found")
      error.0
      error.1

    • let error1 = (errorCode : 404, errorInfo : "Not Found")
      error1.errorCode
      error1.errorInfo

    • let(errorCode1, errorInfo1) = (404, "Not Found")
      errorCode1
      errorInfo1

• 可选类型
  • 注意: 多利用Xcode的提示来使用
  • 概念: nil也是一个特殊的类型,因此推出可选类型
  • 定义可选类型
    • 基本写法
      • 1>方式一:
        

        optional<String>
        class Person {
            //定义属性    var name : Optional<String>
        }
        var avaName : Optional<String>
        //给可选类型赋值avaName = "HMJ"//打印可选类型:Optional("HMJ")
        print(avaName)
        //取出可选类型中的值
        //取值: 可选类型 + !,强制解包print(avaName!)
        //拼接let info = "My name is " + avaName!

    • 语法糖
      • 2>方式二:语法糖: 类型?
        

        let phoneNum : String?
        phoneNum = "+86 123556"
        let phoneInfo = "My phoneNum is " + phoneNum!

  • 使用注意: 如果一个可选类型中没有值,强制解包会报错
    • 在强制解包之前,最好对可选类型进行判断,如果有值再进行解包
      • 判断是否有值

        • if phoneNum != nil {
              let phoneInfo = "My phoneNum is " + phoneNum!
          }

        • 可选绑定
          1>如果没有值,就直接跳过{}
          2>如果有值,将可选类型进行解包,并且将解包后的值赋值给tempPhoneNum
          

          if let tempPhoneNum = phoneNum {
              print(phoneNum)//显示: Optional("+86 123556")                   print(tempPhoneNum)//显示: +86 123556
          }

  • 应用场景

    • let urlstring = "http://www.baidu.com"
      //如果写类型那么必须写成可选类型
      let url : NSURL? = NSURL(string: urlstring)
      //如果有中文就会报错
      NSURLRequest(URL: url!)
      //进行判断
      if url != nil {
          NSURLRequest(URL: url!)
      }
      //可选绑定
      if let tempUrl = url {
          NSURLRequest(URL: tempUrl)
      }

• 函数
  • 格式
    • func 函数名(参数列表) -> 返回值类型 {代码块 return 返回值}
  • 类型
    • 1.没有参数,没有返回值的函数
      

      func about1() -> Void{
          print("手机型号是iPhone6s Plus玫瑰金")
      }
      about1()
      注意: 如果一个函数没有返回值,那么:(-> Void)可省略
      func about2() {
          print("手机型号是iPhone6s Plus玫瑰金")
      }

    • 2.没有参数,有返回值的函数

      func readMessage() -> String {
          return"吃饭了吗?"
      }

    • 3.有参数,有返回值
      注意: 如果有多个参数,则参数使用","分割
      

      func sum(num1 : Int, num2 : Int) -> Int {
          return num1 + num2
      }
      sum(20, num2: 30)

    • 4.有参数,没有返回值

      func callPhone(phoneNum : String) -> Void {
          print("打电话给: " + phoneNum)
      }
      callPhone("+86 13355")

  • 函数使用注意点
    • 1.注意一: 内部参数和外部参数
      **num1: 在外部看不见的参数,就是内部参数
      **num2: 在外部可以看见的参数,就是外部参数(即是内部参数也是外部参数)
      **内部参数和外部参数的使用方法
      • 1>默认情况下,函数从第二个从哪回溯开始都是外部参数

        func sum(num1 : Int, num2 : Int, num3 : Int) -> Int {
            return num1 + num2 + num3
        }
        sum(1, num2: 0, num3: 3)

      • 2>如果想让第一个参数成为外部参数,可以在标示符前加"别名"
        

        func sum(num1 num1 : Int, num2 : Int, num3 : Int) -> Int {
            return num1 + num2 + num3
        }
        sum(num1: 1, num2: 2, num3: 3)

      • 3>如果一个参数不想成为外部参数,在标示符前加"_"
        

        func sum(num1 num1 : Int, _ num2 : Int, num3 : Int) -> Int {
            return num1 + num2 + num3
        }
        sum(num1: 1, 3, num3: 3)

    • 2.注意二: 默认参数

      func makeCoffee(coffeeName : String = "拿铁") -> String {
          return"已经制作好一杯(coffeeName)"
      }
      makeCoffee("卡布奇诺")
      makeCoffee()

    • 3.注意三: 可变参数

      func sumNum(nums : Int...) -> Int {
          var result = 0
          for num in nums {
              result += num
          }
          return result
      }
      sumNum(19, 20, 1, 3, 8, 15)

    • 4.注意四: 传入(引用类型)
      

      var aa = 10
      var bb = 20
      //默认情况下,形参是let类型func swapNum(var num1 : Int, var num2 : Int) {
          let temp = num1
          num1 = num2
          num2 = temp
      }
      //默认是值传递swapNum(aa, num2: bb)
      aa//10
      bb//20
      //地址传递: 需要加关键字inout
      func swapNum(inout num1 : Int, inout num2 : Int) {
          let temp = num1
          num1 = num2
          num2 = temp
      }
      swapNum(&aa, num2: &bb)
      aa//20
      bb//10

    • 5.注意五: 函数的嵌套(不建议这样来写)
      

      func test() {
          func demo() {
              func operation() {
                 
              }
          }
      }

• 类
  • 介绍
    • 定义类: class 类名 : SuperClass {定义属性和方法}
  • 注意
    • 可以没有父类,那么该类是rootClass
    • 通常情况下,定义类时,继承自NSObject(非OC的NSObject)
  • 类的使用

    • class Student : NSObject {
          //类的属性
          //**存储属性:
          //注意:
          //1>如果类型是结构体或者类,通常定义为可选类型
          //2>如果类型是基本数据类型,可以在定义时直接初始化为0或者0.0
          var name : String?
          var age : Int = 0
          var chineseScore : Double = 0.0
          var mathScore :Double = 0.0
          //**计算属性: 并不存储实际的值; 必须提供get方法
          var averageScore : Double {
              get {
                  return (chineseScore + mathScore) * 0.5
              }
              //可选的setter方法,并且在setter方法中有一个系统的标示符,用于记录外界传入的值
              //newValue: 用于记录外界传入的值
              set {
                  print(newValue)
                  //没有意义
                  self.averageScore = newValue
              }
          }
         
          //类属性
          static var courseCount : Int = 0
         
      }
      //创建对象
      //<__lldb_expr_37.Student: 0x7fb771f210b0>
      //命名空间:__lldb_expr_282
      //存储地址:0x7fff1b65d700
      let stu = Student()
      
      //设置或获取其中的值时,必须通过类名调用
      Student.courseCount = 2
      
      stu.name = "hyh"
      stu.age = 10
      stu.chineseScore = 98
      stu.mathScore = 100
      print(stu.averageScore)
      
      //stu.averageScore = 100
      print(stu.averageScore)

    • 监听属性的改变

      • class Person : NSObject {
            //Swift中提供了属性监听器,可以监听属性的改变    var name : String? {
                //即将改变       
                //在willSet方法中,系统提供一个标示符        
                //newValue: 用于记录新传入的数据  
             
                //自定义newValue的名称       
                //willSet(new)
                willSet {
                    print(name)//nil
                    print(newValue)//Optional("hmj")
                    //重命名后调用时
                    print(new)
                }
        
                //已经改变       
                //在didSet方法中,系统提供一个标示符       
                //oldValue: 用户记录之前的值 
              
                //自定义oldValue的名称        
                //didSet(old)
                didSet {
                    print(name)//Optional("hmj")
                    print(oldValue)//nil
                    //重命名后调用时
                    print(old)
                }
            }
            var age : Int = 0
        }
        
        let p = Person()
        p.name = "hmj"p.age = 18
        //OC监听属性的改变: 重写set方法