Swift基础（一）

一、Swift简介

　　苹果公司于2014年WWDC（苹果开发者大会）发布的新开发语言Swift，可与Objective-C共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，并且Swfit完全开源。

二、声明变量和常量

• 在Swift中使用“let”修饰一个常量，使用“var”修饰一个变量;
• let修饰常量的值是不可以更改的；
• var修饰的变量的值是可以更改的；
• 在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。
• Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断。
• 注：在OC中使用mark和Swift使用mark的方式不同：

// OC中 
#pragma mark -
// Swift中
// MARK: 

• 代码示例：

// Swift中导入系统类库使用 import 类库名 ，不再使用 # 和 <>（或 ""）
import Foundation
// Swift中输出语句：print
print("Hello, World!")
// MARK: - 定义常量、变量
// 定义常量（使用完第一次就不能修改它的值）
let myGender = "男"
// 定义变量
var carName = "BMW"
carName = "Audi"
print(carName)
print(myGender)

// MARK: - 定义常量变量：变量类型的隐式转换

// 在Swift中如果定义常量变量不给定相关的类型，它会隐式转换成你给定的初值类型

let name = "Jack" // 如果这样定义一个常量，它会隐式转换成String类型

let name1 : String = "Rose" // 如果给定类型，后边赋值的时候需要根据类型进行赋值

let age : Int = 18 // 如果定义常量最好给出初始值，定义变量可以不给初始值

　　字符、字符串：

var char : Character = "A" // 赋值字符类型的时候仅需一个字母即可
var flag : Bool = true //Bool值只有true 和 false
print(flag)

// MARK: - 字符串String
// 创建空字符串
var str_emperty = ""
var str1_emperty = String()
// 判断是否为空
if str1_emperty.isEmpty {
    print("str_emperty is emperty")
}
// 拼接
var str_url = "http://"
var str = "www.baidu.com"

let str_new_url = str_url + str

print(str_new_url)
print("这是百度的网址\(str_new_url)") //  \(变量名)输出相关内容

// 获取字符串长度
var str1 : String = "abcdef"
let length = str1.characters.count;
//print(length)

// 字符串的比较
var str2 = "ABC"
var str3 = "DEFG"
if str2 != str3 {
//    print("两个字符串不相等")
}

三、数组，字典

• 在Swift中使用“let”或者“var”声明一个数组或者字典;
• 数组必须指定数据类型，如果没有指定类型则会根据数组的初值去推断数据类型;
• 字典所有的key值必须是同一数据类型;
• 字典所有的value必须是同一数据类型。
• 代码示例：

// MARK: - 数组
// swift中数组的元素类型必须相同
// 定义数组
var nameArray = ["oo", "ABC", "DEF"]
print(nameArray)

var nameArrat1:Array<String> = ["YQ", "HG", "QEW"]

// 定义一个空数组(字符串)
let arrayNew = Array<String>()
print(arrayNew)

// 访问数组中的元素
print(nameArray[1])

// 向数组中添加元素
var int_array = Array<Int>()
int_array.append(520)

int_array.append(123)

print(int_array)

// 使用运算符添加数组元素
int_array += [1]
int_array += [3]
print(int_array)

// 使用运算符添加多个数组元素
int_array += [9, 99, 999]
print(int_array)

// 插入元素具体的位置
int_array .insert(521, atIndex: 1)
print(int_array)
// 移除某个元素
int_array.removeAtIndex(4)
print(int_array)

// 移除所有元素
int_array.removeAll()
print(int_array)

// MARK: - 字典

// 定义一个字典类型的变量
var dict:Dictionary<String,Int> = ["a":18, "b":69, "c":38]
print(dict)
// 定义空字典
var dictionary:Dictionary<String,Int> = [:]
var dictionary1 = Dictionary<String, Int>()
print(dictionary, dictionary1)

// 向字典中添加键值对
dict["d"] = 50
print(dict)

// 修改字典中的键值
dict["c"] = 99;
print(dict["b"])

// 删除字典中的内容
dict.removeValueForKey("c");
print(dict)

四、元组

• 元组是Swift里面独有的一种数据格式。
• 是一个可以返回多个值的数据格式。
• 在Swift里面声明的时候使用“（）”声明。
• 元组可以通过下标去访问元素，也可以通过key值去访问元素;
• 整体的数据结构有点类似于C语言里面的结构体。
• 代码示例：

// MARK: - 元组
// 定义一个元组

// 方法1：直接初始化
var tuple = ("语言", ["iOS", "H5", "Android"])
// 方法2：显示初始化的方式
let tupleNew:(String, Array) = ("语言", ["iOS", "H5", "Android"])

print(tuple, tupleNew)

// 取出元组中的值
// 第一种取值方式:直接把元组赋值给另一个常量，根据相关标记进行取值

let tupleNew1:(language:String, name:Array) = tupleNew
var languageName = tupleNew1.language + tupleNew1.name[0] + tupleNew1.name[1] + tupleNew1.name[2]
print(languageName)

