您的位置:时时app平台注册网站 > 编程知识 > 斯维夫特3 - String 字符串、Array 数组、Dictionary 字

斯维夫特3 - String 字符串、Array 数组、Dictionary 字

2019-11-08 01:31
//  字符串 string
    func stringTest() -> Void {
        // 字符串
        let str1 = "yiyi"
        let str2 = "2222"
        var str3 = String()//空string
        var str4 = ""// 空string

        // 字符(字符为 一 个)
        let char1:Character = "d"

        // 字符串长度
        var strCount = str1.characters.count
        strCount = str1.lengthOfBytes(using: String.Encoding.utf8)
        print(String(format:"strCount == "),strCount)

        // 字符串转换integer
        print((str2 as NSString).integerValue)

        // 字符串拼接
        str3 = str1   str2
//        str3 = "(str1)(str2)"
//        str3 = globalStr   String(str1)
        print(String(format:"str3 == "),str3)

        // 字符串与字符拼接
//        str4 = str1 String(char1)
        str4 = "(str1)(char1)"
        str4 = str1.appending(String(char1))// 其他类型转换string  String() exp:String(strCount)
        print(String(format:""),str4)

        //字符串与其他类型值的拼接
        let int1 = 10
        let int2 = 11.1
        let str5 = String(format:"%i%.1f",int1,int2)
        print(String(format:"str5 == "),str5)

        // 字符串枚举 遍历每个字符
        let s1 = "hello world!"
        if strCount != 0 {
            print("判断string长度不为0,不是空")
        }
        for c in s1.characters {
            print(c)
        }

        // 字符串比较
        let ss1 = "hello"
        let ss2 = ",banana"
        var ss3 = ss1 ss2
        if ss1 == ss2 {
            print("ss1=ss2")
        }
        if ss1 ss2 == ss3 {
            print("ss1 ss2=ss3")
        }
        if ss1 > ss2 {// h大于b
            print("ss1>ss2")
        }
        // 判断字符串是否包含字符串
        if (ss3 .range(of: ss1) != nil) {
            print("字符串包含子串")
        }
     if ss3.hasPrefix("he") {}
     if ss3.hasSuffix("a") {}

// 字符串 大小写
        print(ss3.uppercased())// HELLO,BANANA
        print(ss3.capitalized)// Hello,Banana
        print(ss3.lowercased())// hello,banana
        /*
         // 这两个用法没 明白 
        print(ss3.uppercased(with: Locale(identifier: "l")))// HELLO,BANANA
        print(ss3.lowercased(with: Locale(identifier: "o")))// hello,banana
         */


        // 截取 修剪 字符串
        print(ss3.substring(from: ss3.characters.index(of: ",")!))//,banana 截取字符串从“,”开始
        print(ss3.substring(to: ss3.characters.index(of: ",")!))//hello 截取字符串到“,”结束
        print(ss3.unicodeScalars[ss3.unicodeScalars.startIndex ..< ss3.unicodeScalars.index(of: ",")!]);// hello
        print(ss3[ss3.index(ss3.startIndex, offsetBy: 4)])// o  取字符串的某个字符
        ss3.remove(at: ss3.characters.index(of: ",")!)// 去除字符串中特殊字符
        print(ss3)// hellobanana

    }

6. for 循环

斯维夫特 中,作者觉着 for 循环 更动依旧挺多,可是并不影响代码的读书
6.1 正序遍历

for i in 0..<5 {
    print(i)
}

打印结果:
0
1
2
3
4
Swift 中 i   /   i 都已经取消
`..<` 表示循环范围,学过初中数学就可以很好理解,[0,5),左闭右开区间

如果都是闭区间,如下
[0,5]
for i in 0...5 {
    print(i)
}

6.2 反序

for i in (0..<5).reversed() {
    print(i)
}

打印结果:
4
3
2
1
0

 

 

每回学完部分Swift,都发篇文字,记录一下学习成果。五个目标,
率先是复习一下此番学的知识点;
扶植是和iOSer交换。

swift中的群集和OC中的群集的区分: 

