//
// main.swift
// Swift-Basic语法
//
// Created by qianfeng on 16/7/8.
// Copyright © 2016年 SharkTop. All rights reserved.
//

import Foundation
//普通打印
print("Hello, World!")
print("任何一门语言的学习开始于("Hello, World!")")
//注释：添加单行语句的注释用//，添加多行语句或者段语句的注释使用/**/
//分号：可写可不写，一般情况下不加分号，当同一行有多条语句的时候添加分号
//标记：在OC中，标记使用#pragma mark - XXX，在Swift中，标记使用的是//MARK：-xxxx
//在Swift中，工程没有主函数，类似于脚本语言，但实质上，是一种动态编译型语言，代码的执行顺序是从上往下依次执行
//1.声明变量，使用var关键字
var a = 10
a = 20
print(a)

//2.声明常量。使用let关键字
let b = 20
//b = 30
print(b)
//3.类型标注
//为了在申明常量或者变量的时候，通过添加类型标注的方式来说明当前常量或者变量所代表的类型

var c: Int = 10
var d: Double = 2.2
//在Swift中，字符和字符串都用双引号
var e: Character = "e"
var f: String = "hello"

//4.常量和变量的命名
/*
1.不能以数字开头
2.不能以数学符号、制表线、连线、箭头命名
3.一旦常量或者变量进行类型标注之后，在后面就不能使用相同的名字进行申明
4.尽量避免使用和系统关键字一样的名字

*/

//var 1a = 10
//可以使用的命名方式
let 狗 = "狗"
let 🐶 = "狗"
var π = 3.14

//5.数据类型的转换
//字符串转换成数字
var a1 = Int("10")
//数字转换成字符串
var b1 = String(10)
print("(a1!)~~~~(b1)")
//6.声明布尔类型
var bool = true//只有true和false
var bool2 :Bool = false

//7.元组变量
//元组是Swift提供的一种新的数据结构，将多个元素组合在一起，在元组中，元素的数据类型可以互不相同
var c1 = (4,"hello") //方式一
print(c1.1)//通过索引的方式访问元组元素

var(key1,key2) = (10,"abc")//方式二
print(key1)//通过映射的方式访问元组元素

let c2 = (name:"小芳",age:18,score:100)//方式三
print("有个姑娘叫(c2.name),今年(c2.age)岁,考试成绩(c2.score)")//通过key值得方式访问元组元素
//8.可选类型
//可选类型也是Swift提供的一种新的类型，分为有值和无值，在Swift中，系统不会自动的帮我们初始化常量或者变量
//？和！，用？设置一个常量或者变量为可选类型，如果可选类型已经被初始化，变量或者常量的值则为这个初始值，如果可选类型没有被初始化的话，变量则为nil，，这个过程叫做封包
//！：在变量或者常量后面添加！表示将可选类型转化为一般类型，这个过程叫做解包或者拆包

//可选类型就是为了处理值缺失的情况
var d1: Int? = 10
print(d1!)
var d2: String? = "hello"
print(d2!)
//9.if语句
if d1 == nil{
print("没有值")
}else{
print("有值")
}
//10.可选绑定
//使用可选绑定来判断可选类型是否包含值，如果有值则将值赋给另外一个常量或者变量
if let x = d1{
print(x)
}
//11.使用断言
//用代码的形式达到断点的作用
//使用assert来添加断言，如果函数里面表达式为真，则没影响，如果表达式为假，则程序会崩溃到这个地方，作用就是进行辅助调试程序
let e1 = 10
assert(e1 < 100)
/*
断言使用的场景：
1.整数类型的下标索引太大或者太小的时候
2.需要给函数传入的值是非法的会导致函数不能正常工作
3.一个可选值为nil，但后面要用到一个非nil的值
*/

//错误处理
//抛出异常（throws）---->捕捉异常 （添加关键字try try？ try！）

//12.运算符
/*
一元：!a,i ++
二元：a + b,a % b
三元：条件运算符 a?b:c主要用于二选一的操作
*/
//赋值运算符
let a3 = 10
let b3 = 20
//算数运算符
print(a3 + b3)

print(a3 - b3)

print(a3 * b3)

print(a3 / b3)
//求余运算符
//在Swift中，可以使用浮点型进行求余运算
print(3.1 % 2.2)
var i = 10
print(i++)
print(++i)

//复合赋值运算符
var c3 = 3
c3 += 1 //c3 = c3 + 1
print(c3)

//比较运算符
//返回值是布尔值
print(a3 >= b3)
print(a3 == b3)
print(a3 <= b3)

//三目运算符
var apple = 2
var banana = true
var total = banana ? 5 : 2
print(total)

//空合运算符
//形式:a ?? b,表示对可选类型a进行空判断，如果a有值则对a进行解封并返回a的值，如果a无值则返回默认值b，空合运算符是三目运算符的升级版，以更优雅的方式诠释了封装和解封这两种行为
var choiceColor: String? = "red"
var defaultColor = "blue"
var useColor = choiceColor ?? defaultColor
print(useColor)

//逻辑运算符
//与
let answer1 = true
let answer2 = false
print(answer1 && answer2)//一假为假，全真为真

