swift小结01--基础篇

2014年推出的swift目前已来到了3.0，日趋稳定，这个是之前学习整理的关于swift的资料，分享给大家，希望有用，写的不足的地方还请见谅。

语言背景：

        Swift 语言由苹果公司在 2014 年推出，用来撰写 OS X 和 iOS 应用程序。

 

 语言优势：

• 让应用开发更简单、更快、更稳定
• 确保最终应用有着更好的质量

 

一些简单的特点：  

1. 不用；号结束
2. 方法和属性都是用.来使用  区别是方法后有( ),而属性没有( )
3. 在 Swift 中使用 print() 替代 OC 中的 NSLog
4. 在 Swift 中要实例化一个对象可以使用 类名() 的格式，与 OC 中的 alloc/init 等价
5. OC 中的 [[类名 alloc] initWithXXX], [类名 类名WithXXX]在 Swift 中通常可以使用 类名(XXX: ) 找到对应的函数
6. OC 中的 [UIColor redColor] 类方法，在 Swift 中通常可以使用 类名.XXX() 找到对应的函数

 

常量和变量

• 在Swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量
• 使用let来定义常量,定义之后不可以修改
• 使用var来定义变量,定义之后可以修改
• Swift中类型要求异常严格,不一样的类型不能直接操作
• Swift中所有类型的第一个字母都是大写的:Double, Int, Float, String
• Swift中类型转换 类型(要转换的对象)   如果不想让Swift自动推导类型,可以在定义的时候指定类型

类型强转有2种方式 let aa:Float = 值     let aa = Float(变量/值)

 

---

Swift中基本运算

• Swift中在进行基本运算时必须保证类型一致,否则会出错
  • 相同类型之间才可以进行运算
  • 因为Swift中没有隐式转换
• 数据类型的转化
  • Int类型转成Double类型:Double(标识符)
  • Double类型转成Int类型:Int(标识符)

 

 

---

字符串

• • OC和Swift中字符串的区别
    • 在OC中字符串类型时NSString,在Swift中字符串类型是String
    • OC中字符串@"",Swift中字符串""
  • 使用 String 的原因
    • String 是一个结构体（栈里），性能更高
    • NSString 是一个 OC 对象（堆里），性能略差
    • String 支持直接遍历
    • Swift 提供了 String 和 NSString 之间的无缝转换

 

var str = "及法规和第三"

 

//遍历字符串

for i in str.characters{

    print(i)

}

//字符串的长度

let count = str.characters.count

 

//字符串与字符串的拼接

let a = "hhhhhhh"

let b = "jjjjjjj"

let c = a + " " + b

 

//非字符串(需转换成字符串)与字符串拼接

let a1 = 23

let b1 = "kkkk"

let c1 = String(a1) + b1

let c2 = "(a1)"+b1  // "()"在括号中可以传入任何类型然后转变成字符串

 

//字符串格式化

let p = 3.1415926

let format = String(format: "%f", p)

let format1 = String(format: "%d %f", arguments: [p,p])

 

 

//判断一个地址是否后缀是gif

//方法一

let add = "www.baidu.com/aa/bb/cc.gif"

//转小写

let add1 = add.lowercaseString

//判断

add1.hasSuffix("gif")

//方法二

//将String转换NSString

let addr2 = add as NSString

let gif = addr2.substringFromIndex(add.characters.count - 3)

gif == "gif"

 

---

if语句

    Swift没有非0即真, Bool只有2个值 true表示真, false表示假

    Swift中 if 后面的条件可以不需要()

    Swift中if后面的代码即使只有一行,也不能省略{}

    if 后面的条件可以是 Bool类型或者Bool类型的表达式

 

 

let isNb = true

if !isNb {

    print("ture")

}

 

if(isNb){

    print("true")

}

 

let pass = "及格"

let fail = "不及格"

let score = 69

if score > 60{

    print(pass)

}else{

    print(fail)

}

 

//三目运算符  问号前面一定要有一个空格

let ss = score > 60 ?pass : fail

 

---

可选类型

     Swift为了解决忘记对没有值进行判断,搞了可选类型,可选类型的作用:时刻提示你,这个变量或常量有可能有值,也有可能没有,可选如果没有值为nil

    定义可选: 在普通的变量或常量的类型后面加?

 

 

