Swift梳理

一：基础知识

1. Float与Double有时在比较是比如1.2与1.2的比较为什么表示时不相等?

2. 元组主要是解决什么问题的？

变量定义与数

  • 数
    Int，Float,Double
    同其他语言一样，Int是机器字长。32位长度的Float，64位的Double;小数的表示都是用科学计数法表示。所以64位的Double的精度要高。

  • 常量与变量

var population:Int = 100;
var price:Float = 100.0;
let address:String = "潜江";

if语句,循环语句

//if语句示例
var population = 20;
let name:String = "raojunbo";
if (population < 50 ){
    print("20018:\(name)人口小于\(population)");
}else{
    print("2018:\(name)人口超标了");
}
population = 100;
if(population < 50){
    print("20019:\(name)人口小于\(population)");
}else{
    print("2019:\(name)人口超标了");
}

//switch语句示例
var statusCode:Int = 404;
var statusString:String = "潜江市";

switch statusCode {
    case 400:
        statusString = "很好";
    case 401:
        statusString = "一般";
    default:
        statusString = "默认";
}
print(statusString);

//while循环
var i:Int = 0;
while (i < 10 ){
    print(i);
    i+=1;
}


//for 循环
var i:Int = 0;
for i in 2...6 {
    print(i);
}

元组（Swift特有）

//有点类似于Object-C里的字典，主要是在返回参数时，可以同时返回两个参数
var statusCode:Int = 404;
var statusString:String = "这是状态错误";
let error = (statusCode,statusString);
let error2 = (code:statusCode,error:statusString);
print("\(error.0),\(error.1)");
print("\(error2.code),\(error2.error)")

字符串

Swift字符串的字符都是Character类型，Swift的Character类型表示Unicode字符。组合起来就是字符串的实例

  • Unicode

可空类型（Swift特有）

Swift可空类型让这门语言更加安全，（有点类似于NSObject里的weak属性）一个可能为nil的实例应该被声明为可空类型。在Swift的变量必须给定一个初始值，否则编译不过。也可声明成一个可空类型。任何变量类型都可以用可空类型来说明一个实例可能是nil。哪怕是一个Int类型，而NSObject只能允许对象是nil

  • 可空类型定义
var errorStr = String?;
print(errorStr);
  • 可空类型绑定

将可空变量的真实存在的值赋值给另一个变量，即绑定;绑定的过程也是展开的过程

var play:Int?
if let w = play {
    print(w);
}
//将可空的play绑定到w变量上。是空，不做任何操作，不为空就给w;
  • 可空链式调用
var errorCodeString:String?
errorCodeString = "404";
var upperCodeString = errorCodeString?.uppercased();//链式调用
  • nil合并运算符
var errorDescription:String?;
let description = errorDescription ?? "error"

二：容器类型

数组

这里的数组里的类型必须是相同类型

//数组定义，添加元素，删除元素
var bucketList:[String] = ["rao","jun"];
bucketList.append("bo")
bucketList.append("nihao")
bucketList.removeLast();
for item in bucketList {
    print(item)
}

注意
是用let bucketlist申明的是不可变的数组，是用var申明的是可变的数组

字典

var movieDict = ["rao":1,"jun":2,"bo":3];//申明
movieDict["qing"] = 4//设置
movieDict.removeValue(forKey: "qing")//移出key=qing的值
var keyArray = movieDict.keys;//全部的key值
for item in keyArray {
    print(item)
}

注意
不可变的字典就是用let修饰

集合

函数

func printPersonGreeting2 (to name:String, price:Double,age:Int = 20) {
    print("\(name),\(price),\(age)");
}

printPersonGreeting2(to: "rao", price: 20.0);
printPersonGreeting2(to: "jun", price: 30.0, age: 10);

  • 参数

    一个方法可以定义多个参数，但调用的时候，可以调用这个函数的其他参数的形式。

    函数在定义的时候，有内部参数与外部参数，内部参数是供內使用的，外部参数是供调用时使用的。在定义时也可以特别标记没有外部参数，在需要通过函数内部修改外部的值时，需要标记这个参数inout;

  • 函数返回

//返回一个元组
func sortedEvenOddNumbers(numbers:[Int])->(events:[Int],odds:[Int]) {
    var evens = [Int]();
    var odds = [Int]();
    for number in numbers {
        if(number%2==0){
            //是偶数
            evens.append(number);
        }else{
            //是奇数
            odds.append(number);
        }
    }
    return (evens,odds);
}

let array = [10,1,4,3,43,85,27];
let tupe = sortedEvenOddNumbers(numbers: array);

print(tupe.events)
print(tupe.odds)

//返回可空类型
func gradMiddleName(fromFullName name:(String, String?, String))->String?{
    return name.1;
}
var middle = gradMiddleName(fromFullName: ("rao",nil,"bo"))
if let middleName = middle {
    print(middleName);
}
  • 函数类型

func sortedEvenOddNumbers(numbers:[Int])->(events:[Int],odds:[Int])

上面这个函数的类型，就是([Int])->([Int],[Int])，函数也可以当做一个变量存储。

func sortedEvenOddNumbers(numbers:[Int])->(events:[Int],odds:[Int]) {
    var evens = [Int]();
    var odds = [Int]();
    for number in numbers {
        if(number%2==0){
            //是偶数
            evens.append(number);
        }else{
            //是奇数
            odds.append(number);
        }
    }
    return (evens,odds);
}

let evenOdsFunction:([Int])->([Int],[Int]) = sortedEvenOddNumbers;//将一个函数用一个变量承接起来
let array = [10,1,4,3,43,85,27];
var evenOdds = evenOdsFunction(array);
print(evenOdds)

闭包

函数实际上是闭包的一种。
所有的函数实际上是一种闭包。暂时将闭包理解成一个匿名函数。

  • 闭包的表达式语法
//函数形式
let volunteerSorted = [1,3,40,32,2,77,13];
func sortAscending(_ i:Int, _ j:Int)->Bool {
    return i < j;
}
let volunteer = volunteerSorted.sorted(by: sortAscending);

//闭包完整形式
let volunteer2 = volunteerSorted.sorted { (i:Int, j:Int) -> Bool in
    return i<j;
}

//闭包的缩略形式1
let volunteer3 = volunteerSorted.sorted { (i, j) -> Bool in
     return i<j;
}

//闭包的x缩略形式2
let volunteer4 = volunteerSorted.sorted(by: {$0 < $1});

  • 函数作为返回值

    let volunteerCount = [1,3,40,32,2,53,77,13]
func makeTownGrand()->(Int,Int)->Int {
func buildRoads(lightsz:Int,existingLights:Int)->Int{
    if(lightsz == existingLights){
        return 0
    }else if(lightsz > existingLights){
        return lightsz;
    }else {
        return existingLights;
    }
}
return buildRoads;
}                          
var result = makeTownGrand();//result是一个函数
print(result(10,10));

  • 函数作为参数

  • 闭包能捕获变量

  • 闭包是引用类型

  • 函数式编程

结构体

类

三：高级内容

协议

扩展

泛型

错误处理

四：内存管理和ARC

五：Object-C与Swift的交互
2019/2/27 posted in  Swift

Copyright © 2015 Powered by MWeb,  Theme used GitHub CSS.