1.元组

1.1什么是元组

在其他语言中很早就有元组这个概念, 但是对于OC程序员来说这是一个新的概念
官方定义:元组(tuples)把多个值组合成一个复合值.
元组内的值可以是任意类型, 并不需要是相同的类型.
自定义(我定义):将多个相同对或者不同类型的值用一个小括号起来就是一个元组.

1.2定义元组(代码):

let student = ("jianshu", 30, 22.2)
print(student)
print(student.0)
print(student.1)
print(student.2)

其实元组定义其实和结构体很像, 只是不需要提前定义类型.
元组其实是复合类型, 小括号中可以写任何类型
也可以指定数据类型
如果指定饿了数据类型, 那么对应的必须是其他定的数据类型, 否则会报错.

let student: (String, Int, Double) = ("jianshu", 30, 22.2)

1.3定义元组其他方式

指定元组元素的名称

let student = (name:"jianshu", age = 30, score: 43)
print(student.name)
print(student.age)
print(student.score)

通过指定的名称提取元组对应的值, 会将对应的值赋值给对应位置的名称

let (name, age, score) = ("jianshu", 30, 43)
print(name)
print(age)
print(score)

如果不关心元组中的某一个值可以利用_通配符来忽略提取

let student = ("jianshu", 30, 43)
let (name, age, _) = student
print(name)
print(age)

1.4外话

在以前没有元组之前C和OC是通过传入指针或者返回结构体的方式来返回多个值的, 而有了元组之后就可以实现让一个函数返回多个值

2 Swift可选值

**使用可选类型(optionals)来处理值可能缺失的情况. **
C和Objective-C中没有可选类型这个概念
最接近的是OC中的一个特性,
一个方法要么返回一个对象, 要么返回nil, nil表示"缺少一个合法的对象"
可选值:optionals有两种状态

1.有值
2.没有值

?表示两种状态, 一种是有值(有具体的某个值), 一种是没有值(没有代表nil), 当?修饰时,表示这个变量可能为nil

// 有值
var optValue: Int? = 9
// 没有值
var optValue: Int?
var optValue: Int? = nil

2.1可选值可以利用if语句来进行判断

var optValue: Int? = 10
if optValue != nil
{
    print("有值:\(optValue)")
}else
{
    print("没有值:\(optValue)")
}

输出结果: 有值: Optionals(10)

var optValue: Int?
var optValue: Int? = nil
if optValue != nil
{
    print("有值:\(optValue)")
}else
{
    print("没有值:\(optValue)")
}

输出结果:没有值:nil

var optValue: Int? = nil
if optValue != nil
{
    print("有值:\(optValue)")
}else
{
    print("没有值:\(optValue)")
}

输出结果:没有值:nil

2.2提取可选类型的值(使用!强制解析)

将optValue中的整型值强制拿出来赋值给变量result, 换句话说就是告诉编译器optValue一定有值
因为可选类型有两种状态有值和没有值, 所以需要告诉编译器到底有没有值
需要注意的是如果强制解析optValue
但是optValue中没有值时会引发一个运行时错误

var optValue: Int? = 9
var result: Int = optValue!
print(result)

输出结果:9

var optValue: Int?
var result: Int = optValue!
print(result)

结果为报错:
fatal error:
unexpectedly found nil while unwrapping an Optional value

2.3可选绑定

为了更安全的解析可选类型的值, 一般情况下使用可选绑定
如果optValue没有值就不会做任何操作
如果optValue有值会返回true并将optValue的值赋值给result执行大括号中的内容

var optValue: Int? = 9
if let result = optValue
{
    print(result)
}

2.4!与?详解

解释一:

Optional其实是个enum，里面有None和Some两种类型。其实所谓的nil就是Optional.None, 非nil就是Optional.Some, 然后会通过Some(T)包装（wrap）原始值，这也是为什么在使用Optional的时候要拆包（从enum里取出来原始值）的原因, 也是PlayGround会把Optional值显示为类似{Some "hello world"}的原因，这里是enum Optional的定义：

enum Optional<T> : LogicValue, Reflectable {
case None
case Some(T)
init()
init(_ some: T)

/// Allow use in a Boolean context.
func getLogicValue() -> Bool

/// Haskell's fmap, which was mis-named
func map<U>(f: (T) -> U) -> U?
func getMirror() -> Mirror

}
声明为Optional只需要在类型后面紧跟一个?即可。如:

var strValue: String?   //?相当于下面这种写法的语法糖
var strValue: Optional<String>

