标签:
前言:
1.swift2.2 语法(下)正在整理中,预计5.17号完成。
2.此文中的语法会根据swift的升级变动而更新。
导入框架
OC:
#import <UIKit>
#import "AFNetWorking.h"
Swift:
import UIKit
定义标识符
OC:
int i = 0;
Swift:
// 不可变标识符
let i = 0 或 let i : Int = 0
// 可变标识符
var i = 0 或 var i : Int = 0
“;”号的使用
import UIKit
// 定义一个常量
let a : Int = 0 // 或 let a = 0
// 因为常量不可修改,所以 a = 1 的是错误的写法
// 定义一个变量
var b : Int = 0 // 或 var b = 0
// 因为变量可以修改,所以来修改下变量
b = 1
常量使用注意
// 创建一个常量指向UIView并修改内部属性
let view : UIView = UIView()
// 设置尺寸
view.frame = CGRectMake(0, 0, 150, 150)
// 设置背景颜色
= UIColor.greenColor()
// 定义一个常量保存尺寸信息
let rect = CGRectMake(0, 0, 150, 150)
// 定义一个变量指向UIView并切换到UIButton
var tempView : UIView = UIView(frame: rect)
// 设置背景颜色
tempView.backgroundColor = UIColor.redColor()
// 切换变量指向的View
tempView = UIButton(type: .Custom)
// 定义一个Int类型的常量
let a : Int = 15
// 因为有类型推导的特性,所以上面的语句可以简写为
let a = 15 // 编译器会自动根据右边值得类型判定数据类型
// 定义一个浮点类型的常量
let b : Double = 3.14
// 因为有类型推导的特性,所以上面的语句可以简写为
let b = 3.14 // 因为右边是浮点型数据,所以编译器会判定常量类型为浮点型
// 相同类型运算
let a = 15
let b = 20
// 求和
let sum = a + b
// 不同类型运算
let a = 30.0
let b = 15
// 转换类型
let tempA = Int(a)
// 求和
let sum = tempA + b
介绍
if判断
在Swift中,判断语句必须有明确的真假
let a = 15
if a > 11{
print(a)
}
// 因为Swift中,只有声明成可选类型,才能判断是否为空
let view : UIView? = UIView()
if view != nil {
view!.backgroundColor = UIColor.blueColor()
}
三目运算符(和OC一样,没有别的区别)
let a = 15
let b = 20
var result = a > b ? a : b
print(result)
/* 假设成绩为100分,60以下为不及格 */
// 定义一个常量
let a = 99
// 定义一个test函数,参数Int类型
func test(a : Int) {
guard a >= 60 else {
print("不及格")
return
}
print("优秀")
}
// 调用函数
test(a)
switch判断
let a = 0
switch a {
case 0 :
print("真")
case 1 :
print("假")
default :
print("其它")
}
let a = 0
switch a {
case 0, 1 :
print("真假")
default :
print("其它")
}
let a = 0
switch a {
case 0 :
fallthrough
case 1 :
print("假")
default :
print("其它")
}
switch支持区间判断
/* 假设成绩为100分 */
let a = 88
switch a {
case 0..<60:
print("不及格")
case 60..<80:
print("几个")
case 80..<90:
print("良好")
case 90..<100:
print("优秀")
default:
print("满分")
}
循环是开发中必不可少的,常见循环有:for/while/do…while
// 传统写法
for var i = 0; i < 15; i++ {
print(i)
}
// 区间循环
for i in 0..<15 {
print(i)
}
for i in 0...15 {
print(i)
}
// 特殊写法
// 有时候我们只需要循环语句内的操作,不需要i,那么i可以用_代替
for _ in 0..<15 {
print("hello world")
}
var a = 0
while a < 10 {
a++
}
let a = 0
repeat {
print(a)
a++
} while a < 20
定义
let str = "hello world"
var str = "hello world"
使用
let count = str.characters.count
var str = "hello world"
for tmp in str.characters {
}
let str1 = "hello"
let str2 = "world"
let str = str1 + str2
let str1 = "xiao ming"
let str2 = 23
let str = "\(str1)今年\(str2)岁"
字符串的格式化
let min = 3
let time = String(format:"%02d", arguments:[min])
字符串截取方式
let myStr = "hello world"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))
// 定义一个String类型的常量str
let str : String = "http://blog.csdn.net/yeshaojian"
// 截取开始位置
let startIndex = str.startIndex.advancedBy(7)
let head = str.substringFromIndex(startIndex)
// 截取结束位置
let endIndex = str.endIndex.advancedBy(-11)
let foot = str.substringToIndex(endIndex)
// 截取中间网址
let range = Range(start: startIndex, end: endIndex)
let middle = str.substringWithRange(range)
介绍
有序的由相同类型元素
构成的集合有序
的,可以重复
出现泛型集合
,类型
是Array,初始化数组
数组分为可变数组和不可变数组
let
修饰的数组是不可变数组var
修饰的数组是可变数组 // 在swift中任意类型一般不用NSObject而会使用AnyObject
// 定义一个不可变数组(存储内容为AnyObject)
let array : [AnyObject] = ["123", 15, ["se"]]
// 定义一个可变数组,并初始化值
var arrayM : [String] = [String]()
注意:在swift中任意类型一般不用NSObject而会使用AnyObject
声明数组的简便写法
// 声明可变数组
var arrayM2 : Array<String>
// 或
var arrayM3 : [String]
// 声明不可变数组
let array1 : Array<AnyObject>
let array2 : [AnyObject]
注意:声明的数组需要初始化才能使用,数组类型一般都是在声明的同时进行初始化
// 初始化值
arrayM2 = ["1", "2", "3"]
// 初识化后可追加值
arrayM2.append("隔壁老王")
// 因为上面我们声明的array1是let(常量),所以初始化后不能追加元素(不能使用append追加元素)
array1 = ["se", 234]
// 定义一个可变数组
var arrayM : [AnyObject] = ["123", 15, 25, 35]
// 添加数据
arrayM.append("隔壁老王")
// 取值
arrayM[4]
// 修改元素
arrayM[0] = "12"
// 删除数组最前面的元素(这边填 2 就表示删除2次,所以执行完毕后 隔壁老李 和 "123" 会被删除)
arrayM.removeFirst(2)
// 删除数组最后面的元素
arrayM.removeLast()
// 删除指定下标的元素(0 表示删除第一个元素)
arrayM.removeAtIndex(0)
// 删除所有元素
arrayM.removeAll()
// 定义一个可变数组
var arrayM : [AnyObject] = ["123", 15, 25, 35, "隔壁老王"]
// 方式一:遍历数组下标
for i in 0..<arrayM.count {
print(i)
}
// 方式二:遍历数组内容
for name in arrayM {
print(name)
}
// 方式三:设置数组遍历区间
for name in arrayM[0..<3] {
print(name)
}
// 方式四(常用)遍历数组同时获取下标
for (i, name) in arrayM.enumerate() {
print("\(i)--\(name)")
}
// 相同类型的数组才能合并
let array1 = ["123", "157", "12345", "234567", "15689123"]
let array2 = ["1568648", "26879435", "1578715645"]
let array3 = array1 + array2
// 一个数组最好不要存放多种类型数据
var arrayM1 = ["mms", 56, "隔壁老王", 37, "15689123"]
var arrayM2 = [12, "哈哈哈哈", "1578715645"]
var arrayM3 = arrayM1 + arrayM2
注意:只有相同类型的数组才能合并
介绍
Dictionary
,和数组一样死个`泛型集合“初始化字典
swift的字典分为可变和不可变字典2种
let
修饰的字典是不可变字典var
修饰的字典是可变字典 // 定义一个不可变字典
let dict = ["name" : "laoWang", "city" : "隔壁", "age" : 35]
// 定义一个
var dictM : [String : AnyObject] = [String : AnyObject]()
注意:在swift中任意类型一般不用NSObject而会使用AnyObject
// 声明不可变字典
let dict1 : [Int : AnyObject]
let dict2 : Dictionary<Int, AnyObject>
// 声明可变字典
var dictM1 : [Int : AnyObject]
var dictM2 : Dictionary<Int, AnyObject>
注意:和数组一样,声明的字典也需要初始化值后才可使用
// 初始化不可变字典值
dict1 = [0 : "aa", 1 : "bb", 2 : "cc"]
dict2 = ["name" : "laoWang", "age" : 35]
// 初始化可变字典值
dictM1 = ["name" : "laoWang", "age" : 35]
dictM2 = [0 : "aa", 1 : "bb", 2 : "cc"]
// 添加Key为city value为gebi
dictM1["city"] = "gebi"
// 修改
dictM1["name"] = "laoLi"
// 查询
dictM1["name"]
// 删除
dictM1.removeValueForKey("city")
// 删除所有元素
dictM1.removeAll()
// 方式一:遍历字典内所有值
for value in dictM1.values {
print(value)
}
// 方式二:遍历字典中所有的键
for key in dictM1.keys {
print(key)
}
// 方式三:遍历字典中键和值
for (key, value) in dictM1 {
print("\(key) : \(value)")
}
// 字典合并
// 只有字典内容类型相同的字典才可合并
// 定义一个不可变字典(key:String类型 value:AnyObject类型)
let dict1 : [String : AnyObject] = ["name" : "laoWang", "age" : 35]
// 定义一个可变字典(key:String类型 value:AnyObject类型)
var dictM2 : Dictionary<String, AnyObject> = ["city" : "gebi"]
// 遍历dict1的key和value并合并(添加)到dictM2字典中
for (key, value) in dict1 {
dictM2[key] = value
}
print(dictM2)
注意:只有字典内容类型相同的字典才可合并
元组是Swift中特有的,OC中并没有相关类型
定义元组
// 方法一:基本写法(格式:(元素,元素) 数据类型不限)
let personInfo1 = ("老王", 35, 1.80, "laoWang")
// 方法二:在上面方法的基础给元素定义名称
let personInfo2 = (name:"老王", age:35, height:1.80, EnglishName:"laoWang")
// 方法三:先定义元素名,在设置值
let (name, age, height, EnglishName) = ("老王", 35, 1.80, "laoWang")
// 方法四:明确有几个元素并且确定类型
var personInfo3 : (Int, String) = (0, "老王")
元组操作
// 通过下标或者别名读取值
personInfo1.0
personInfo2.name
name
可选类型作用:
可选类型定义
// 基本写法
let user : Optional<String> = nil
// 糖语法
let user : String? = nil
可选类型简单使用
// 可选类型使用
var user : String? = nil
// 给可选类型赋值(我们上面定义的可选类型为String类型,所以只能给他赋值String类型)
user = "laoWang"
// 可选类型取值(在可选类型内,只能通过强制解包来取出可选类型的真实类型)
// 强制解包方式一:
user!
// 需要注意的是,如果可选类型为nil(为空),强制取出其中的值(强制解包),会出错
// 强制解包方式二:
if user != nil {
print (user!)
}
// 为了在if语句里面方便使用user,我们可以定义一个可选绑定类型,这样也能达到严谨取值的效果(底层也是帮我们进行判断,有值就会解包)
if let userStr = user {
print (userStr)
}
注意:
1.如果可选类型为nil(为空),强制取出其中的值(强制解包),会出错,所以解包前需要进行判断
2.为了使用方便,解包会以可选绑定
的形式实现
// OC中,我们在定义一个包含中文的NSURL的时候是这样的
NSString *urlStr = @"http://www.xxxxx.com/中文/sie";
// 因为字符串中包含中文,所以需要对字符串进行UTF8编码转换,防止出现访问错误
NSString *str = [urlStr stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
// 再将其包装成NSURL
NSURL *url = [NSURL URLWithString:str];
// 在swift中,如果字符串中包含中文,且我们没有对其进行处理,那么就会直接返回nil
// 也就是说,url可能有值也可能没值,这时候就需要用可选类型来接收
// 方法一:标准写法
let url : NSURL? = NSURL(string: "http://www.xxxxx.com/中文/sie")
// 方法二:利用类型推导
let url2 = NSURL(string: "http://www.xxxxx.com/中文/sie")
// 方法三:可选绑定
if let temp = url {
let request = NSURLRequest(URL: temp)
print (request)
}
类型转化符号
// 定义一个数组
let array : [AnyObject] = ["laoWang", 15, 18.9]
// 取出数组中的第二个元素
let temp = array[1]
// 判断第一个元素类型是否为字符串
if temp is String {
print("true")
} else {
print("flase")
}
// 将objc转成真实类型
// 方式一:使用as?将AnyObject转成可选类型,通过判断可选类型是否有值,来决定是否转换成功
let age = temp as? Int
print(age)
// 方式二:使用as!将AnyObject转成真实类型,因为objc的真实类型为Int不是String,通过as!进行转换后,会直接报错
let age1 = temp as! String
print(age1)
标签:
原文地址:http://blog.csdn.net/yeshaojian/article/details/51418753