//或
print(answer1 || answer2)//一真为真，全假为假

//非
print(!answer2)

//区间运算符
//1...5表示1，2，3，4，5
for i in 1..<5{
print("第(i)次 say world")
}

//13.字符串
//字符串的初始化
var str1: String = ""//方式一
var str2: String = String()//方式二

//判断字符串是否为空
print(str1.isEmpty)

print(str2.isEmpty)

//判断字符串是否相等
if str1 == str2 {
print("相等")
}

//进行字符串的拼接
var str3 = "hello"
var str4 = "everybody"
var str5 = str3 + str4
print(str5)

//进行字符串的遍历
for c in str5.characters {
print(c)
}

//在字符串中插入字符
str3.insert("a", atIndex: str3.startIndex)//在整个最前面插入字符
str3.insert("b", atIndex: str3.endIndex)//在最后面插入字符
str3.insert("c", atIndex: str3.endIndex.advancedBy(-2))//在字符串末尾向前数第几位插入字符
str3.insert("d", atIndex: str3.startIndex.successor())//在正向第二位插入字符
str3.insert("f", atIndex: str3.endIndex.predecessor())//在倒数第二位插入字符
print(str3)
//获取字符串中字符的个数
print(str3.characters.count)

//通过字符串中的索引获取对应的字符
for i in str3.characters.indices{
// 通过索引获取字符
print(str3[i])
}
//删除字符串中的字符
str3.removeAtIndex(str3.startIndex)
str3.removeAtIndex(str3.endIndex.predecessor())
print(str3)

//删除指定范围的字符串
var range = str3.endIndex.advancedBy(-3)..<str3.endIndex.advancedBy(-2)
str3.removeRange(range)
print(str3)

//字符串的比较
var str6 = "abc"
var str7 = "bcd"
if str6 <= str7{
print("相同")
}else{
print("不相同")
}

//判断前缀和后缀
var str8 = "hello world"
//判断前缀
print(str8.hasPrefix("h"))

//判断后缀
print(str8.hasSuffix("!"))
//14.数组
//创建空数组
var arr1 = Int//方式一
var arr2 = Array<Int>()//方式二

//判断数组是否为空
print(arr1.isEmpty)

//创建带有默认值的数组
//count:数组元素个数，repeatedValue：默认的元素值
var arr3 = [Int](count: 10, repeatedValue: 5)
var arr4 = Array<Int>(count: 20, repeatedValue: 10)
//两个数组合并，两个数组里面的数据类型必须一致，相加后两个数组合并为一个数组
var arr5 = arr3 + arr4
print(arr5)
//方式三:用字面量的方式创建数组
var arr6 = [1,2,3,4]

//访问数组
print(arr6[3])

//修改数组元素
arr6[0] = 10
print(arr6)

//15.集合
//创建集合
var set1 = Set<Int>()//空集合 方式一
//向集合中存放数据,集合和数组的区别：数组元素是有序的，集合的元素是无序的
set1.insert(10)
set1.insert(20)
set1.insert(30)
set1.insert(40)
set1.insert(50)
print(set1)

//删除集合中的某个元素
set1.remove(20)
print(set1)

//遍历集合
for i in set1.sort(){
print(i)
}

//方式二：用字面量的方式创建集合
var set2: Set<Int> = [10,11,12,13]
var set3: Set<String> = ["a","b","c","d"]

//集合的运算
var set4: Set<Int> = [1,2,3,4,5]
var set5: Set<Int> = [3,5,6,7,8]
//获取两个集合的交集
var set45 = set4.intersect(set5)
print(set45)
//合并两个集合，并且相同的元素只保留一份，即只保留一份交集
var set54 = set4.union(set5)
print(set54)

//获取除了交集之外的set4的值
var set6 = set4.subtract(set5)
print(set6)

//获取除了交集之外的set4和set5的值
var set7 = set4.exclusiveOr(set5)
print(set7)

//判断两个集合是否相等
if set6 == set7 {
print("相同")
}else{
print("不相同")
}

//判断集合之间的关系
//判断一个集合是否是另外一个集合的子集
var set8: Set<Int> = [1,2]
print(set8.isSubsetOf(set4))

//判断一个集合是否包含另一个集合
print(set4.isSupersetOf(set8))

//判断一个集合是否是另外一个集合的子集并且两个集合不相等
print(set4.isStrictSubsetOf(set8))

//判断一个集合是否包含另外一个集合并且两个集合不相等
print(set4.isStrictSupersetOf(set8))

//16.字典
//创建空字典
var dic1 = Int: String//方式一
//通过字面量的方式创建字典
var dic2 = [1:"a",2:"b",3:"c"]//方式二

//访问字典中的元素
print(dic2[2]!)
//修改字典中的元素
dic2[3] = "f"
print(dic2)

//字典的遍历
//方式一
for(key,value) in dic2 {
print("(key)对应着(value)")
}
//方式二：字典的有序遍历
for key in dic2.keys.sort(){
// 获取到key对应的value
var value = dic2[key]
print("(key)对应着(value!)")
}