Swift初体验

Swift特色

可以使用现有的 Cocoa 和 Cocoa Touch 框架

Swift 取消了

OC 的指针

及其他不安全访问的使用

舍弃了 OC 早起应用 Smalltalk 的语法,全面改为句点表示法

提供了类似 Java 的名字空间(namespace),泛型(generic),运算对象重载(operator overloading)

Swift 被简单地形容为

没有C 的 OC

Swift 与 OC 的不同

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语句

没有小括号 ‘()’可以省略

必须写大括号

{}

,即使只有一句代码,也要写

没有

非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)
})
}
}