图片来自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()
待续
网友评论