初窥Swift：从0到1

作者: 張贺 | 来源:发表于2016-08-13 00:54 被阅读266次

图片来自500px

导入框架

//OC中导入框架
#import <UIKit/UIKit.h>
//Swift中导入框架
import UIKit

语句结束

如果一行中只有一条语句，那么该语句结束后，可以不加 ; ，可以省略
但是如果一行中有多条语句，那么需要以 ; 分割

打印内容

let a : Int = 20
//OC中打印内容
//NSLog(@"%d",a);
//Swift中的打印
print(a)

定义标识符

Swift中定义标识符必须告诉编译器是一个常量还是变量
声明常量使用 let 修饰，定义之后不可以修改
声明变量使用 var 修饰，定义之后可以修改

//OC中定义一个标识符
//int a = 10;
//格式  let / var 标识符的名称 : 标识符的数据类型 = 值
//声明常量，其值之后将不能修改
let a : Int = 20
//声明变量，其值在之后可以修改
var b : Int = 10
//修改变量的值
b = 30

常量的本质是其保存的内存地址不可以修改，但是可以通过内存地址拿到对象内部的属性进行修改

//OC中创建UIView
//UIView *view = [[UIView alloc]init];
let view : UIView = UIView()
//通过常量view中保存的内存地址找到UIView对象修改他的backgroundColor属性
//OC中设置view的背景颜色
//view.backgroundColor = [UIColor redColor]
view.backgroundColor = UIColor.redColor()

类型推导

如果在初始化标识符的时候给其赋值可以省略其类型
可以按住option + 鼠标左键查看数据类型

//let a : Int = 20
let a = 20                              //a为Int类型
//let view1 : UIView = UIView()
let view1 = UIView()                    //view1是UIView类型
let view1 = UIButton()                  //view1是UIButton类型

基本运算

Swift中不存在隐式转换，基本运算必须保证类型一致

let m = 20      //Int类型
let n = 3.14    //Double类型
//将int类型转换成double类型：Double(m)
let result = Double(m) + n
//将double类型转换成int类型: Int(n)
let result2 = m + Int(n)

逻辑分支

if、if - else、else if

Swift中的if与OC中的if主要有2点不同：

if后面的（）可以省略
判断条件不再有非0 / nil即真，判断句必须有明确的真假（Bool--->ture / false）

//OC这种判断是可以的，但在Swift中不可以
//int a = 10;
//if (a) {
//    NSLog(@"判断为真");
//}

//Swift中的if else判断
let a = 10
if a > 0 {
    //Swift中的字符串没有 @ 符号
    print("a大于0")
}else{
    print("a小于等于0")
}

//else if 用法和if一致
let score = 99
if score < 0 || score > 100{
    print("分数异常")
}else if score < 60{
    print("不及格")
}else if score < 80{
    print("及格")
}else if score < 90{
    print("良好")
}else if score <= 100{
    print("优秀")
}

三目运算

let a = 10
let b = 20

//var max = 0

//if a > b {
//    max = a
//}else{
//    max = b
//}
//三目运算
let max = a > b ? a : b

guard的使用

guard是Swift2.0新增的语法
他与if语句非常类似，他设计的目的是提高程序的可读性
guard语句必须带有else语句，他的语法如下：
当条件表达式为true的时候跳过else语句中的内容，执行语句组内容
条件表达式为false的时候执行else语句中的内容，跳转语句一般是return、break、continue和throw

guard  条件表达式  else  { 
    //语句
    break
}
语句组

列子：

import UIKit

/**
判断一个人是否可以去网吧上网？
1.是否满18岁?
2.是否带了身份证?
3.是否带了钱?
*/

//这个函数用来判断一个人是否可以去网吧上网？
//用if else 实现，当多重if嵌套的时候可读性并不好
func online (age : Int,IDCard : Bool,Money : Bool){
    //1.是否满18岁?
    if age >= 18 {
        //2.是否带了身份证?
        if IDCard == true{
            //3.是否带了钱?
            if Money == true{
                print("可以上网")
            }else{
                print("已满18岁，带了身份证，没有钱不能上网")
            }
        }else{
            print("已满18岁，但没带身份证，不能上网")
        }
    }else{
        print("未满18岁，不能上网")
    }
}

//用guard实现，可读性更高
func online (age : Int,IDCard : Bool,Money : Bool){
    //1.是否满18岁?
    guard age >= 18 else{
        print("未满18岁，不能上网")
        return
    }
    //2.是否带了身份证?
    guard IDCard == true else{
        print("已满18岁，但没带身份证，不能上网")
        return
    }
    //3.是否带了钱?
    guard Money == true else{
        print("已满18岁，带了身份证，没有钱不能上网")
        return
    }
    print("可以上网")
}

