拖了好久的笔记3终于要上来了,这部分笔记主要是补充之前做计算机时没有使用到的swift基础语法。
第一个:Optional
首先要知道,swift里声明变量是不会有默认值的,所以必须要初始化。
然后optional其实就是个长这样的enum:

enum:optional<T>{
case none
case some(T)
}

T是一个数据类型,表示如果这个变量不是一个nil,就是一个T。其中,nil就是optional.none,T就是optional.some,然后通过some(T)来warp好原始值。
举个例子

//声明一个optional
enum:optional<String>{
case none
case some(String)
}
//wrap
let x: String? = nil
let x = optional<String>.none
let x: String? = “hello”
let x = optional<String>.some(“hello”)
//unwarp
var y = x!
switch x {
case some(let value) = value
case none://开始报错,因为根本没得解包
}

所以解包一个nil的时候程序会崩溃。
参考资料:http://blog.csdn.net/zhangao0086/article/details/38640209

第二个:Array
array有let和var两种:
第一种var是可变的,即可以使用append之类的方法,有两种声明方法:
1.var a = array()
2.var a = [String]()
第二种let是不可变的,声明方法例子:
let letters = [“a”,“b”,“c”,“d”]
array的遍历,当然是用循环啦。

例子:

for letter in letters{
println(“\(letter)”)

第三个:Dictionary
Dictionary也是有let和var两种:
var是可变的,有两种声明方法:
1.var ranking = Dictionary<String, int>()
2.var ranking = Dictionary[String: int]()
赋值的时候要这样:ranking = [“a”:1,“b”:10]
let是不可变的:
let ranking = dictionary[“a”:1,“b”:10]
dictionary就是一种键值对的关系。假如说我通过键(值)的关系访问值(键)的时候,访问了一个不存在的键(值),这个时候就会返回nil,所以,dictionary的返回值是个optional。
dictionary的遍历使用的是tuple, 例子如下:

for (key, value) in ranking {
println(“\(key) = \(value)”)
}

tuple的详细可以参考上一篇笔记~

第四个:Range
range是一个包含两种合理类型的两个点,一个是起始点,一个是终止点。
range是有泛型的, 合理类型的意思就是比方说一个array的index往往是个int,所以array里的range的合理类型就是int,range就是int的一个取值区间。

struct Range&lt;T&gt;{
var startIndxt: T
var endIndex: T
}

给range赋值的时候,不用range=xxx这种方式,而是使用“…”和“..<”:
例子:
let array = [“a”, “b”, “c”, “d”]
let subArray1 = array[2…3]//subArray1会是“c”,“d”,“…”表示从一头到另一头
let subArray2 = array[2..<3]//subArray2会是“c”,“..<”表示从一头到另一头,但是不包括另一头
range也可以用循环遍历的。

第五个:各种类
NSObject:
所有oc类的基类
NSNumber:
一个装数字的类,里面有很多很多方法
例子:
let n = NSNumber(35.5)
let intversion = n.intValue //使n转化为int,还有doubleValue,boolValue之类的
NSDate:
一个装日期的类,里面有很多方法,比方说获取当前时间。
NSData:
是data不是date!这是一个装比特的类,里面都是无类型的数据。

第六个:swift里的数据结构
class,struct,enum是组成swift数据结构的三大块,它们有很多相像的地方:
1.声明的语法:
class 名称 {

}
struct 名称 {

}
enum 名称 {

}
2.都可以有属性和方法:
func 函数名(属性名:数据类型)->返回值{

}
属性大概分这两种:
(1)储存用的属性:var storedProperty =
ps:enum本身不可以用于储存,但是可以把值储存在关联信息中。
(2)计算用的属性:
var computedProperty : 数据类型{
set{

}
get{

}
}
3.struct和class可以有initializer,但是enum没有。
init (argument1:Type, argument2:Type, ...){

}
不同点:
1.只有class是可以继承的。
2.只有class可以重写和覆盖。
3.struct和enum是通过值传递(Value)的,class是通过引用传递(reference)的。

第七个:方法(Method)
1.方法重写应该在方法声明前加override。
2.在方法前可以加final,表示该方法不能重写,可以防止子类重写该方法;class前也可以加final,表示该类不可继承,不可修改。
3.所有数据类型(Type)及其实例(instance)都有自己的方法和属性:
例子:
var d: Double = …
//判断d是否是负数
if d.isSignMinus {
//如果d是负数,则d=d的绝对值
d = Double.abs(d)
}

isSignMinus是实例d的属性,但是Double.abs()是类方法,是所有对象共享的。
4.类方法的声明前必须加static。
5.参数名:所有方法里的参数名都有一个内部名(interal)和一个外部名(external),内部名是在方法内部使用的,外部名是给调用者调用方法时候用的。
例子1:

func foo(external internal: Int){
let local = internal
}
func bar(){
let result = foo(external: 123)
}

这里bar()通过external来调用foo,但是foo的内部这个变量叫internal。
例子2:

func foo(_ internal: Int){
let local = internal
}
func bar(){
let result = foo(123)
}

下划线在swift里是忽略的意思。 swift里第一个参数名是有默认值下划线“_”。
例子3:

func foo(internal: Int){
let local = internal
}
func bar(){
let result = foo(123)
}

效果同上例子2.
例子4:

func foo(#internal: Int){
let local = internal
}
func bar(){
let result = foo(internal:123)
}

强制调用者调用方法时第一个参数必须使用参数名:加“#”,对于非第一个参数的参数名是必须要按照方法里的参数名写的,除非其拥有外部名或者下划线。

第八个:Property
1.Property Observer:
通过property observer可以对property进行监视并且做出反应,主要应用于验证设置值以及更新用户接口。
例子:

var someStoredProperty: Int = 1{
willSet{将要进行的操作}
didSet{已经进行的操作}
}
override var inheritedProperty{
willSet{将要进行的操作}
didSet{已经进行的操作}
}

willSet和getSet是property observer的必备,类似于监听到变化然后需要做出反应的两种case,一种是将要进行的反应,另一种是已经进行的反应。如果拟人化一点,就是:通知通知!someStoredProperty发生变化了!observer就位!这个时候,willset就会说“someStoredProperty将会变成xxx样!”然后someStoredProperty就变成xxx样了,紧接着didset就会汇报“someStoredProperty已经变成xxx样了!完成!”
属性有储存属性和计算属性,储存属性里面有get和set,计算属性有willset和didset,但是一个属性不可能既是储存属性优势计算属性,所以不可能一个属性里同时出现get,set,willset,didset。
可以参考:http://swifter.tips/property-observer/
2.lazy initialization:
lazy property只有在被调用的时候才会被初始化,只有var才可以用。
例子1: lazy var a = abc() //a只有在被调用的时候才会初始化,如果abc()里有很多资源文件的话,lazy property的优点就会很明显。
例子2: 可以使用闭包,通过执行这个闭包来初始化这个property,减少不必要运行的代码,提高性能。

let data = 1…3
let result = data.lazy.map {
(i: Int) -&gt; Int in print("正在处理 \(i)”)
return i * 2
}
print("准备访问结果”)
for i in result {
print("操作后结果为 \(i)”)
}
print("操作完毕")

运行结果:
准备访问结果
正在处理 1
操作后结果为 2
正在处理 2
操作后结果为 4
正在处理 3
操作后结果为 6
操作完毕
直接就跳过了不必要的重复的代码。
可以参考:http://swifter.tips/lazy/

因为我也是初学者,所以看公开课的时候思考时间会比较长,要查看的资料也比较多,所以笔记也写的比较慢咯。
如有错误,欢迎斧正~