swift3.0学习
可选值
可选值:有可能被设置为nil,所有类型都可以被设置.?表示不能拿来运算.!强制解包,如果没有值会崩溃.swift中不会给变量或常量赋初值.
空合运算符:??使用可选值的时候使用.如果有值使用可选值,无值使用后面一个
可选绑定:在条件判断语句中,定义一个临时的变量或常量x,将可选值y的值,赋值给x.如果y有值,则赋值成功,可以使用x,如果y没有值,绑定不成功,可以做异常处理,简称iflet,另一个guardlet,可以减少代码的层级.
iflet
//可以避免频繁的使用?和!
var a1:Int? =5
var b1:Int? =10
if let x = a1{
let c = x + 10
}else{
print("a1没有值")
}
if let a1 = a1, let b1 = b1,b1>5,a1>2{
let c1 = a1 + b1
}
guardlet
func testguard(){
guard let a1 = a1,let b1 = b1,b1>5,a1>2 else{
return
}
let c1 =a1+b1+5
}
可选值举例说明
let string = "http://www.baidu.com/哈哈"
let url = URL(string:string)
在开始时是nil,所以是可选值
var window: UIWiondow?
复杂的数据类型
- 字符串
//let 定义一个不可变的字符串,var定义一个可变的字符串
let str:String = "hello,world"
var str1:String = "hello"
str1.append(",love you")
str.append(",love you") //报错
//拼接
var str2 = str +str1
str2 += ",love you"
//与变量常量拼接,最常用
let name = "xiaoming"
var str3 = "hello,\(name)"
let h = 5, m= 5,s = 5
let time = String(format:"%02d:%02d:%02d",h,m,s)
//字符串的比较,最常用
var stra = "hello"
var strb = "hello"
if stra == strb{}
//字符串是否有前后缀
let result = stra.hasPrefix("h") //前缀
let result1 = stra.hsaSuffix("loa")//后缀
//字符串长度(个数)
let count = strc.characters.count
//字符串的长度(字节数)
let countbytes= strc.lengthOfBytes(using:String.Encoding.utf8)
//range
let strd = "hello,girl"
let index2 = 1
let index3 = 3
let rang = 1...3
let startIndex = strd.startIndex
let endIndex = strd.endIndex
let secondIndex = strd.index(startIndex,offsetBy:1)
let fourIndex = strd.index(startIndex,offsetBy:3)
let swiftRange = secondIndex..<fourIndex
let subStr = strd.substring(with:swiftRange)
//range简单用法
let stre = (strd as NSString).substring(with:NSMakeRange(1,3))//as 类型转换
- 数组
//可变不可变
let arr = ["dog","cat","pid"]
var arr1 = ["dog","cat","pid"]
var arr2:[String] = Array()
var arr3:[String] = []
//数组的遍历
for item in arr1{
print(item)
}
for item in arr1.enumerated(){
pring("\(item.element),\(item.offset)")
}
for item in arr1.enumerated().reversed(){
pring("\(item.element),\(item.offset)")
}
//生成新的倒序数组
let reversedArray = Array(arr1.reversed())
//数组的拼接
let array1 = ["dog","cat"]
let array2 = ["pig","goat"]
var array3 = array1 + array2
//增
array3.append("cow")
//删
array3.remove(at:2)
//改
array3[1] = "snake"
- 字典
//字典的定义
let dic = ["first":"dog","second":"cat"]
var dic1 = ["first":"dog","second":"cat"]
dic1["second"]=nil
let first = dic1["first"]//返回可选值
let dic3:[String:String] = Dictionary()
let dic3:[String:String] = [:]
//Any 和AnyObject
//任何类型和对象
//字典的遍历
let dic5 = ["first":"dog","second":"cat"]
for (k,v) in dic5{
print("\(k),\(v)")
}
let keys = Array(dic5.keys)
let values Array(dic5.values)
//字典的操作//字典的操作都是围绕key值做操作
//增
dic6["third"]= "pig"
//删除
dic6["first"]= nil
//改
dic6["second"]= "snake"
//查,返回的是可选值
let second = dic6["second"]
函数和闭包
- 函数
func 函数名 (参数1:类型,参数2:类型) -> 返回值类型{}
函数参数的默认值,一旦设了默认值,该参数可传可不传.
func addNum(a:Int=5,b:Int)->Int{
return a + b
}
addNum(b:20)
func methodOne () ->Void{
print(#function)
}
//Void是一个空的元组
methodOne()
//有参数没有返回值
func add(a:Int,b:Int){
print("\(a)和\(b)相加,值是\(a+b)")
}
add(a:5,b:10)
//有参数,有返回值
func caculate(a:Int,b:Int)->Int{
return a + b
}
let result = caculate(a:5,b:10)
//函数的参数
//first叫外部参数名,对参数a做解释说明用的
//swift默认给函数的每一个参数都加了一个和形参名字一样的外部参数名,也可以自己定义外部参数名.
func caculatea(first a:Int,second b:Int)->Int{
return a + b
}
let result = caculatea(first:5,second:10)
//我们也可以选择忽略外部参数名
func caculateb(_ a:Int,_ b:Int)->Int{
return a + b
}
let result = caculateb(5,10)
//外部参数名,如果不忽略就必须传
- 闭包:是一个匿名的函数块.函数就是闭包,闭包就是函数,本质就是函数指针.闭包被完整的包括在{}里.
闭包的定义和调用
//定义一个无参无返回值的闭包
func methodOne(){
print("hello")
}
methodOne()
let closureOne = {
print("hello")
}
closureOne()
//定义一个有参数,无返回值的闭包
func methodTwo(a:Int,b:Int){
print("a+b =\(a + b )")
}
methodTwo(a:5,b:10)
let closureTwo = {
(a:Int,b:Int) in
print("a+b =\(a + b )")
}//不会默认给参数添加解释名
closureTwo(5,10)
//定义一个有参数,有返回值的闭包
func methodThree (a:Int,b:Int)->Int{
return a + b
}
let result = methodThree(a:5,b:10)
let clousureThree={
(a:Int,b:Int)->Int in
return a + b
}
let result = clousureThree(5,10)
异步加载的时候使用
//下载一部movie,完成后更新ui
尾随闭包
当闭包可以写在函数的最后一个参数,可以写在函数外面.
如果函数只有该闭包表达式一个参数,则连小括号都可以省略
deinit{
print("byebye")
}
-
window的设置
Snip20160928_1 - 循环引用
Snip20160928_8.png
downloadMovie{
[weak self](movie:String) in
self!.label.text = movie
}
- 闭包修饰符
Snip20160928_9.png
总结
Snip20160928_10.png
swift3.0
类与对象
class Person:NSObject{}
protocol personDelegate:NSObjectProtocol{}
struct MyRect{}
enum MyCase{}
class Dog:NSObject{
var name = "旺财"
init(name:String){
self.name = name
}
//便利构造器,必须调用指定构造器完成构造过程
convenience init(namea:String){
self.init(name:namea)
}
}
class Person:NSObject{
//存储属性,节省cpu,消耗cpu
var name:String
var age:Int
//可选属性,代表这个属性可能有值,可能是nil
var girlFriend:String?
//计算属性,一定有return值的,节省内存,消耗cpu
var kindName:String{
return "亲爱的\(name)"
}
//懒加载属性
lazy var pet :Dog = Dog()
lazy var pet: Dog = {
()->Dog in
let dog = Dog()
dog.name = "小白"
return dog
}()
//构造函数,创建一个对象(完成类的构造的方法)
//构造函数,可以有多个,都叫init
init(name:String,age:Int){
self.name = name
self.age = age
//自动调用super.init()
}
}
let xiaoming = Person(name:"xiaoming",age:20)
print("name:\(xiaoming.name),age,\(xiaoming.age)")
//就是调用一个方法
let kindname = person.kindName
let pet = person.pet
类的属性
存储属性:一直保留
计算属性:调用后立即创建和释放,相当于一个函数
可选属性:属性可以被设置为nil
懒加载属性:调用时初始化初始化
只需要考虑存储属性
Snip20160928_12.png
1.创建一个类,如果没有自己实现构造函数,会有一个默认的构造函数,就是init(){super.init()},指定构造器
2.一旦定义了自己的构造器,则默认就失效
3.便利构造器,简化类的构造过程
let button = UIButton(type:.contactAdd)
- kvc构造器
kvc是基于运行时的,运行时是oc的特性.在swift中,使用kvc时,如果基本的数据类型设为可选,是不兼容的.可以给基本的数据类型,设一个初值
import Foundation
//kvc构造函数:
class Person:NSObject{
var name:String?
var age:Int? = 0
init(dict:[String:Any]){
super.init() //调用完成后,对象已经被创建
setValuesForKeys(dict)
}
override func setValue(,forUndefinedkey ){}
}
重载:参数不同.
