Swift初体验

Swift特色

• 可以使用现有的 Cocoa 和 Cocoa Touch 框架
• Swift 取消了 OC 的指针及其他不安全访问的使用
• 舍弃了 OC 早起应用 Smalltalk 的语法,全面改为句点表示法
• 提供了类似 Java 的名字空间(namespace),泛型(generic),运算对象重载(operator overloading)
• Swift 被简单地形容为没有C 的 OC

Swift 与 OC 的不同

1. Swift 中得类文件都是以 .swift 结尾的,没有 OC 中的. h 与. m
   
   • 没有main.m文件,@ UIApplicationMain 标识程序入口
   • 使用大括号{}标识嘞的范围及方法范围
   • OC 中得initWithXX对应 Swift 中的init(XX:) ,也可以用(xx:)的形式去访问,前面省略了. init
   • Swift 中调用类方法 类名.方法名()
   • 代码后不用加分号,一行就代表一行代码,如果想把多行代码写一行,可以使用;分开
   • 在 Swift 中,枚举分为两部分:枚举名,枚举值名,枚举名可以省略
   • 在 Swift 中,访问当前类的变量/其他 可以不使用self

Playground 介绍

• 就是一个文件

基本语法

let语法

• let 常量—-值不能更改,但是可以修改它的属性
• 不需要指定类型,会自动进行类型推导
• 不同类型之间不能进行计算(例如 int 不能与 double 计算)
  
  • 需要把其中一个转换类型,例如 let a = 1; let b = 1.2; let : Int result = a + Int(b)
• 空格大法 操作符的左右空格必须对称,否则会报错

没有隐式转换

• Swift 对数据类型要求异常严格
• 任何时候,都不会做隐式转换
• 如果要对不同类型的数值进行计算,必须对其中一个数值做显示转换

可选项

• optional: 代表一个变量/常量 可能有值,可能为 nil
  
  • 例如用户头像,有可能用户上传过,也可能没有
• ?: 修饰变量/常量 是一个可选值
• !: 告诉系统该 可选值中一定有值,可以,就可以直接参与计算,如果使用了! ,但是没有值,就会报错
  
  • 在使用!号时一定要谨慎,确定里面是否有值

• ??: 其用于判断可选值是否为空,如果可选值不为空,就直接取其值,否则就取??后面的值

  • 例如 (a ?? 0) + 10

• 可选值不能直接参与计算

• 如果没有值,打印 nil, 如果有值,打印结果会带有Optional

• 用法1:没有赋值 var a: Int?,print(a)

  • 打印结果: nil
• 用法2:赋值 var a: Int?,print(a) = 10
  
  • 打印结果: Optional(10)

if语句

1. 没有小括号 ‘()’可以省略
   
   • 必须写大括号{},即使只有一句代码,也要写
   • 没有非0即真的概念, 必须要指定条件语句的结果为true或者false

if let 固定用来判断值是否有值

• 与 where 联合使用, where 后语句执行结果,必须是 true 或者 false

guard 语法

• guard let u = url else{return} .守护 u 有值,如果没有值,才会进入到大括号里

事例程序