上面这个Optional的声明，意思不是”我声明了一个Optional的String值”, 而是”我声明了一个Optional类型值，它可能包含一个String值，也可能什么都不包含”，也就是说实际上我们声明的是Optional类型，而不是声明了一个String类型，这一点需要铭记在心。
建议再读一遍上段文字。
一旦声明为Optional的，如果不显式的赋值就会有个默认值nil。判断一个Optional的值是否有值，可以用if来判断：

if strValue {
    //do sth with strValue
}

然后怎么使用Optional值呢？文档中也有提到说，在使用Optional值的时候需要在具体的操作，比如调用方法、属性、下标索引等前面需要加上一个?，如果是nil值，也就是Optional.None，会跳过后面的操作不执行，如果有值，就是Optional.Some，可能就会拆包(unwrap)，然后对拆包后的值执行后面的操作，来保证执行这个操作的安全性，比如：

let hashValue = strValue?.hashValue

strValue是Optional的字符串，如果strValue是nil，则hashValue也为nil，如果strValue不为nil，hashValue就是strValue字符串的哈希值(其实也是用Optional wrap后的值)

另外，?还可以用在安全地调用protocol类型方法上，比如：

@objc protocol Downloadable {
@optional func download(toPath: String) -> Bool;
}

@objc class Content: Downloadable {
    //download method not be implemented
}

var delegate: Downloadable = Downloadable()
delegate.download?("some path")

因为上面的delegate是Downloadable类型的，它的download方法是optional，所以它的具体实现有没有download方法是不确定的。Swift提供了一种在参数括号前加上一个?的方式来安全地调用protocol的optional方法。

另外如果你需要像下面这样向下转型(Downcast)，可能会用到 as?：

 if let dataSource = object as?         UITableViewDataSource {
let rowsInFirstSection  = dataSource.tableView(tableView, numberOfRowsInSection: 0)
}

到这里我们看到了?的几种使用场景:
1.声明Optional值变量
2.用在对Optional值操作中，用来判断是否能响应后面的操作
3.用于安全调用protocol的optional方法
4.使用 as? 向下转型(Downcast)
另外，对于Optional值，不能直接进行操作，否则会报错：

//error: 'String?' does not have a member named   'hashValue'
//let hashValue = strValue.hashValue
//                ^        ~~~~~~~~~

let hashValue = strValue.hashValue

上面提到Optional值需要拆包(unwrap)后才能得到原来值，然后才能对其操作，那怎么来拆包呢？拆包提到了几种方法，一种是Optional Binding， 比如：

if let str = strValue {
    let hashValue = str.hashValue
}

还有一种是在具体的操作前添加!符号，好吧，这又是什么诡异的语法?!

直接上例子，strValue是Optional的String：

let hashValue = strValue!.hashValue

这里的!表示“我确定这里的的strValue一定是非nil的，尽情调用吧” ，比如这种情况:

if strValue {
    let hashValue = strValue!.hashValue
}

{}里的strValue一定是非nil的，所以就能直接加上!，强制拆包(unwrap)并执行后面的操作。 当然如果不加判断，strValue不小心为nil的话，就会出错，crash掉。

考虑下这一种情况，我们有一个自定义的MyViewController类，类中有一个属性是myLabel，myLabel是在viewDidLoad中进行初始化。因为是在viewDidLoad中初始化，所以不能直接声明为普通值：var myLabel : UILabel，因为非Optional的变量必须在声明时或者构造器中进行初始化，但我们是想在viewDidLoad中初始化，所以就只能声明为Optional：var myLabel: UILabel?, 虽然我们确定在viewDidLoad中会初始化，并且在ViewController的生命周期内不会置为nil，但是在对myLabel操作时，每次依然要加上!来强制拆包(在读取值的时候，也可以用?，谢谢iPresent在回复中提醒)，比如:

myLabel!.text = "text"
myLabel!.frame = CGRectMake(0, 0, 10, 10)
...

对于这种类型的值，我们可以直接这么声明：var myLabel: UILabel!, 果然是高(hao)大(gui)上(yi)的语法!, 这种是特殊的Optional，称为Implicitly Unwrapped Optionals, 直译就是隐式拆包的Optional，就等于说你每次对这种类型的值操作时，都会自动在操作前补上一个!进行拆包，然后在执行后面的操作，当然如果该值是nil，也一样会报错crash掉。

var myLabel: UILabel! //!相当于下面这种写法的语法糖
var myLabel: ImplicitlyUnwrappedOptional<UILabel>
那么!大概也有两种使用场景