斯维夫特相关知识,本小说为 字符串、数组、字典的简要利用。

5. Switch

func demo(num: String) {

    switch num {
    case "10", "9":
        print("优")
    case "6":
        break
    default:
        print("一般")
    }

}

打印结果:
一般

Switch 语句和 OC 相比有了一些改变
switch 可以针对任意类型的值进行比较,不再局限于整数
switch 一般不需要break
switch 如果要多值 用 `,`
switch 所有的分支 至少一条指令,如果是什么都不写,才使用break

数组的起先化,注解存款和储蓄固定类型的数组

// 数组 array
    func arrayTest() -> Void {
        // 初始化
//        var array1:[Any] = []// 空 任意类型
//        var array2 = Array<Any>()
//        var array3:[String] = []// 空 string 类型
//        var array4 = Array<String>()
//        let array5 = Array<Any>(repeatElement("", count: 3))
        var arr0 = ["what","test","swift","array"]
        let arr1 = ["hyArr",1,"hySwift",3] as [Any]
        var arr2 = [1,"2","swiftArr2",3,9,5] as [Any]
        print(arr2[0], arr2[3], separator: "* ")

        // arr0.count  数组count
        print(String(format:"arr0 长度 == "),arr0.count)
        // 判断数组是否为空
        if arr1.isEmpty {
            print("arr1数组是空")
        }else {
            print("arr1数组不空")
        }
        // arr1[arr1.count-2] 取数组的某个元素
        print(arr1[arr1.count-2])// hySwift
//        print(arr1[0])// hyArr
        //  public var first: Self.Iterator.Element? { get }
        print(arr1.first!)// hyArr

        // 遍历数组
        for i in 0..<arr1.count {
            print(arr1[i])
        }
        // 包含
        if arr0 .contains("test") {
            print("数组包含 test")
        }else {
            print("数组不包含 test")
        }

        // 删除元素
//        arr2 .remove(at: 4)
//        arr2 .removeSubrange(1..<3)// 删除 1、2 两个元素
//        arr2 .removeLast()
//        arr2 .removeFirst()
        arr2 .removeAll()
        print(arr2)

        // 添加元素
        arr2 .append("new1")// ["new1"]
        arr2.append(contentsOf: ["Shakia", "William"])
        print(arr2)
        arr2 = arr1   arr2// ["hyArr", 1, "hySwift", 3, "new1"]
        arr2 = arr1
        arr2 .insert("insertElement", at: 3)//["hyArr", 1, "hySwift", "insertElement", 3, "new1"]

        // 更换
        if let i = arr0.index(of: "test") {
            arr0[i] = "测试"
        }
        arr2[0] = "domy"
        print(arr2)

        // 数组排序
        var sortArr = [3,5,1,0,8,0]
        sortArr.sort(by: >)
        print(String(format:"排序后:"),sortArr)// 排序后: [8, 5, 3, 1, 0, 0]


        // 二维数组
        let tArr1 = [["tSwift","haha"],1,[3,2]] as [Any]
        let subArr1 = tArr1[0]
        print(subArr1)



        ///  Array => NSArray
        ///  苹果的例子
        /// Description:
        /// The following example shows how you can bridge an `Array` instance to
        /// `NSArray` to use the `write(to:atomically:)` method. In this example, the
        /// `colors` array can be bridged to `NSArray` because its `String` elements
        /// bridge to `NSString`. The compiler prevents bridging the `moreColors`
        /// array, on the other hand, because its `Element` type is
        /// `Optional<String>`, which does *not* bridge to a Foundation type.
             let colors = ["periwinkle", "rose", "moss"]
             let moreColors: [String?] = ["ochre", "pine"]

             let url = NSURL(fileURLWithPath: "names.plist")
             (colors as NSArray).write(to: url as URL, atomically: true)
             // true

             (moreColors as NSArray).write(to: url as URL, atomically: true)
             // error: cannot convert value of type '[String?]' to type 'NSArray'


        /// Array 的更多其他用法点进去查看方法文档
    }

2. 可选项