//定义可选类型,不能直接使用，要先拆包，而拆包前需判断是否包为空，或者将包赋值

//两种写法，一般是第一种

let a:Int? = 1000

let a1 = Int?(1000)

 

//拆包： 变量！ 操作时没有进行拆包判断的话，如果包为nil会出错

 

//拆包需要判断是否为nil

if a1 != nil{

    let sum1 = a1! + 100

}else{

    print("拆包为空")

}

 

//let aaa = a1这个式子里先将a1拆包，然后将拆出来的值赋给aaa

if let aaa = a1{

    let sum1 = aaa + 100

}else{

    print("拆包为空")

}

---

for循环

 

for var i = 0; i < 5; i++ {

   

}

 

for var i = 0;i < 10; i++ {

   

}

 

for i in 1...9{

    print(i)

}

 

for i1 in 0..<9{

    print(i1)

}

 

 0...5 范围(区间)运算符: 闭合运算符[a, b], 包含a也包含b: 0,1,2,3,4,5

 0..<5 范围(区间)运算符: 半闭合运算符[a,b),包含a不包含b: 0,1,2,3,4

---

switch语句

Swift中的每个case后面可以不加break,不会跑到下一个case去执行

    fallthrough: 贯穿,执行下一个case

    如果没有匹配完所有的条件必须使用default

    

let score = 77

switch score {

    case 90...100:

        print("优秀")

    case 80..<90:

        print("良好")

    case 76..<80:

        print("中上")

    case 70...75:

        print("中下")

    case 60..<70:

        print("及格")

        break

    default:

        print("不及格")

        break

}

 

swift中的switch可以匹配String, Float, Bool

 

let weekDay = "Thursday"

switch weekDay {

    case "Monday":

        print("星期一")

    case "Friday":

        print("星期五")

    default:

        print("未知")

}

---

数组

 OC中定义数组:

        NSArray *arr = [NSArray array];

        NSArray *arr2 = @[元素1, 元素2, 元素3];

 

    Swift中:

        var修饰的可变数组

        let修饰的是不可变数组

 

//数组

let arr = ["aaa","bbb","ccc"]//[String],元素是sting类型

let arr1 = ["aaa",123]//[NSObject],元素是对象，不建议这样使用

//指定数组类型

let arr2 :[Int] = [1,2,3]

//指定了就不能乱赋值

//let arr3 :[String] = ["aaa",123]

 

 

//定义空数组

let arr3 = [Int]()

let arr4:[Float] = []

 

//遍历数组

let arr5 = ["aaa","bbb","ccc"]

for var i = 0;i < arr5.count; i++ {

//    print(arr5[i])

}

 

for value in arr5{

//    print("value :(value)")

//    print("value:(value)")

}

 

//可同时获取下标和原始的值

for value in arr5.enumerate(){

//    print("下标：(value.index) 元素：(value.element)")

    /*

    下标：0 元素：aaa

    下标：1 元素：bbb

    下标：2 元素：ccc

    */

}

//另一种写法

for (a,b)in arr5.enumerate(){

//    print("下标:(a),元素:(b)")

}

 

//数组的增删改查

var arr6 = ["zhuzhuxia","dawang","xiaoming","55"]

//增加

arr6.append("xxx")//在最后添加

arr6.insert("yyy", atIndex: 0)//在指定下标添加

//删

arr6.removeLast()//删除最后一个

//arr6.removeAll()//删除全部

arr6.removeFirst()//删除第一个

arr6.removeAtIndex(2)//删除第几个

//修改

arr6[2] = "libai"

 

//查看

arr6.count//数组的元素个数

arr6.isEmpty//判断是否为空

 

//数组相加

let arr7 = [1,2]

let arr8 = [4,5]

let arr9 = ["aa","bb"]

let arr10 = arr7 + arr8  //[1, 2, 4, 5]

//不同类型的数组不能相加

//let arr11 = arr8 +arr9

---

字典

let dict  = ["name":"libai","age":55] //[String : NSObject]字典key是String,value是NSObjct类型

var dict1 = ["name":"libai","place":"taiwan"]//[String : String]

//指定字典类型

let dict2 :[String:String] = ["name":"gg","xxx":"ggg"]

 

 

//定义空字典

let dict3:[String:String] = [:]

 