1.强制对Optional值进行拆包(unwrap)
2.声明Implicitly Unwrapped Optionals值，一般用于类中的属性

解释二:
从IB中拖线的控件对应的变量：

// 系统自带
@IBOutlet weak var display: UILabel!

// 如果这样
@IBOutlet weak var display: UILabel?

?表示display是一个可选类型（optionals），!表示对可选类型进行强制解包，如果解包的变量是nil，程序就会崩溃.
系统自带的相当于在xib解档赋值的时候，进行了强制解包；而后面修改后，赋值时没有进行强制解包，所以后面使用display时，需要这样使用以获取其属性－－

 display!.text

以上的两种解释第一种比较详细, 第二种凡是有做过一些小程序的人, 都能理解,简单易懂

3 swift字符和字符串

3.1字符

// OC当中的字符 
char charValue = 'a';
// swift当中的字符
var charValue: Character = "a"

Swift和OC字符不一样
1.Swift是用双引号
2.Swift中的字符类型和OC的也不一样
OC中的字符占一个字节, 因为它只包含ASCII表中字符
而Swift中的字符除了可以存储ASCII表中的字符还可以存储Unicode字符,
OC的字符是遵守ASCII标准的. Swift的字符是遵守Unicode标准的
所以可以存放世界上所有国家语言的字符(大部分)

// OC中
char charValue = '高';// 错误
// Swift中
var charValue: Character = "高' // 正确

注意:双引号只能存放一个字符, 如下写法是错误的

var charValue : Character = "ab"

3.2字符串

C:

char *stringV = "ab";
char *stringV2 = "cd";

OC:

NSString *stringV = "ab";

Swift:

var stringV = "ab"
var  stringV:String = "ab"

C语言中的字符串都是以\0结尾的, 例如

char *StringV = "abc\0def";
printf("%s", StringV);

输出结果:abc

OC语言中的字符串也是一\0结尾的 例子就不再举了
Swift中的字符串和C语言/OC语言中的字符串是不一样的

var StringV = "abc\0def"
print(StringV)

输出结果:abcdef
将两个字符串合并在一起:
OC

NSMutableString *str1 = [NSMutableString stringWithString:@"abc"];
NSString *str2 = @"def";
[str1 appendString: str2];
NSLog(@"%@", str1);

输出结果:abcdef

Swift:

var str1 = "jian"
var str2 = "shu"
var str = str1 + str2
print(str)

输出结果: jianshu

3.3字符串比较

OC:

// 方法一:
NSString *str1 = @"abc";
NSString *str2 = @"abc";
if ([str1 compare: Str2] == NSOrderedSame)
{
    NSLog(@"相等");
}else{
    NSLog(@"不相等");
}
// 方法二:
NSString *str1 = @"abc";
NSString *str2 = @"abc";
if([str1 isEqualToString: str2])
{
    NSLog(@"相等")
}else{
    NSLog(@"不相等");
}

输出结果: 相等

Swift:

Swift: (== , != , >= , <= )这些是Swift中字符串的比较符号, 和C语言的strcmp一样的是逐一比较

var str1 = "abc"
var str2 = "abc"
if str1 == str2
{
    print("相等")
}else{
    print("不相等")
}

输出结果: 相等

var str1 = "abc"
var str2 = "adc"
if str1 >= str2
{
    print("大于等于")
}else{
    print("不大于等于")
}

输出结果: 大于等于

3.4大小写转换

OC:

NSString *str = @"abc";
NSLog(@"%@", [str uppercaseString]);
NSLog(@"%@", [str lowercaseString]);

输出结果: ABC
abc

Swift:

var str = "abc"
print(str.uppercaseString)
print(str.lowercaseString)

输出结果: ABC
abc

3.5转换成基本数据类型

OC:

NSString *str = @"250";
NSInteger number = [str integerValue];
NSLog(@"%tu", number);

输出结果: 250

如果str不能转换为整数, 那么可选类型返回nil
str = "250sb" 不能转换所以可能为nil
这句话, 我也不是很理解,望各位读者见谅, 如果有自己的想法, 欢迎评价

var str = "250"
var number: Int? = Int(str)
if number != nil
{
    // Swift以前的版本中的printIn会自动拆包, 现在的不会
    print(number!)
}

作者说

本片文章介绍的知识点并不是多, 主要就是关于!与? 他们的使用, 目前的我, 也没有办法熟练的使用, 只是当报错的时候, 再解决, 抱歉.