2.1 原始的可选项,在头文件的概念中,有八个值
none 没有值
some 某后生可畏类值

let x: Optional = 10
print(x)

输出结果:
Optional(10)
可以看到,输出结果Optional(10),表示是一个可选值

2.2 轻松的定义
? 来定义五个可选值,恐怕有值, 也可能有可能未有

var y: String? = "多看书"
print(y)
打印结果:
Optional("多看书")

y = nil
print(y)
打印结果:
nil

2.3 可选值的计算
地方说了,分化类型的值,是不能够开展测算的,倘若多少个都以可选值是或不是能揣度呢?
答案是不可能的,因为可选值,有希望是 nil,不能够拓宽测算

let x: Int? = 10

let y: Int? = 20

print(x   y) 这句代码会报错
有一种方法,可解决这个问题 
print(x!   y!)
`!` 强制解包 -> 从可选值中 强行获取 非空值,如果真的是nil 就会直接崩溃,可想而知,这种方式并不好,违背了Swift 的安全性,怎么解决呢?继续往下看。。。

 

    // 字典 dictionary
    func dictionaryTest() -> Void {        
        // 创建字典
        var dict = [200:"ok",400:"error"]// [key:value]
        var emptyDict: [String: Any] = [:]// 空字典 var emptyDict: [Int: String] = [:]
        emptyDict = ["key1":"value1","key2":2]

        // Getting and Setting Dictionary Values
        print(dict[200]!)// ok
        print(emptyDict["key1"]!)// value1
        // 添加键值对
        emptyDict["key3"] = "value3"
        print(emptyDict)// ["key2": 2, "key3": "value3", "key1": "value1"]
        // 更新键值对的value
        emptyDict["key2"] = "updateValue2"
        print(String(format:("更换value后:")),emptyDict)


        var interestingNumbers = ["primes": [2, 3, 5, 7, 11, 13, 15],
                                  "triangular": [1, 3, 6, 10, 15, 21, 28],
                                  "hexagonal": [1, 6, 15, 28, 45, 66, 91]]
        //  排序
        for key in interestingNumbers.keys {
            interestingNumbers[key]?.sort(by: >)
        }
        print(interestingNumbers["primes"]!)
        /// print(interestingNumbers)
        /// ["hexagonal": [91, 66, 45, 28, 15, 6, 1],
        /// "primes": [15, 13, 11, 7, 5, 3, 2],
        /// "triangular": [28, 21, 15, 10, 6, 3, 1]]

        // 遍历字典
        let imagePaths = ["star": "/glyphs/star.png",
                          "portrait": "/images/content/portrait.jpg",
                          "spacer": "/images/shared/spacer.gif"]
        for (key, value) in imagePaths {
            print("The path to '(key)' is '(value)'.")
        }

/// search a dictionary's contents for a particular value
//        let glyphIndex = imagePaths.index {
//            $0.value.hasPrefix("/glyphs")
//        }
//        print(imagePaths[glyphIndex!].value)// /glyphs/star.png
//        print(imagePaths[glyphIndex!].key)// star
        let glyphIndex = imagePaths.contains {
            $0.value.hasPrefix("/glyphx")
        }
        print(glyphIndex)// ture


/// Bridging Between Dictionary and NSDictionary
        // imagePaths as NSDictionary
        print("keys:((imagePaths as NSDictionary).allKeys) ,values:((imagePaths as NSDictionary).allValues)")



    }

3. 逻辑分支

3.1 轻易的分层,轻易的if...else 决断

let x = 10
if x > 5 {
    print("大了")
} else {
    print("小了")
}

与 OC 不同的是,条件没有了 `()`

3.2 三目运算符
与 OC 中的三目运算符 格式同样

let x = 10
x > 5 ? print("大了") : print("小了")

唯一不同,是可以执行空运行
x > 5 ? print("大了") : ()

4、字符串插值

///  2016.12.29

8. 数组

8.1 数组的概念
OC 使用 [] 定义数组, Swift 同样,可是并未有 @

