Swift 基础02 —— Objective-C转战Swift

字符串的使用

OC中字符串类型是NSString，Swift中字符串的类型是String

OC：@"", Swift：""

• string是一个结构体，性能更高
• NSSting是一个OC对象，性能略差
• String支持直接遍历
• Swift提供了String和NSString之间的无缝转换

// 1.定义字符串
let str = "Hello Swift"
var strM = "Hello Objective-C"

// 2.获取字符串的长度
let lenngth = str.count

// 3.字符串的拼接
let str1 = "你好"
let str2 = "世界"
let str3 = str1 + str2

let name = "GYD"
let age = 18
let height = 1.83
let infoStr = "my name is \(name), age is \(age), height is \(height)."

let min = 3
let second = 4
let timeStr = String(format:"%02d:%02d", min, second)

// 4.字符串的截取
let urlString = "www.baidu.com"
// 1> 将String类型转成NSString类型，再进行截取
let header1 = (urlString as NSString).substring(to : 3)
let range1 = NSMakeRange(4, 5)
let middle1 = (urlString as NSString).substring(with : range1)
let footer1 = (urlString as NSString).substring(form : 10)
// 2> 直接使用String类型，进行截取
let headerIndex = urlString.index(urlString.startIndex,offsetBy: 3)
let header2 = urlString.substring(to: headerIndex)

let startIndex = urlString.index(urlString.startIndex,offsetBy: 4)
let endIndex = urlString.index(urlString.startIndex,offsetBy: 9)
let range = Range(startIndex..<endIndex)
let middle2 = urlString.substring(with: range)

let footerIndex = urlString.index(urlString.endIndex,offsetBy: -3)
let footer2 = urlString.substring(from: footerIndex)

数组

Switf 数组类型是Array，是一个泛型集合

// 1.数组的定义
//   1> 定义不可变数组：使用let修饰
//let array : [String] = ["aaa", "bbb", "ccc"] 推荐使用
//let array : Array<String> = ["aaa", "bbb", "ccc"] 正确
let array = ["aaa", "bbb", "ccc"]

//   2> 定义可变数组：使用var修饰
// var arrayM = Arrany<String>
// var arrayM :[String] = Arrray()
var arrayM = [String]()


// 2.对可变数组的基本操作
//   1>添加元素
arrayM.append("aaa")
arrayM.append("bbb")
arrayM.append("ccc")

//   2>删除元素
arrayM.remove(at : 0)

//   3>修改元素
arrayM[0] = "ddd"

//   4>获取元素
let item = arrayM[1]


// 3.对数组的遍历
let count = array.count
for i in 0..<count {
    print(array[i])
}

for item in array {
    print(item)
}

for (index, item) in array.enumerated() {
    print(index)
    print(item)
}


// 4.数组的合并
// 如果两个数组中存放的是相同类型的元素，那么可以直接相加合并
let array1 = ["aaa", "bbb"]
let array2 = ["ccc", "ddd"]
let array3 = [12, 20]

let resultArray = array1 + array2

// let result = array1 + array3 错误

字典

• Swift 字典类型是Dictionary，是一个泛型集合

import UIKit

// 1.如何定义字典
// 1>定义不可变字典 ： 使用let修饰
//let dict : Dictionary<String, Any> = ["name":"aaa", "age":18]
//let dict = ["name":"aaa", "age":18] as [String : Any]
//let dict = ["name" : "aaa", "age" : "18"] // 不需要进行转化
let dict : [String : Any] = ["name":"aaa", "age":18]

// 2>定义可变字典 ： 使用var修饰
//var dictM = Dictionary<String, Any>()
var dictM = [String : Any]()


// 2.对可变字典的基本操作
// 2.1 添加元素
dictM["name"] = "aaa"
dictM["age"] = 18
dictM

// 2.2删除元素
dictM.removeValue(forKey: "age")
dictM

// 2.3修改元素
dictM["name"] = "bbb"
dictM.updateValue("ccc", forKey: "name")
dictM

// 2.4查找元素
dictM["age"]


// 3.遍历字典
for key in dict.keys {
    print(key)
}

for value in dict.values {
    print(value)
}

for (key, value) in dict {
    print(key, value)
}


// 4.字典合并
var dict1 : [String : Any] = ["name" : "aaa", "age" : 18]
let dict2 : [String : Any] = ["height" : 1.88, "phoneNum" : "10086"]

//let relustDict = dict1 + dict2 错误！！！
for (key, value) in dict2 {
    dict1[key] = value
}
dict1

元组

• 元组是Swift中特有的，OC中并没有相关类型
• 它是一个数据结构，在数学中应用广泛
• 类似于数组或者字典
• 可以用来定义一组数据
• 组成元组的类型的数据可以称为"元素"

import UIKit

// gyd 18 1.88

//1.使用数组保存信息
let infoArray : [Any] = ["gyd", 18, 1.88]
let arrayName = infoArray[0] as! String
print(arrayName.count)


//2.使用字典保存信息
let infoDict : [String : Any] = ["name" : "gyd", "age" : 18, "height" : 1.88]
let dictName = infoDict["name"] as! String
print(dictName.count)