““
//1.NSURL 中只有中文时,无法初始化成功
let url = NSURL(string: “http://www.baidu.com/遮罩”)

    //2.if let 只有当 u 中有值的时候才会进入大括号
    if let u = url{
        print(u)
    }

    //guard let确保 u 一定有值,只有当没有值的时候,才会进入 else 中,而且大括号中一定要有 return
    //一旦 u 没有值,就会进入大括号中,然后就 return, 结束当前函数,后面的语句就会执行
    guard let u = url else{
        print("hello nil")
        return
    }
    print("hello amos")
    print(u)

““

打印结果:


hello nil


switch 语法

• 没有 break, 可以不用写 break,但是 case 后必须跟一行代码
• 可以判断任意类型,不像 OC 中得 switch 只能判断整形
• 不用使用大括号来区分 case 中变量的作用域

• case let where 可用于条件语句,类似于 OC 中得 case 穿透

• 事例程序:
  ““

““

for 循环

• 事例代码

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

    print("====================")

    //取值范围[0,10),可取0到9
    for i in 0..<10{
        print(i)
    }

    print("====================")

    //取值范围[0,10],可取0到10
    for i in 0...10{
        print(i)
    }

““

while

• 在 Swift2.0中, do while 已更改为repeat while

• 事例代码
  ““
  var a = 9

  while a > 0{
      a--
      print(a)
  }
  
  print("===========")
  
   a = 9
  repeat {
      a--
      print(a)
  }while a > 0
  

  ““

字符串 String

• Swift 中.字符串使用String,其实是一种结构体,比NSString轻量级,速度更快
• String 可以支持直接遍历
• String 可以与 NSString 无缝转换
• NSString 里面有些操作字符串的方法String中没有
• 事例代码

““
let str = “别低头,绿帽会掉”

    //直接遍历字符串的字符
    for s in str.characters{
        print(s)
    }

    //打印 utf8编码下的字节长度
    print(str.utf8.count)

    //打印指定编码下的字节长度
    print( str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

    //打印字符串长度
    print(str.characters.count)

““

拼接字符串的三种方式

• 事例

        let c = 10
        let name = "老王"

        //第一种方式
        let result = "我叫" + name + ",年龄" + String(c)

        //第二种方式:在字符串中使用\(变量名) 拼接字符串
        let result2 = "我叫\(name),年龄\(c)"

        //第三种方式:string format 方式
        let result3 = String(format: "我叫%@,年龄%d", name, c)

截取字符串

• 事例

        let str = "听说下雨天和辣条更配哟"

        //1.下标截取
        let r1 = str.substringFromIndex("听说".endIndex)

        print(r1)

        //2.截取到倒数第三位
        let r2 = str.substringToIndex(str.endIndex.advancedBy(-3))
        print(r2)

        //3.计算 rangge 的开始与结尾
        let startIndex = str.startIndex.advancedBy(2)
        let endIndex = str.endIndex.advancedBy(-3)

        let r3 = str.substringWithRange(startIndex..<endIndex)
        print(r3)

打印结果:

下雨天和辣条更配哟
听说下雨天和辣条
下雨天和辣条

数组

与 OC 的不同

• 可以约束数组中可放置元素的类型

• 事例

ar arr1 = ["老王", "老李", 18]
print(arr1)
//1.按照下标取数组中值
print(arr1[1])

//2.在数组末尾添加元素---数组必须是 var 定义的--可变
arr1.append("呵呵哒")

//3.移除元素
arr1.removeFirst(1)
print(arr1)

//4.初始化一个空的数组--可变
var arr2 : [Int] = [Int]()

print(arr2)

//5.添加一个整形数值,如果添加字符串或者其他类型就会报错
arr2.append(18)
arr2.append(19)

print(arr2)


//6.1遍历方式一
for var i = 0; i < arr2.count; i++ {
    print(arr2[i])
}

//6.2遍历方式二
for value in arr2{
    print(value)
}

//6.3遍历方式三
for (index,value) in arr2.enumerate(){
    print("index\(index); value\(value)")
}


//7.数组合并---同类型数组才能合并
let array1 = ["老王"]
let array2 = ["老李","la"]

let array3 = array1 + array2

print(array3)


//8.数组容量
print("数组容量",array3.capacity)

字典

• 字典中取出的值是可选值
• 事例

//1.定义字典--此时 dict1是字典([String : NSObject])类型
var dict1 = ["name":"老王", "age":18]

//1.1打印字典
print(dict1["name"])

//1.2 添加键值对
dict1["no"] = "呵呵哒"

print(dict1)

//1.3移除键值对
dict1["age"] = nil

//2.定义一个空的可变字典

var dict2 =  [String : NSObject]()

print(dict2)

//2.1添加键值对
dict2["name"] = "老王"
dict2["age"] = 19
print(dict2)


//3.遍历字典
for (key ,value) in dict2 {
    print("key:\(key), value:\(value)")
}

//4.0 dict4是[String : String]
var dict4 :[String : NSObject] = ["name":"老王", "age":"22"]

//4.1.字典的合并--dict3是[String : NSObject]字典类型
let dict3 = ["nick":"老李", "no":2]


//此时如果直接赋值会报错,要把 dict4定义成[String : NSObject]
for (k,v) in dict3{

    dict4[k] = v
}

函数

• 事例

//1.定义一个没有参数没有返回值的函数
//格式: func 函数名(){函数执行代码}
func func1(){
    print("定义一个没有参数没有返回值的函数")
}


//2.定义一个有参数没有返回值的函数
func func2(a: Int, b: Int){
    print(a + b)
}

//如果没有'外部参数'的话,第一个参数的名字默认省略
func2(10, b: 50)

//外部参数--提供给外部调用者使用的参数而不会在函数内部使用---使调用者更加明白参数的含义
//格式: func 函数名(外部参数名1 形参名1: 类型 ...){代码}
func func3(num1 a: Int, num2 b: Int){
    print(a + b)
}

func3(num1: 10, num2: 20)

//3.定义一个有参数有返回值的函数
//格式: func 函数名(外部参数名1 形参名1: 类型 ...) -> 类型{代码}
func func4(num1 a: Int, num2 b: Int) -> Int{
    return a + b
}

let result = func4(num1: 2, num2: 3)

print(result)


//4.没有返回值的三种表示方式
//4.1
func demo1(){
}
//4.2 
func demo2() -> (){
}
//4.3
func demo3() -> Void{

}


//5.在函数中嵌套定义一个子函数
func demo4(){
    //---此处还不能调用 demo5

    func demo5(){
        print("嵌套子函数")
    }

    //demo5只能在 demo4中,而且只能从定义结束到 demoe4的结束这个域内可使用
    demo5()
}
//调用 demo4
demo4()

闭包

• 事例

/**
*   1. 闭包---与 OC 中得 block 类似,是一个预先定义好的代码块,在需要的时候去执行
    2. 内部如果使用 self 的话,也需要考虑循环引用
*/

//1.使用嵌套定义子函数的形式
func demoA(){
    func test(){
        print("test")
    }
    test()
}
demoA()

//2.使用闭包--是() -> () 类型--即没有参数,没有返回值
func demoB(){

    //2.1定义闭包
    let test = {
        print("测试闭包")
    }
    //2.2调用闭包
    test()
}

demoB()

//3.有参数无返回闭包
func demoC(){
    //3.1定义闭包
    let test = {(num1 a: Int, num2 b: Int) -> () in
        print(a+b)
    }

    test(num1: 10, num2: 20)

}

demoC()



//4.有参数有返回闭包
func demoD(){

    //4.1定义闭包
    let test = {(num1 a: Int, num2 b: Int) -> Int in

        return a+b
    }

   let r = test(num1: 10, num2: 20)
    print(r)

}

 demoD()

//5.没有参数没有返回值闭包的三种表示方式
func demoE(){

    //5.1 
    let test1 = { () -> () in
        //代码
    }
     test1()

    //5.2
    let test2 = { () -> Void in
        //代码
    }
    test2()

    //5.3

    let test3 = {
        //代码
    }

}

闭包使用

• 举例

        //方式一:
        let finished = { (value: String) -> ()? in
            print(value)

        }

        loadData(finished)

        //方式二:尾随闭包,如果闭包作为函数的最后一个参数时,括号可以提前关闭,该闭包可以写在函数外面
        loadData { (value) -> ()? in
            print(value)
        }

        //方式三:与方式二同理
        loadData( { (value) -> ()? in
            print(value)
        })


    }

    func loadData(finished : (value: String) -> ()?){
       //方式二:尾随闭包,如果闭包作为函数的最后一个参数时,括号可以提前关闭,该闭包可以写在函数外面
        dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
            //模拟网络延迟
            NSThread.sleepForTimeInterval(1)

            let result = "闭包测试"

            //转到主线程
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                finished(value: result)
            })
        }
    }