字符串的介绍
- 字符串在任何的开发中使用都是非常频繁的
- 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..<endIndex)
let middle2 = urlString.substring(with: range2)
数组
数组的介绍
- 数组（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..<array.count {
print(array[i])
}
// forin方式
for item in array {
print(item)
}
// 设置遍历的区间
for item in array[0..<2] {
print(item)
}
// 遍历数组的同时获取下标值
let names = ["why", "yz", "lnj", "lmj"]
for (index, name) in names.enumerate() {
print(index)
print(name)
}
数组的合并
// 数组合并
// 注意:只有相同类型的数组才能合并
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..<items.count {
strM = strM + " " + "\(items[i])"
}
print(strM)
}
print(20, 30, 40)
myPrint(20, 30, 40)
- 注意三: 默认参数
- 某些情况,如果没有传入具体的参数,可以使用默认参数
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)")