//3.使用元组保存信息
// 方法一
let infoTuple = ("gyd", 18, 1.88)
let tupleName = infoTuple.0
let tupleAge = infoTuple.1
print(tupleName.count)

// 方法二：可以取一个别名
let infoTuple1 = (name:"gyd",age: 18, height:1.88)
infoTuple1.name
infoTuple1.age

// 方法三：不常用
let (name, age, height) = ("gyd", 18, 1.88)
name
age

可选类型

• 在OC开发中，如果一个变量暂时不使用，可以赋值为0(基本数据类型)或者赋值为空(对象类型)
• 在Swift开发中，nil也是一个特殊的类型。因为和真实的类型不匹配是不能赋值的(Swift是强类型语言)
• 但是在开发中赋值为nil在所难免，因此推出了可选类型

import UIKit

// 在开发中，只有可选类型才能赋值为nil，其他类型都不能赋值为nil
// 1.定义可选类型：泛型集合
//  1> 方式一
var name : Optional<String> = nil
//  2> 方式二 语法糖
var name1 : String? = nil

// 2.给可选类型赋值
//  1> 方式一
name = Optional("gyd")
//  2> 方式二
name = "gyd"

// 3.取出可选类型的值
print(name) //Optional("gyd")
// name!强制解包 --->注意：强制解包非常危险，如果可选类型为nil，那么强制解包就会奔溃
print(name!) //gyd
if name != nil {
    print(name!)
}
// 4.可选绑定（固定格式）：该语法用于可选类型，使我们使用可选类型更加方便
//  1>判断name是否有值，如果没有值，则直接不执行{}
//  2>如果有值，那么系统自动对可选类型进行解包，并且将解包后的结果赋值给前面的tempname

if let tempname = name{
    print(tempname)
}

// 可选类型的应用场景
// 只要一个类型有可能为nil，那么这个标识符类型一定是一个可选类型

// 1.将字符串转换成Int类型
let str = "123"
let num = Int(str) //let num : Int? = Int(str)
print(num) //Optional(123)

// 2.根据文件名称123.plist，获取该文件的路径
let path = Bundle.main.path(forResource: "123.plist", ofType: nil)

// 3.将一个字符串转成NSURL
let url = URL(string: "http://www.baidu.com")

// 4.从字典中取出元素
let dict : [String : Any] = ["name" : "gyd", "age" : 18]
let value = dict["name"]

类型转化

import UIKit

var str = "Hello, playground"
let NSString = (str as NSString).substring(to: 5)


let dict : [String : Any] = ["name" : "gyd", "age" : 18, "height" : 1.88]
let tempname = dict["name"]
// as? 转成的类型是一个可选类型，系统会自动判断tempname是否可以转成String，如果可以转成，那么获取字符串，如果不可以转成，那么返回nil
let name = tempname as? String
if let name = name{
    print(name)
}

if let name = dict["name"] as? String {
    print(name)
}


// as! 转成具体类型
// 注意：如果转化不成功，程序直接奔溃！
let tempname1 = dict["name"]
let name1 = tempname1 as! String

函数

• 函数相当于OC中的方法 Method/Function

import UIKit

// 1.没有参数，没有返回值的函数
func about() -> Void {
    print("iPhone 7 Plus")
}
func about1() {
    print("iPhone 7 Plus")
}

// 2.有参数，没有返回值的函数
func callPhone(phoneNum : String) {
    print("打电话给:\(phoneNum)")
}

// 3.没有参数，有返回值的函数
func readMsg() -> String {
    return "吃饭了吗？"
}
print(readMsg())

// 4.有参数，有返回值的函数
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
let result = sum(num1: 1, num2: 2)
print(result)

// 1.内部参数&外部参数
// 内部参数：在函数内部可以看到的标识符名称，该标识符就是内部参数
// 外部参数：在函数外部可以看到的标识符名称，该标识符就是外部参数
// 默认情况下，所有的参数都是内部参数也是外部参数
// 修改外部参数，在标识符前面加上外部参数名称即可
// 如果不希望显示外部参数，可以在标识符前加上 _
func sum(abc num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
//let result = sum(num1: 1, num2: 2)
let result = sum(abc: 1, num2: 2)

func sum1(_ num1 : Int, _ num2 : Int) -> Int {
    return num1 + num2
}
let result1 = sum1(1, 2)

// 2.可变参数
func sum(nums : Int...) -> Int {
    var total = 0
    for n in nums {
        total += n
    }
    return total
}
sum(nums: 1, 2, 3, 4)

// 3.默认参数
func makeCoffee(coffeeName : String = "雀巢") -> String {
    return "制作了一杯:\(coffeeName)咖啡"
}
makeCoffee(coffeeName: "拿铁")
makeCoffee()

// 4.指针参数
var m : Int = 20
var n : Int = 30

func swapNum(num1 : inout Int, num2 : inout Int) {
    let temp = num1
    num1 = num2
    num2 = temp
}
swapNum(num1: &m, num2: &n)