欢迎来到我的个人博客

Swift基础语法（三）

  • ~8.07K 字

一、字符串

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

OC中字符串@””，Swift中字符串””

1
2
3
4
5
使用 String 的原因
String 是一个结构体，性能更高
NSString 是一个 OC 对象，性能略差
String 支持直接遍历
Swift 提供了 String 和 NSString 之间的无缝转换

遍历字符串

1
2
3
4
5
// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {
    print(c)
}

字符串拼接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
两个字符串的拼接
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])

字符串的截取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Swift中提供了特殊的截取方式
该方式非常麻烦
Index创建较为麻烦
简单的方式是将String转成NSString来使用
在标识符后加:as NSString即可

let myStr = "www.520it.com"
var subStr = (myStr as NSString).substring(from: 4)
print("subStr:\(subStr)")
subStr = (myStr as NSString).substring(to: 3)
print("subStr1:\(subStr)")
subStr = (myStr as NSString).substring(with: NSRange(location: 4, length: 5))
print("subStr2:\(subStr)")

=++++  打印结果  ++++++
subStr:   520it.com
subStr1:   www
subStr2:   520it

字符串的判断

1
2
3
4
5
6
 //与oc方法的  isEqualToString方法一样
if str == str1 {
    print("======")
} else {
    print("!=====")
}

ASC 值进行比较

1
2
3
4
5
6
7
let s1 = "abc"
let s2 = "xyz"
if s1 > s2 {
    print("大于")
} else {
    print("小于")
}

二、数组

数组（Array）是一串有序的由相同类型元素构成的集合
数组分成：可变数组和不可变数组

  • 使用let修饰的数组是不可变数组
  • 使用var修饰的数组是可变数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 定义一个不可变数组
let array2 : [NSObject] = ["why", 18]
// 定义一个可变数组,必须初始化才能使用
var array1 : [String] = [String]()

在声明一个Array类型的时候可以使用下列的语句之一
var stuArray1:Array<String>
var stuArray2: [String]

声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的
// 定义时直接初始化
var array = ["why", "lnj", "lmj"]

// 先定义,后初始化
var array : Array<String>
array = ["why", "lnj", "lmj"]

//作为参数
init(dict: [String]){
}

对数组的基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 添加数据
array.append("yz")
// 删除元素
array.removeFirst()
// 修改元素
array[0] = "why"
// 取值
array[1]
// 对原数组进行升序排序
array.sort()
// 对原数组进行降序排序
array.sort(by: >)
// 将原数组除了最后一个以外的所有元素赋值给另一个数组
let anotherNums = Array(array[0 ..< nums.count - 1])

数组的遍历

1
2
3
4
5
6
7
8
9
10
11
12
// 遍历数组
for i in 0..<array.count {
  print(array[i])
}
// forin方式
for item in array {
    print(item)
}
// 设置遍历的区间
for item in array[0..<2] {
    print(item)
}

数组的合并

1
2
3
4
5
6
7
8
9
10
// 数组合并
// 注意:只有相同类型的数组才能合并
var array = ["why", "lmj","lnj"]
var array1 = ["yz", "wsz"]
var array2 = array + array1;

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

Swift中关于数组的 Sorted、forEach、 Map,Flatmap,Filter,Reduce的用法

简化参数名，如$0，$1(从0开始，表示第i个参数…)

  • Sorted

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    /*
      数组提供了一个排序函数，sorted().使用的是默认规则，当然我们也可以定制排序规则。
    */
    let names = ["ZZZZZZ", "BB", "A", "CCCC", "EEEEE"]
    names.sorted()
    // ["A", "BB", "CCCC", "EEEEE", "ZZZZZZ"]

    //更改排序规则 其实就是利用了函数重载，具体可看函数定义
    //sorted(by: <#T##(String, String) throws -> Bool#>)
    names.sorted {
          $0.count > $1.count
    }
    // ["ZZZZZZ", "EEEEE", "CCCC", "BB", "A"]

  • forEach

    1
    2
    3
    4
    5
    /* 循环遍历集合中的元素，相当于for-in 快速遍历    */
    let values = [5, 3, 2, 3,1]
    values.forEach {
        print("element is \($0)")
    }

  • Map

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    在OC中，对数组元素的操作是很不方便的一件事，遍历，操作，赋值给新数组，显得太繁琐。
    在swift中，对数组的操作就简洁了很多。
    map方法作用是把数组[T]通过闭包函数把每一个数组中的元素变成U类型的值，最后组成数组[U]
      
    +将示例数组，每个数字都加10，获得一个新的数组：
    //map函数里面可以直接使用函数作为参数,这里采用函数的方式。
    let numberArray = [1,2,3,4,5]
    func fmap(a : Int) -> Int{
        return a + 10
    }
    var result = numberArray.map(fmap)
    print(result)

    //采用闭包的方式
    var result = numberArray.map({($0) + 10})
    print(result)

    + map不只是可以用来做简单的数值运算，还可以处理一些其他复杂操作，如：在数字后拼接字符串，返回新的数组
    用常规方式写：
    for number in numberArray {
        stringsArray.append("\(number)只")
    }
    print(stringsArray)

    使用map：
    resultArray = numberArray.map({"\($0)只"})
    print(resultArray)

  • FlatMap

    1
    2
    3
    4
    5
    flatMap 更加强大，可以传入N个处理方法，将处理后得到数据，组合到同一个数组中
    resultArray = numberArray.flatMap({["\($0)个","\($0 )只"]})
    print(resultArray)
    //输出结果：
    ["1个", "1只", "2个", "2只", "3个", "3只", "4个", "4只", "5个", "5只"]

  • Filter

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    filter就是筛选的功能，参数是一个用来判断是否筛除的筛选闭包，
    根据闭包函数返回的Bool值来过滤值。为True则加入到结果数组中。

    + 找出数组中大于2的数
    常规方式实现：

    var filteredArray : [Int] = []
    for number in numberArray {
          if number > 2 {
          filteredArray.append(number)
      }
    }
    print(filteredArray)

    使用filter实现：
    filteredArray = numberArray.filter({$0 > 2})
    print(filteredArray)

  • reduce

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    reduce的作用给定一个类型为U的初始值，
    把数组[T]中每一个元素传入到combine的闭包函数里面，通过计算得到最终类型为U的结果值。

    +计算数组中所有数字的和，积

    常规方式实现：
    var sum = 0
    for number in numberArray {
        sum += number
    }
    print(sum)

    var product = 1
    for number in numberArray {
      product = product * number
    }
    print(product)

    使用reduce实现：
    sum = numberArray.reduce(0, combine: {$0 + $1})
    print(sum)