let age = 20
let idCard = true
let money = false
//调用函数
online(age, IDCard: idCard, Money: money)

switch的使用

苹果对switch进行了大大的增强，使其拥有其他语言中没有的特性
与OC的不同之处：
switch后面可以没有（）
case后面也可以没有break（默认会自动加上break，虽然看不见）

import UIKit

//0 带表男 1 代表nv
let sex = 1
//基本用法，与OC一样
switch sex{
case 0:
    print("男")
case 1:
    print("女")
default:
    print("其他")
}

//补充：
//1.如果想让case产生穿透,可以在case结束后加上fallthrough
//2.case后面可以判断多个条件，条件之间以 , 分割
switch sex{
case 0 ,1:
    print("正常人")
default:
    print("其他")
}

Swift中switch的特殊用法：
switch可以判断浮点型

let a = 3.14
switch a {
case 3.14:
    print("π")
default:
    print("不是π")
}

switch可以判断字符串

let m = 10
let n = 20

let operation = "*"
var result = 0

switch operation{
case "+":
    result = m + n
case "-":
    result = m - n
case "*":
    result = m * n
case "/":
    result = m / n
default:
    print("非法操作符")
}

switch可以判断区间
区间：
开区间 0..<10 代表0~9 ，不包括10
闭区间 0...10 代表0~10，包括10

let score = 100
switch score{
case 0..<60:
    print("不及格")
case 60..<80:
    print("及格")
case 80..<90:
    print("良好")
case 90...100:
    print("优秀")
default:
    print("不合法分数")
}

循环结构

for循环

//OC写法
//for (int i = 0 ; i < 10 ; i++){
//    NSLog(@"%d", i);
//}

//Swift写法
//for后面的（）可以省略
//1.for循环的基本写法
for var i = 9; i >= 0; i-- {
    print(i);
}

for循环的for in写法

for i in 0..<10 {
    print(i)
}

for循环的for in写法（特殊）
在Swift中如果一个标识符不需要使用，可以使用 _ 来代替

for _ in 0...9 {
    print("hello world")
}

while / do while

while后面的（）可以省略
while判断句里面不存在非0即真

var a = 10
//OC写法
//while (){
//
//}

//Swift写法
while a > 0{
    print(a)
    a--
}

//OC写法
//do{
//
//}while()

//Swift写法
repeat {
    print(a)
    a--
}while a > 10

字符串

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

创建字符串

//直接指定为String类型
//let str : String = "hello world"
//通过类型推导
let str = "zhanghe"

遍历字符串

for c in str.characters{
    print(c)
}

字符串的拼接
两个字符串之间的拼接

let str1 = "hello"
let str2 = "world"

let str3 = str1 + str2

字符串和其他标识符之间的拼接

let name = "zhanghe"
let age = 18
let hight = 1.90

let info = "my name is \(name) , age is \(age) , hight is \(hight)"

拼接字符串时，字符串的格式化

//08:12
let min = 8
let second = 2

let timeStr = String(format: "%02d:%02d", arguments: [min,second])

字符串的截取

let urlStr = "www.baidu.com"

//这种方法需要传一个Index类型，比较麻烦
//let head = urlStr.substringFromIndex(index: Index)
//这里先把String转换成NSString在进行截取,这里就可以传一个int
let head = (urlStr as NSString).substringToIndex(3)
let body = (urlStr as NSString).substringWithRange(NSMakeRange(4, 5))
let foot = (urlStr as NSString).substringFromIndex(10)

数组

数组（Array）是一串有序的由相同类型元素构成的集合
数组中的集合元素是有序的，可以重复出现
Swift中的数组类型是Array，是一个泛型集合

定义数组

//1.1 定义不可变数组：使用let修饰的标识符创建出来的数组就是不可变数组
let names = ["zh","lsy","cq","lkp"]
//1.2 定义可变数组:使用var修饰的标识符创建出来的数组就是可变数组
//两种方法一样，但实际开发中用下面的
//let namesM = Array<String>()
var namesM = [String]()

对可变数组的基本操作

//2.1 添加元素
namesM.append("lf")
namesM.append("sl")
namesM.append("nm")

//2.2 删除元素
//2.2.1 删除所有元素
//namesM.removeAll()
//2.2.2 删除指定index位置的元素
namesM.removeAtIndex(0)

//2.3 修改元素
namesM[0] = "wsp"