// 第2种取值方式:直接根据下标进行取值
var languageNameNew = tupleNew.0 + tupleNew.1[0]
print(languageNameNew)

五、循环结构和分支结构

• Swift里面的循环结构包含：for、for-in、while、repeat-while。
• Swift里面的分支结构包含：if、if－else。
• 代码示例：

// MARK: - 循环
// 第一种形式:
for var i = 1; i < 10; i++ {
    print(i)
}
// 第二种
for number in 1..<10 {
    print(number)
}

// 第三种形式
for number in 1...10 {
    print(number)
}

// while循环和repeat...while

var i = 8;
while i > 0 {
    i--
    print(i)
}

repeat {  // 先执行一次循环体，在进行相关的循环
  print("我。。。")
} while 1 < 0

// 使用循环遍历数组

var animalArray = ["dog", "pig", "cat", "fish"]

for animal in animalArray {
    print(animal)
}

// 使用循环遍历字典
var animalDic = ["dog":"", "pig":"", "cat":""]
for (key, value) in animalDic {
    print("key = \(key), value = \(value)")
}

// MARK: - 分支结构 (if  switch)

// if 形式的

let flag1 = true;
if flag1 == true {
    print("我是真的")
} else {
    print("假的")
}

// switch形式使用fallthrough实现贯穿每种可能

let value = 0

switch value {
case 0:
    print(0)
    fallthrough
case 10:
    print(10)
    fallthrough
default:
    print("other")
}

// case 可以使用一个范围
switch value {
case 0..<10:
    print("输出0-10之间的数值")
case 10...100:
    print("输出10-100之间的数值")
default:
    print("other")
}

// 特点3: case 可以使用（let和var修饰的常量或者变量） where是满足某种条件
switch value {
case var i where value >= 0 && value <= 6:
    i = 99
    print(i)
default:
    print("aaaa")
}


// 特点4：case后还可以匹配一个元组

let point = (10, 10)
switch point {
case (10, 0):
    print("")
case (_, 10):
    print("_代表可以忽略某个元素")
case (10, 10):
    print("")
default:
    print("....")
}

六、枚举

• C 语言中，枚举类型将枚举名和一个整型值相对应。
• Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个确定的值。
• 如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
• 代码示例：

// MARK: - 枚举（enum）
// 枚举原始类型为int类型的

enum Direction:Int {
    case east = 0
    case south = 1
    case west = 2
    case north = 3
}
print(Direction.east.rawValue) // rawValue就是找到相对应枚举的原始值

// 枚举原始类型为string类型的
enum Season:String {
    case spring = "春天"
    case summer = "夏天"
    case autumn = "秋天"
    case winner = "冬天"
}

print(Season.autumn.rawValue)

// 根据原始值获取枚举的类型
print(Direction(rawValue: 2))

七、函数

• Swift里面用 func 表示声明一个函数。
• Swift的文件格式里面没有类似于OC的.h文件。所以，如果需要定义一个私有的函数，可以在func前面添加private 修饰。
• 代码示例：

// MARK: - 函数
// 表示函数的关键字: func
// 函数的类型有：四种
// 1：无返回值，无参数
func function1() -> Void {
    print("无返回值无参数")
}

function1()

// 2:无返回值，有参数
func function2(name str:String) -> Void {
    print(str)
}

function2(name: "ABC")

// 3：有返回值无参数
func function3() -> String {
    return "DEF"
}

print(function3())

// 4:有返回值有参数

func function4(num1:Int, num2:Int) -> Int {
    return num1 + num2
}

print(function4(6, num2: 9))

// 函数的返回值为元组类型的
func function5(num1:Int, num2:Int) -> (Int, Int, Int) {
    return (num1, num1 + num2, num2)
}

print(function5(1, num2: 2))

// 外部参数和内部参数
// first second 是外部参数  在函数调用的时候会显示这两个名称
// one two 是内部参数：在函数内部使用的
// 默认的情况下，第一个外部参数在调用的时候不显示，其余的都显示
func function6(first one:Int, second two:Int) {
    print((one, two))
}

function6(first: 10, second: 2)


// 如果都不想显示外部参数

func function7(one:Int, _ two:Int) {
    print("忽略外部参数")
}

function7(1, 2)


// 函数的嵌套

func test1() {
    func test2() {
        func text3() {
            print(":-O")
        }
        text3()
    }
    test2()
    print(" v ")
}

test1()

// inout参数:
// 1.参数默认是用let修饰,即常量
// 2.在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.
// 3.如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.

func test(inout name:String) {
    name = "MBBoy"
    print(name)
}

var myName = "yuanyuan"
test(&myName)

print(myName)


func newText(var name:String) {
    name = "MBBoy"
    print("nameOld = \(name)")
}
var Name = "tianxin"
print("name = \(Name)")

newText(Name)

print("name = \(Name)")