• • 简介
    • 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 = 0switch 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.23switch r {case 1.23:    print("lian")default:    print("jie")}
      • 2>可以判断字符串
        • let m = 20let n = 10let opration = "/"var result : Intswitch opration {case "+":    result = m + ncase "-":    result = m - ncase "*":    result = m * ncase "/":    result = m / ndefault:    print("非法操作符")}
      • 3>判断区间
        • 全闭区间: 0~10 0…10
        • 半开区间: 0~9  0..<10
        • let scores = 35switch 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 = 10while 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 = 18let iheight = 1.89let str3 = "age is \(iage), height is \(iheight)"
        • 字符串的格式化
          • let min = 2let second = 3let 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)//wwwlet middleString = (urlString as NSString).substringWithRange(NSRange(location: 4, length: 6))//MJBabylet 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
                         
                           = ["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..
      • 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
                         
                           = ["name" : "hmj", "age" : 23]
                         
        • 2>初始化方法二:
          let dict2 : [String : AnyObject] = ["name" : "hmj", "age" : 23]
        • 3>初始化方法三:
          let dict3 = ["name" : "hmj", "age" : 23]
      • 可变字典
        • 1>初始化方式一
          var dictA1 = Dictionary
                         
                          ()
                         
        • 2>初始化方法二:
          var dictA2 = [String : AnyObject]()
        • 3>初始化方法三:
          var dictA3 = ["name" : "hmj", "age" : 23]
    • 基本操作
      • • 1>添加元素
          dictA["name"] = "hmj"dictA["age"] = 23dictA["height"] = 1.70dictA["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.0error.1
      • let error1 = (errorCode : 404, errorInfo : "Not Found")error1.errorCodeerror1.errorInfo
      • let(errorCode1, errorInfo1) = (404, "Not Found")errorCode1errorInfo1
  • 可选类型
    • 注意: 多利用Xcode的提示来使用
    • 概念: nil也是一个特殊的类型,因此推出可选类型
    • 定义可选类型
      • 基本写法
        • 1>方式一:
          optional
                         
                          class Person {    //定义属性    var name : Optional
                          
                           }var avaName : Optional
                           
                            //给可选类型赋值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 = 10var bb = 20//默认情况下,形参是let类型func swapNum(var num1 : Int, var num2 : Int) {
                        let temp = num1    num1 = num2    num2 = temp}//默认是值传递swapNum(aa, num2: bb)aa//10bb//20//地址传递: 需要加关键字inoutfunc swapNum(inout num1 : Int, inout num2 : Int) {    let temp = num1    num1 = num2    num2 = temp}swapNum(&aa, num2: &bb)aa//20bb//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//存储地址:0x7fff1b65d700let stu = Student()//设置或获取其中的值时,必须通过类名调用Student.courseCount = 2stu.name = "hyh"stu.age = 10stu.chineseScore = 98stu.mathScore = 100print(stu.averageScore)//stu.averageScore = 100print(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方法