// 自动推导的结果,[String] -> 表示数组中存放的是 String
// 跟 OC 中的数组指定泛型类似
let array = ["张三", "小王", "小羊"]
print(array)
打印结果:
["张三", "小王", "小羊"]

// [Int] -> 表示存放的都是 Int
// Swift 中基本数据类型不需要包装
let array2 = [1, 2, 3, 4, 5]
print(array2)
打印结果:
[1, 2, 3, 4, 5]

// CG 结构体
let p = CGPoint(x: 10, y: 20)
let array3 = [p]
print(array3)
打印结果:
[(10.0, 20.0)]

8.2 数组的遍历

1> 按下标遍历
let array = ["张三", "李四", "王五"]
for i in 0..<array.count {
    print(array[i])
}

2> for in 遍历元素
let array = ["张三", "李四", "王五"]
for s in array {
    print(s)
}

3>  枚举遍历,遍历下标 和 元素
let array = ["张三", "李四", "王五"]
for e in array.enumerated() {
    print("(e.offset) (e.element)")

打印结果:
0 张三
1 李四
2 王五
}

4> 遍历下标和元素
let array = ["张三", "李四", "王五"]
for (i, s) in array.enumerated() {
    print("(i) (s)")
}
结果同3

5> 反序遍历数组
let array = ["张三", "李四", "王五"]
for i in array.reversed() {
    print(i)
}
打印结果:
王五
李四
张三

6. 反序遍历 下标 和 元素
let array = ["张三", "李四", "王五"]
for (i, s) in array.enumerated().reversed() {
    print(i, s)
}

这里需要注意,先枚举,再反序,否则 下标是错误的

8.3 数组的 增/删/改

1> 追加 修改数组 要用 var  数组必须是可变数组
var array = ["张三", "李四", "王五"]
array.append("赵六")
print(array)

打印结果:
["张三", "李四", "王五", "赵六"]
2> 根据下标修改

aray[0] = "老大"
print(array)
结果:
["老大", "李四", "王五", "赵六"]

3> 删除
/ / 根据指定下标删除
array.remove(at: 3)
print(array)
结果:
["老大", "李四", "王五"]

3.1>删除全部,保留空间
array.removeAll(keepingCapacity: true)
print("(array) (array.capacity)")

结果:
[] 6

8.4 数组的体量

var array = [Int]()
print("初始容量 (array.capacity)")

for i in 0..<8 {
    array.append(i)
    print("(array) 容量 (array.capacity)")
}

结果:
初始容量 0
[0] 容量 2
[0, 1] 容量 2
[0, 1, 2] 容量 4
[0, 1, 2, 3] 容量 4
[0, 1, 2, 3, 4] 容量 8
[0, 1, 2, 3, 4, 5] 容量 8
[0, 1, 2, 3, 4, 5, 6] 容量 8
[0, 1, 2, 3, 4, 5, 6, 7] 容量 8

插入元素时,如果容量不够,会 *2 (初始为0)
容量不够,会在现有基础上 *2 ,可以避免每次都要分配空间

8.5 数组的联合

var array = ["a", "b", "c"]
let array2 = ["d", "e"]
array  = array2
print(array)

结果:
["a", "b", "c", "d", "e"]

 

1、斯威夫特3 ,字符串的大致利用,直接将代码贴过来,更有利查看

9 字典

9.1 字典的概念
OC 中 字典定义 用 {}
Swift 中 []

// [String : Any]
let dict: [String : Any] = ["name" : "老张", "age" : 3]
print(dict)
结果:
["name": "老张", "age": 3]

// [[String : Any]]
let array = [
    ["name" : "小王"],
    ["age" : 18]
]

print(array)
结果:
[["name": "小王"], ["age": 18]]