三、字典

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

字典的初始化
- 使用let修饰的数组是不可变字典
- 使用var修饰的数组是可变字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 定义一个不可变字典
let dict2 = ["name" : "why", "age" : 18]
// 定义一个可变字典
var dict1 := [String : NSObject]()

在声明一个Dictionary类型的时候可以使用下面的语句之一
var dict1: Dictionary<Int, String>
var dict2: [Int: String]

声明的字典需要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的
// 定时字典的同时,进行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]

//作为参数
init(dict: [String : AnyObject]){
}

字典的基本操作

1
2
3
4
5
6
7
8
9
// 添加数据
dict["height"] = 1.88
dict["weight"] = 70.0
// 删除字段
dict.removeValueForKey("height")
// 修改字典
dict["name"] = "lmj"
// 查询字典
dict["name"]
字典的遍历
1
2
3
4
5
6
7
8
9
10
11
12
// 遍历字典中所有的值
for value in dict.values {
    print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
    print(key)
}
// 遍历所有的键值对
for (key, value) in dict {
    print(key，value)
}
字典的合并
1
2
3
4
5
6
7
// 字典的合并
var dict1 = ["name" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

四、方法的书写

方法调用 闭包中必须使用 self，类中使用时不必加self

1
2
3
func 函数名(形参列表) -> 返回值类型  {
 // 函数体...
 }

有参数、无返回值：

1
2
3
4
5
6
7
8
func switchMethod(a:Int) -> (){
    switch a {
    case 100:
        print("值为100")
    default:
        print("常规值")
    }
}

无参数、有一个返回值：

1
2
3
4
5
6
func backCountValue() -> String {
    let strq = "backCountValue"
    let strq1 = "New"
    let str1 = strq1+strq
    return str1
}

无参数、有二个返回值：

1
2
3
4
func getNume()->(a:Int,b:Int)
{
    return (2,3)
}

有若干个不确定的参数、有一个返回值：

1
2
3
4
5
6
//写一个可变参数的函数只需要在声明参数时在类型后面加上 ... 就可以了
//输入的 input 在函数体内部将被作为数组 [Int] 来使用，
func sum(input:Int...)->Int{
    
    return input.reduce(0, {$0+$1})
}

函数的外部参数

1
2
3
4
5
//外部参数  width是提供给调用方来进行使用的，方便调用方明白函数里面参数的具体意思
//内部参数  a  是提供给函数内部使用的
func square(width a: Int,height b: Int) -> Int{
    return a * b
}

五、访问修饰符

在Swift语言中，目前有五种修饰符，有 open public internal fileprivate private 这五个访问权限，都可以修饰属性和方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1、private 
private修饰的属性或者方法只能在当前类里面访问。

2、fileprivate 
fileprivate访问级别所修饰的属性或者方法在当前的Swift源文件里可以访问，
(上面例子中private改为fileprivate就不会报错)

3、internal（默认访问级别，internal修饰符可写可不写） 
internal访问级别所修饰的属性或方法在源代码所在的整个模块都可以访问。 
如果是框架或者库代码，则在整个框架内部都可以访问，框架由外部代码所引用时，则不可以访问。 
(默认权限，如果项目没有进行组件化开发，整个APP项目内都是可以访问的。)

4、public 
可以被任何人访问，但是在其他模块中不可以被重写和继承，而在本模块中可以重写和继承

5、open 
可以任何人使用，包括重写和继承。

5种修饰符访问权限排序

open>public>internal>fileprivate>private

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可