let dict7 = [String:String]()

let dict4 = [String : NSString]()

 

let dict5 = [String:NSObject]()

let dict6 = [String:AnyObject]()

 

//通过key值获取value

let name = dict1["name"]

//遍历

for obj in dict1{

    print("key = (obj.0),value = (obj.1)")

}

for(key1,key2) in dict1{

    print("key = (key1),value = (key2)")

}

//增删改查

//增

dict1["ee"] = "什么？"

print(dict1)

//删

dict1["place"] = nil

dict1.removeValueForKey("ee")

//改

dict1["place"] = "guangzhou"

 

//字典不能相加

let dict9 = ["name": "a"]

let dict10 = ["age": "55"]

//let dict11 = dict9 + dict10

//print(dict1)

---

枚举

      /*

    OC定义枚举类型:

        enum Season {

            Spring = 1,

            Summer = 2,

            Autumn = 20,

            Winter

        };

    定义枚举变量

        enum Season s = Spring;

*/

 

// 定义枚举类型

enum Season {

    case Spring

    case Summer

    case Autumn

    case Winter

}

 

// 定义枚举变量: 枚举名称.成员名称

var s = Season.Spring

s = Season.Summer

 

// 当要修改枚举可以直接 .成员名称

s = .Summer

s = .Winter

 

// 枚举switch

switch s {

    case Season.Spring:

        print("春天")

    case Season.Summer:

        print("夏天")

    case .Autumn:

        print("秋天")

    case .Winter:

        print("冬天")

}

 

// 枚举原始值

enum Direction: Int {

    case east = 1

    case south = 10

    case west = 66

    case north = 88

}

 

// 创建枚举常量

let dir1 = Direction.north

// 获取枚举的原始值

print(dir1.rawValue)

 

// 通过原始值创建枚举常量

let dir2 = Direction(rawValue: 88)

 

print(dir2)

 

if let dir3 = dir2 {

    switch dir3 {

    case Direction.east:

        print("东")

    case Direction.south:

        print("南")

    case Direction.west:

        print("西")

    case Direction.north:

        print("北")

    }

} else {

    print("枚举没有值")

}

---

函数

         C语言函数:
        int sum(int a, int b) {
            return a + b
        }
        调用函数: int c = sum(10, 5);

    Swift中定义函数:
        func: 关键字
        func 函数名称(函数的形参数: 参数类型, ...) -> 返回值类型 {
            函数代码
        }

    函数没有返回值:
        1.返回值什么都不写
        2. -> Void

        3. -> ()

 

// 函数有返回值

func sum(a: Int, b: Int) -> Int {
    return a + b
}

// 函数没有返回值
func sayHello() {
    print("hello world")

}

 

// 调用函数
let c = sum(10, b: 5)

print(c)

 

sayHello()

// 自定义外部参数名: 在形参前面再添加一个名称就是外部参数名
func addStudent(stu_name name: String, age: Int, no: Int) {
    print("添加学生: name = (name), age = (age), no = (no)")
}

// 10000行代码
// 调用
// 外部参数名,作用提示我们每个参数的作用,默认第一个参数不生成外部参数名,其他参数的外部参数名和形参一样
addStudent(stu_name: "liudehua", age: 55, no: 55)

func addStudent2(stu_name name: String, stu_age age: Int, stu_no no: Int) {
    print("添加学生: name = (name), age = (age), no = (no)")
}

addStudent2(stu_name: "liudehua", stu_age: 55, stu_no: 55)

---

闭包

      和OC的Block类似,都是一段先准备好的代码,在需要的时候执行,函数其实也是这样 Block和函数最大的区别:Block可以作为参数传递

    闭包表达式的格式:
        //  in 必须要的,用于区分
        { (形参: 类型, 形参: 类型) -> 返回值 in
            // 闭包代码

        }

     // 1.定义闭包常量：无参数无返回值
        let coluse = { () -> Void in
            print("我是一个闭包")
        }
       
        // 2.调用闭包
        coluse()

       
        // 1.定义一个有参数的闭包
        // 闭包类型: (Int, Int) -> Int
        let coluse2 = { (a: Int, b: Int) -> Int in
            return a + b
        }
       
        // 调用闭包
        let c = coluse2(10, 5)

        print(c）

---

 待续。。。