概念字典的数组,这种格式在支付中运用的最多
具备指标能被转成JSON(字典也许数组卡塔尔必需坚守以下法规

  • 头号节点是数组/字典
  • 持有指标必需是 NSString,NSNumber 或 NSNull
  • NSArray,NSDictionary 能够嵌套使用
  • 所有的KEY,都是NSString
  • NSNumber 不可能为空 或 无穷大

9.2 字典的增删改

var dict: [String : Any] = ["name" : "小王", "age" : 10]
// 新增 - 如果KEY 不存在 就是新增
dict["title"] = "H5"
print(dict)
结果:
["name": "小王", "age": 10, "title": "H5"]

// 修改 - 字典中,是通过 KEY 取值,KEY 在字典中 必须是唯一的
// 如果 KEY 存在 就是修改
dict["name"] = "老王"
print(dict)

结果:
["name": "老王", "age": 10, "title": "H5"]

// 删除 - 直接给定 KEY
//  *** 字典是通过 KEY 来定位值的, KEY 必须是可以hash(哈希)
// hash 就是将字符串变成唯一的 `整数` ,便于查找,提高字典遍历的速度
dict.removeValue(forKey: "age")
print(dict)
结果:
["name": "老王", "title": "H5"]

9.3 字典的遍历

let dict: [String : Any] = ["name" : "小王", "age" : 19, "title" : "哈哈"]

// 元组 (key: String, value: Any)
for e in dict {
    print("(e.key) (e.value)")
}
结果:
name 小王
age 19
title 哈哈

// 第二种
for (k, v) in dict {
    print("(k) (v)")
}
结果同上

9.4 字典的集结

var dict: [String : Any] = ["name" : "小王", "age" : 19, "title" : "哈哈"]
let dict1 = ["name" : "老李", "height" : 1.8] as [String : Any]

// 将dict1 合并 到dict
// 字典不能直接相加
//
for e in dict1 {
    dict[e.key] = dict1[e.key]
}
print(dict)
结果:
["name": "老李", "age": 19, "title": "哈哈", "height": 1.8]

时时app平台注册网站 1

3、字典的轻便利用

1. 变量和常量

在 Swift 中,定义变量和常量,分别使用两个关键字 let(常量),var(变量)。
顾名思义,
使用 let 定义的常量,是不允许更改的,使用 let 定义常量,必须要被初始化
使用 var 定义的变量,是可以更改的
如下代码:

let y 会直接报错
Constant 'y' used before being initialized

let x = 10
x = 20
会报错:Cannot assign to value: 'x' is a 'let' constant
Change 'let' to 'var' to make it mutable
意思是,let 定义的是变量,不可以修改,将 let  改为 var 变成可变的

var x = 10
x = 20
print(x)

输出结果:20

Swift 中常用的 option click,斯威夫特 相比较于 OC,斯威夫特能够张开自动推导,无需先内定变量/常量的等级次序,编写翻译器自动推导,依据左侧代码的举行理并了结果推导

x 的类型编译器可以 根据右边的数值自动推导,使用 option   click 可以查看

x 在这里就是 整数 Int 类型

var x = 10
x = 20

y就是 Double 类型        
let y = 10.5

v 就是UIView 类对象
let v = UIView()
print(x)
print(y)
print(v)

打印结果:
20
10.5
<UIView: 0x7ff25e519840; frame = (0 0; 0 0); layer = <CALayer: 0x60400003d6a0>>

Swift 中对品种供给拾壹分严谨
别的例外门类的多少里面,不允许直接运算
斯威夫特 不会做私下认可的隐式转变,全数的花色分明都以由技术员担负
Swift 中不设有基本数据类型,都以结构体

let x = 1
let y = 1.5
这行代码会报错,Binary operator ' ' cannot be applied to operands of type 'Int' and 'Double'
意思就是,不同数据类型不能进行 运算
print(x   y)

如果想要进行计算,就需要强制转换
1. 将y 转换为整数
print(x   Int(y))
2. 将x 转换为 浮点类型
print(Double(x)   y)

输出结果:
2
2.5

OC 中写法 int(x) `强制类型转换`
Swift  Int(x) `结构体的构造函数`

固然想钦命具体变量/常量的体系 还是能如此写

let x: 类型 = 值
提示:在 Swift 开发中,通常使用自动推导,很少使用直接设置类型
let x: Double = 10
let y = 2.3
print(x   y)
打印结果:
12.3
  • 关于 var 和 let 的选择
    不可变的会更安全,开荒的时候,平日先选取let,再须求调换的时候 再改成 var

时时app平台注册网站 2

 2、数组的回顾利用

注意:

  • 技师必需为每三个 ! 负责
  • 程序中,必定要少用 !

3 、Swift中可变类型和OC中的NSString做了周到的交接,换句话说,正是swiftStrig能够运用NSString的章程

///***********************************************************************************************************/

7. 字符串

7.1 字符串的遍历

let str = "你要飞吗"
for c in str {
    print(c)
}

打印结果:
你
要
飞
吗

7.2 字符串长度

1> 返回指定编码的对应的字节数量
// utf-8 编码 每个汉字是3个字节
let str = "hello world你好"
print(str.lengthOfBytes(using: .utf8))
打印结果:
17

2>返回字符串的长度->字符的个数
let str = "hello world你好"
print(str.count)
打印结果:
13

3>使用NSString 中转
// str as NSString
// Switf 中可以使用 `值 as 类型` 进行类型转换
let str = "hello world你好"
let ocStr = str as NSString
print(ocStr.length)

7.3 字符串拼接
使用 () 实行字符串 拼接,可以拼接 任何类型

let name = "老刘"
let age = 22
let title: String? = "Boss"
let point = CGPoint(x: 100, y: 200)

let str = "(name) (age) ((title ?? "")) (point))"
print(str)

打印结果:
老刘 22 Boss (100.0, 200.0))

