Swift学习 - 字符串&& 数组 && 字典&& 函数

字符串的介绍

• 字符串在任何的开发中使用都是非常频繁的
• OC和Swift中字符串的区别
  • 在OC中字符串类型时NSString,在Swift中字符串类型是String
  • OC中字符串@"",Swift中字符串""
• 使用 String 的原因
  • String 是一个结构体，性能更高
  • NSString 是一个 OC 对象，性能略差
  • String 支持直接遍历
  • Swift 提供了 String 和 NSString 之间的无缝转换

字符的定义

• 定义不可变字符串

// 1> 定义不可变字符串 : 使用let修饰
let str : String = "hello swift"
// str = "hello Objective-C" 错误写法

• 定义可变字符串

// 2> 定义可变字符串 : 使用var修饰
var strM : String = "hello world"
strM = "hello china"

字符串的使用

获取字符串的长度

• 获取字符集合,再获取集合的count属性

let count = str.characters.count

字符串拼接

• 两个字符串的拼接

let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2

• 字符串和其他数据类型的拼接

let name = "why"
let age = 18

let info = "my name is \(name), age is \(age)"

• 字符串的格式化
  • 比如时间:03:04

let min = 3
let second = 4

let time = String(format: "%02d:%02d", arguments: [min, second])

字符串的截取

• Swift中提供了特殊的截取方式
  • 该方式非常麻烦
  • Index创建较为麻烦
• 简单的方式是将String转成NSString来使用
  • 在标识符后加:as NSString即可

let urlString = "www.520it.com"

// Swift中通过 as 关键字可以将String类型转成NSString的类型
let header1 = (urlString as NSString).substring(to: 3)
let footer1 = (urlString as NSString).substring(from: 10)
let range1 = NSRange(location: 4, length: 5)
let middle1 = (urlString as NSString).substring(with: range1)

• swift截取方式

let urlString = "www.520it.com"

let headerIndex = urlString.index(urlString.startIndex, offsetBy: 3)
let header2 = urlString.substring(to: headerIndex)

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

let startIndex = urlString.index(urlString.startIndex, offsetBy: 4)
let endIndex = urlString.index(urlString.startIndex, offsetBy: 9)
let range2 = Range(startIndex..

---

数组

数组的介绍

• 数组（Array）是一串有序的由相同类型元素构成的集合
• 数组中的集合元素是有序的，可以重复出现
• Swift中的数组
  • swift数组类型是Array，是一个泛型集合

数组的初始化

• 数组分成:可变数组和不可变数组

  • 使用let修饰的数组是不可变数组
  • 使用var修饰的数组是可变数组

• 定义不可变数组

let array : [Any] = ["why", 18, 1.88]

• 定义可变数组

var arrayM = [Any]()

对数组的基本操作

// 添加数据
array.append("yz")

// 删除元素
array.removeFirst()

// 修改元素
array[0] = "why"

// 取值
array[1]

数组的遍历

// 遍历数组
for i in 0..

数组的合并

// 数组合并
// 注意:只有相同类型的数组才能合并
var array = ["why", "lmj","lnj"]
var array1 = ["yz", "wsz"]
var array2 = array + array1;

// 不建议一个数组中存放多种类型的数据
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4

字典

字典的介绍

• 字典允许按照某个键来访问元素
• 字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合
• 键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的
• Swift中的字典
  • Swift字典类型是Dictionary，也是一个泛型集合

字典的初始化

• Swift中的可变和不可变字典
  • 使用let修饰的数组是不可变字典
  • 使用var修饰的数组是可变字典

// 定义一个可变字典
var dict1 : [String : Any] = [String : Any]()

// 定义一个不可变字典
let dict2 : [String : Any] = ["name" : "why", "age" : 18]

字典的基本操作

// 添加数据
dict["height"] = 1.88
dict["weight"] = 70.0
dict

// 删除字段
dict.removeValueForKey("height")
dict

// 修改字典
dict["name"] = "lmj"
dict.updateValue("lmj", forKey: "name")
dict

// 查询字典
dict["name"]

字典的遍历

// 遍历字典中所有的值
for value in dict.values {
    print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
    print(key)
}

// 遍历所有的键值对
for (key, value) in dict {
    print(key)
    print(value)
}

字典的合并

// 字典的合并
var dict1 = ["name" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

函数

函数的介绍

• 函数相当于OC中的方法
• 函数的格式如下

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}

• func是关键字,多个参数列表之间可以用逗号（,）分隔，也可以没有参数
• 使用箭头“->”指向返回值类型
• 如果函数没有返回值，返回值为Void.并且“-> 返回值类型”部分可以省略

常见的函数类型

// 1.没有参数,没有返回值的函数
func about() -> Void {
    print("iPhone7")
}
about()

func about1() {
    print("iPhone7")
}

about1()

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

callPhone(phoneNum: "+86 110")


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

let msg = readMsg()

// 4.有参数有返回值的函数
func addTwoNum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

let result = addTwoNum(num1: 20, num2: 30)

函数的使用注意

• 注意一: 外部参数和内部参数
  • 在函数内部可以看到的参数,就是内部参数
  • 在函数外面可以看到的参数,就是外部参数
  • 默认所有的参数都是外部参数和内部参数
  • 如果不想要外部参数,可以在参数名称前加_

// 1.内部参数&外部参数
/*
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

sum(num1: 20, num2: 30)
*/

/*
func sum(_ num1 : Int,_ num2 : Int) -> Int {
    return num1 + num2
}

sum(20, 30)
*/

func sum(abc num1 : Int, cba num2 : Int) -> Int {
    return num1 + num2
}

sum(abc: 20, cba: 30)


// sum(20, 30)

• 注意二: 可变参数
  • swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数
  • 它们必须具有相同的类型
  • 我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数

// 2.可变参数
func sum(nums : Int...) -> Int {
    var total = 0
    for num in nums {
        total += num
    }

    return total
}


sum(nums: 20, 30, 40, 50)

func myPrint(_ items : Any...) {

    var strM : String = "\(items[0])"

    for i in 1..

• 注意三: 默认参数
  • 某些情况,如果没有传入具体的参数,可以使用默认参数

func makeCoffee(coffeeName : String = "雀巢") {
    print("制作了一杯爱心\(coffeeName)咖啡")
}

makeCoffee(coffeeName: "拿铁")
makeCoffee(coffeeName: "摩卡")
makeCoffee()

• 注意四: 引用类型(指针的传递)
  • 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
  • 必须是变量,因为需要在内部改变其值
  • Swift提供的inout关键字就可以实现
  • 对比下列两个函数

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

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

swap(&m, &n)

print("m:\(m) n:\(n)")