//2.4 查找元素
namesM[1]

数组的遍历

//3.1 根据下标进行遍历
for i in 0..<names.count{
    print(names[i])
}

//3.2 直接遍历数组中的元素
for name in names{
    print(name)
}

//3.3 遍历数组中的前两个(比较少见)
//for i in 0..<2{
//    print(names[i])
//}
for name in names[0..<2]{
    print(name)
}

数组的合并：只有相同类型才可以相加合并

let resultArray = names + namesM
//注意：相同类型的数组才能进行合并，不同类型的数组不能进行合并
let array = ["hhh" ,18 ,90]   //[NSObject]
let array1 = ["ggg" ,"ll"]    //[String]
let addArray = array + array1   //错误的

字典

Swift字典类型是Dictionary，也是一个泛型集合

定义字典

//1.1 定义不可变字典：使用let修饰
//系统会自动判断[]中存放的是键值对（字典）还是一个一个的元素（数组）
let dict = ["name" : "zh","age" : 18,"height" : 1.88]

//1.2 定义可变字典：使用var修饰
//var dictM = [String : NSObject]()
//AnyObject一般用来指定类型 NSObject一般用来创建对象
var dictM = [String : AnyObject]()

对可变字典的基本操作（增删改查）

//2.1 添加键值对
dictM["name"] = "llny"
dictM["age"]  = 17
dictM["height"] = 1.99
dictM["weight"] = 70
dictM

//2.2 删除键值对
//删除所有的键值对，清空字典
//dictM.removeAll()
dictM.removeValueForKey("weight")

//2.3 修改字典中某一个key对应的value
//区别：如果字典中存在指定的key就修改对应的value，如果不存在指定的key就添加一对键值对
dictM["name"] = "lf"
dictM

//2.4 查找某一个key对应的value  
dictM["age"]

字典的遍历

//3.1 遍历字典中的所有key
for key in dictM.keys{
    print(key)
}
//3.2 遍历字典中的所有value
  for value in dictM.values{
    print(value)
}
//3.3 遍历所有的键值对
  for (key ,value) in dictM{
    print(key)
    print(value)
}

字典的合并

//即使两个字典的类型完全一致，也不能直接相加合并
var dict1 = ["name" : "jj" , "age" : 44]
let dict2 = ["height" : 1.88 , "phoneNum" : "+86 120"]

//let result = dict1 + dict2 //错误写法
for (key , value) in dict2{
    dict1[key] = value
}
dict1

元祖

元祖是Swift中特有的，OC中并没有相关类型
他是什么呢？
他是一种数据结构
类似于数组或者字典
可以用于定义一组数据
组成元祖类型的数据可以成为“元素”

//1.使用数组定义一组数据
let array = ["zh" , 18 , 1.88]
array[0]
array[1]

//2.使用字典定义一组数据
let dict = ["name" : "zh", "age" : 18, "height" : 1.88]
dict["name"]        //"zh"
dict["age"]          //18

//3.使用元祖（一般用于作为方法的返回值）
//3.1 元祖的基本使用
let info = ("zh", 18, 1.88)
info.0        //"zh"
info.1          //18

//3.2 可以给元祖的每一个元素起一个别名（使用最多）
let info1 = (name : "zh", age : 18, height : 1.88)
info1.name        //"zh"
info1.age          //18
info1.height        //1.88

//3.3 元祖中元素的别名，就是元祖的名称
let (name, age, height) = ("zh", 18, 1.88)
name        //"zh"
age          //18
height    //1.88

可选类型

在OC开发中，如果一个变量暂时不用，可以赋值为0（基本数据类型）或者赋值为空（对象类型）
在Swift开发中，nil也是一个特殊的类型，因为和真实的类型不匹配是不能赋值的（Swift是强类型语言）
但是开发中赋值nil,在所难免，因此退出了可选类型

定义可选类型

//var name : String = nil //nil也是一种数据类型，把nil类型赋值给String类型是不可以的
//1.1 方式一:常规方式（不常用）
//var name : Optional<String> = nil   //nil
//1.2 方式二：语法糖（常用）
var name : String? = nil     //nil

给可选类型赋值

name = "zh"    //"zh"

取出可选类型的值

print(name)     //"Optional("zh")\n"
// 可选类型 + ！：强制解包
//print(name!)    //"zh\n"

//注意：强制解包是一个危险操作，如果可选类型的值为nil,强制解包会导致系统崩溃
//建议：在强制解包前对可选类型判断是否为nil
if name != nil{
    print(name!)
}

//4.可选绑定
//可选绑定做了两件事情：
//1.判断name是否有值，如果没有值，直接不执行{}
//2.如果name有值，系统自动将name解包，并把解包后的值赋值给tempName
//写法一：不常用
if let tempName = name{
    print(tempName)    //"zh\n"
}

//写法二：常用
if let name = name{
    print(name)       //"zh\n"
}

例子：

//可选类型的应用场景
//根据一个String创建一个url
//没有指定类型
//let url = NSURL(string: "http://www.baidu.com")
//指定类型
let url : NSURL? = NSURL(string: "http://www.baidu.com")

//根据url创建一个nsurlrequest
//let request = NSURLRequest(URL: url)) // 直接把url传过来是报错的，因为url是一个NSURL的可选类型（NSURL？）这里需要传一个（NSURL）

//强制解包
if url != nil{
    let request = NSURLRequest(URL: url!)
}

//可选绑定
if let url = url{
    let request = NSURLRequest(URL: url)
}

函数

函数的格式如下：
func 函数名（参数列表） -> 返回值类型{
代码块
return 返回值
}
func是关键字，多个参数列表之间用逗号，分割，也可以没有参数
使用箭头“->”指向返回值类型
如果函数没有返回值，返回值为Viod，并且“->”返回值类型部分可以省略

//1.没有参数没有返回值的函数
func about() -> Void{
    print("iPhone 100")
}
func about1(){
    print("iPhone 100")
}
about()

//2.没有参数有返回值的函数
func readMessage() -> String{
    return "where are you?"
}
readMessage()

//3.有参数没有返回值的函数
func callPhone(num : String){
    print("call \(num)")
}
callPhone("86+10086")

//4.有参数有返回值的函数
func sum(num1 : Int, num2 : Int) -> Int{
    return num1 + num2
}
//这种函数调用的时候看上去有点怪
//如果是这样sum(num1 : 10, num2: 20)舒服一些
sum(10, num2: 20)

函数的使用注意：

//两个数相加
func sum(num1 : Int, num2 : Int) -> Int{
    return num1 + num2
}
sum(10, num2: 20)

注意一：内部参数和外部参数

//内部参数：在函数内部可以看到的参数就是内部参数，默认情况下所有的参数都是内部参数
//外部参数：在函数外部可以看见的参数就是外部参数，默认情况下从第二个参数开始既是内部参数也是外部参数
//如果希望第一个参数也是外部参数，可以在标识符前给该参数添加一个别名

func sum(num1 num1 : Int, num2 : Int) -> Int{
    return num1 + num2
}
sum(num1: 30, num2: 11)

注意二：Swift中的默认参数

//你想要一杯什么咖啡，传给这个函数，就会返回一杯咖啡给你
//你要传参数我就用，你要不传就给你一个默认的值
func makeCoffee(coffeeName : String = "雀巢") -> String{
    return ("制作了一杯\(coffeeName)咖啡")
}
//要了一杯拿铁
makeCoffee("拿铁")     //"制作了一杯拿铁咖啡"
//要了一杯卡布奇诺
makeCoffee("卡布奇诺")    //"制作了一杯拿铁咖啡"
//随便？？？
makeCoffee()        //"制作了一杯雀巢咖啡"

注意三：可变参数

//参数的个数不确定：例如2个数相加、3个数相加、4个数相加、5个、6个、7、8...具体几个数字相加根据你传的个数
func sum(num : Int...) -> Int{
    var result = 0
    for n in num{
        result += n
    }
    return result
}

//sum(<#T##num: Int...##Int#>)
sum(1, 2, 3)
sum(1, 2, 3, 4, 5)

注意四：指针类型

var m = 10
var n = 40
//想要交换2个变量的值
//值传递，并不能交换
func swapNum(var m : Int,var n :Int){
    let temp = m
    m = n
    n = temp
}
swapNum(m, n: n)
print(m)                   //10

//指针传递，交换2个变量的值
func swapNum(inout m : Int,inout n :Int){
    let temp = m
    m = n
    n = temp
}

swapNum(&m, n: &n)
print(m)          //40

注意五：函数的嵌套使用

func text(){
    func demo(){
        print("demo")
    }
    demo()
    print("text")
}

text()

待续

初窥Swift：从0到1

导入框架

语句结束

打印内容

定义标识符

类型推导

基本运算

逻辑分支

if、if - else、else if

三目运算

guard的使用

switch的使用

循环结构

for循环

while / do while

字符串

数组

字典

元祖

可选类型

函数

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

首页投稿（暂停使用，暂停投稿）

iOS Developer