7.4 字符串格式化

let h = 9
let m = 4
let s = 3

let time = "(h):(m):(s)"
print(time)

let time2 = String(format: "d:d:d",h,m,s)
print(time2)

打印结果:
9:4:3
09:04:03

7.5 字符串子串
动用 NSString 取子串比较实惠

let str = "我们一起去飞吧"
let ocStr = str as NSString
let s1 = ocStr.substring(with: NSMakeRange(2, 3))
print(s1)

(4卡塔尔国、数组查询

///***********************************************************************************************************/

4. 可选拔的判断

4.1 OC 的逻辑

func demo(x: Int?, y: Int?) {
    强制解包,但是x 或 y 可能为空,所以不能这么搞 pass
    print(x!   y!)

使用if判断,完美解决问题,代码太多,逻辑没问题
    if x != nil && y != nil {
        print(x!   y!)
    } else {
        print("x or y is nil")
    }
}

4.2 ?? 操作符
?? 是二个三目运算符
借使可接纳的值有值,使用当前值
如果为 nil 使用 ?? 后边的值

func demo(x: Int?, y: Int?) {

   print((x ?? 0)   (y ?? 0))
}

调用函数,demo(x: nil, y: 12)

打印结果:
12

?? 操作符 也有缺点 看下面的代码

let name: String? = "小李"
print(name ?? ""   "您好")
print((name ?? "")   "您好")

打印结果:
小李
小李您好

不难发现,name 有值,但是打印结果不同,缺点也很明显,就是?? 优先级太低了 使用时候,最好加()

4.3 if let / var 连用语法,指标正是判定值

func demo() {
    let oName: String? = "老王"
    let oAge: Int? = 18

    if var name = oName,
        let age = oAge {
        name = "老张"
        print(name   String(age))

    } else {
        print("name or age is nil")
    }
}

if let 连用,判断对象是否为 nil ,{} 内一定有值,可以直接使用,不需要解包了
if var 连用,{} 内可以对值进行修改
进入分支之后, name 和 age 一定有值,不需要解包
name 和 age 的作用域仅仅在 {} 内

4.4 gurad let/var
guard let 和 if let 恰巧相反

let oName: String? = "老李"
let oAge: Int? = 29 

// guard let 守护 一定有值,如果没有值,直接返回
guard let name = oName,
    let age = oAge else {
        print("name or age is nil")
        return
}

// 代码执行到此,name 和 age 一定有值
print(name   String(age))

guard let 和 if let 使用技巧
使用同名的变量接收值,在后续使用的时候都是非空值,不需要解包
也就是将 上面代码 oName 和 oAge 修改为 name 和 age

时时app平台注册网站 3

以下内容是私有的上学进度和收获,还盼见到错误的位置告诉自身,斯威夫特小编从4.x 最早系统自学了。

  在swift中,Array也未曾可变和不得变类型之分,並且决议于用哪些主要字来修饰,var正是可变,let正是不行变 

时时app平台注册网站 4

时时app平台注册网站 5

时时app平台注册网站 6

 

2、swift中的字符串和OC中的字符串的分别

时时app平台注册网站 7

 

利用字典开始化形式进行创办的是稳固键值类型的字典

2、字典(Dictionary)

下边简介下String的有个别行使办法:

 

 

 在swift输出语句中绝非格式化占位符,想要完结如此的功能,我们要用到字符串插值格式:"()"

时时app平台注册网站 8

 

时时app平台注册网站 9

 

时时app平台注册网站 10

斯维夫特中的字符串未有可变类型和不得变类型之分,在swift中,字符串到底可变不可变, 决定于评释变量的花色,假设定义的是let就是不可变,假如定义的是var正是可变

  当大家先行表明数组六月素的花色,内部因素必需后生可畏律

时时app平台注册网站 11 

时时app平台注册网站 12

打字与印刷结果如下:

2、字典键值对的去除

字典初叶化的措施也可以有三种

二、swift中的会集

自然大家也得以像下边这样写:

 

 

 

iOS手艺沟通群 461069757 迎接参预 

(3卡塔 尔(英语:State of Qatar)、 改换数组中的成分

 

在OC中,我们常用的数组和字典都以引用类型,而Swift中是值类型,那是因为在Swift中,那么些结合类的底层都是struct

 

我们掌握在iOS开辟中用的最多的根底项目大概就数字符串了,以致部分集聚类型的应用,下边我们来轻便学习下字符串String以致Array、Dictionary等联谊类型的施用形式

(1卡塔尔国、数组增日币素

Swift中的字符串是值类型 , 而OC当中,不加特殊评释的话是引用类型,不用操心内部存款和储蓄器难题,Swift已经做好了优化,

  3、在swift中,援用计数管理内存的章程与OC在那之中援用计数管理内部存款和储蓄器的措施,依旧区别的 (见后边内容卡塔 尔(英语:State of Qatar)

 

  2、在swift中,也是接纳引用计数的定义来保管内部存款和储蓄器的,但是引用计数只适用于对象类型,值类型不必要管住

上面我们来分别介绍下数组成分的增、删、改、查:

斯维夫特和OC中聚合相比较

时时app平台注册网站 13

  

 

 

  

 

1、字典键值对的增加

  1、在swift中的集结类也都是值类型,而OC个中的是引用类型

时时app平台注册网站 14

 

 枚举值类型,函数,闭包是援用类型

由此上边面的措施来删除钦赐下标的元素

时时app平台注册网站 15

运用构造方法创制的是由一个一定数据类型构成的数组

4、字典键值对的查询

时时app平台注册网站 16

 

1、字符串的字面量 , 例如"jeck"字面量

(2卡塔 尔(英语:State of Qatar)、数组删除成分

时时app平台注册网站 17

一、字符串 

  4、在swift中数组是能够寄存任意等级次序,可是OC中,只好贮存对象类型

Swift提供了C和Objective-C根底项指标友好意气风发套版本,富含用于整型的Int,用于浮点值的Double和Float,用于布尔值的Boolean,和用来文书数据的String。Swift还提供了Array和Dictionary那三种集合类型的增高版本。

选用字面量来给字典举行赋值

1、

  在swift中,使用字面量来给三个数字赋值

 

 

 

2、

时时app平台注册网站 18

 时时app平台注册网站 19

1、数组(Array)

 

时时app平台注册网站 20

3、字典键值没错改造

 

本文由时时app平台注册网站发布于编程知识,转载请注明出处:斯维夫特3 - String 字符串、Array 数组、Dictionary 字

关键词: