【4858.com】字符串与Array等联谊的利用,字典的利用

By admin in 4858.com on 2019年4月26日

Swift相关知识,本小说为 字符串、数组、字典的大约利用。

每趟学完部分斯维夫特,都发篇文字,记录一下就学成果。多少个目标,
第3是复习一下此次学的知识点;
扶助是和iOSer沟通。

Swift提供了C和Objective-C基础项目的亲善壹套版本,包含用于整型的Int,用于浮点值的Double和Float,用于布尔值的Boolean,和用于文书数据的String。Swift还提供了Array和Dictionary那二种集结类型的升高版本。

近年来趁着公司付出方式的改变,swift也体现尤为主要,相对来讲,swift语言越发简明,严峻.但对于本人的话,认为swift细节的管理很麻烦,大概是还没适应的原故吧.基本每写一句代码,都要对变量的数据类型进行决断,还要举办强转等等.

好了,废话不多说了,直接把本身对swift的语法的局地理解进献给大家,希望能对上学swift语法的情人有所帮衬,如有不足之处,还请多多原谅,如若有荒唐之处,迎接指正

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

以下内容是私有的读书进度和收获,依旧期待见到错误的地方告诉俺,Swift作者从肆.x
发轫系统自学了。

大家掌握在iOS开荒中用的最多的基本功项目或许就数字符串了,以及一些凑合类型的选择,上面大家来大致学习下字符串String以及Array、Dictionary等联谊类型的应用方法

Swift 介绍

简介

斯威夫特 语言由苹果集团在 201四 年推出,用来撰写 OS X 和 iOS 应用程序

2014 年,在 Apple WWDC 发布

历史

2010 年 7 月,苹果开采者工具部门组长 Chris Lattner 开首发轫 斯威夫特编制程序语言的陈设性工作

用一年岁月,达成人中学央架构

Swift 大约历经 四 年的开辟期,201四 年 6 月公布

 

克里斯·拉特纳何许人?

          LLVM 项目标关键发起人与作者之1

          Clang 编写翻译器的撰稿人

          苹果公司『开拓者工具』部门的牵头

          领导Xcode、Instruments等编写翻译器团队

          斯维夫特的大多数基础架构均由她一人完结

 

特点

     从它的语法中能看到`Objective-C、JavaScript、C#、Python`等语言的黑影

     语法简单、代码简洁、使用方便

     可与Objective-C混合使用(互相调用)

     提供了近乎 Java
的名字空间(namespace)、泛型(generic)、运算对象重载(operator
overloading)

 

为啥设计斯威夫特语言

     让使用开辟更简便易行、更加快、更平稳

     确认保障最终选拔具备更加好的身分

 

Swift初体验

Playground是什么?

从Xcode陆初叶现出(斯威夫特早先产出)

翻译为:操场/游乐场

对此学习Swift基本语法相当便利

     所见即所得(神速查看结果)

     语法天性发生改造时,能够火速查看.

 

一.斯威夫特最宗旨的语法变化

 

1.导入框架  

1 OC: #import <UIKit/UIKit.h>
2 Swift: import UIKit 

二.概念标志符

     OC: int a = 20;

     Swift: let a : Int = 20   ==  let a = 20     

 

     定义标记符格式: let / var 标记符 : 数据类型 = 赋值    

     注意:let表明的是常量,不得以对常量重新赋值

 

     斯威夫特中定义标记符,必须评释该标志符是变量(var)还是常量(let)

     注意:在swift中壹经一行代码中唯有一条语句,那么说话前边的 ;(分号)
能够省略

             1行内有多条语句 ; 不可以省略,   不建议壹行写多条语句

 

三.Swift中的打字与印刷    

1 OC: NSLog(@"Hello world”);  /  NSLog(@"%d", a);
2 //Swift中字符串不需要@
3 print(a)   /   print("hello world")

 

二.常量&变量

 

壹.怎么样是常量和变量?

 

     在Swift中规定:在概念一个标志符时,必须鲜明表明该标记符是常量照旧变量

     使用let来定义常量,定义之后,不能够开始展览改变

     使用var来定义变量,定义之后,可以实行修改

 

二.常量个变量的选择注意

 

     在行使中,建议先选拔常量,那样更安全,幸免相当大心修改从前的值

     假若须求修改时,再把常量修改为变量

   
 注意:常量的面目是,指向的内部存储器地址无法改改,但足以找到内部存储器地址对应的靶子,修改对象内部的属性

1 let view : UIView = UIView()
2 view.alpha = 0.5
3 view.backgroundColor = UIColor.orangeColor()

 

三.类型推导

 

一.如何是种类推导?

   
 在斯威夫特中,若是在概念标志符的还要一直对其进行赋值,那么系统会自行根据赋的值的数据类型,推导出标志符的品种

     假如定义标记符的还要平素赋值,那么标志符前面包车型的士数据类型能够回顾

     能够通过option + 鼠标左键来查看标志符的项目

1 let n = 3.14
2 let View = UIView()

 

4.Swift中的基本运算

 

一.swift中在张开着力运算时,必须保障多少个参加运算的值得数据类型一致,不然会报错

     因为swift中并未有隐式调换

1 let m = 20
2 let n = 3.44
3 // let result = m + n 错误写法 

2.数据类型的转载

     将Int 转换为 Double  Double(m)

     将Double 转换为 Int Int(n)

1 let a : Double = 2.44
2 let b : CGFloat = 4.55
3 let result1 = a + Double(b)

 

五.逻辑分支

 

一.怎么是逻辑分支?

     分支就是if / witch / 三目运算符 等看清语句

     通过分支语句可以垄断程序的举行流程

 

二.if分支语句

 OC中if的写法 : BOOL –> YES/NO

1  int a = 20
2  if (a > 0) {
3     NSLog(@"a大于0")
4  }
5  
6  if (a) {
7     NSLog(@"a不等于0")
8  }

 Swift和OC的差异

    1. if背后的()能够省略掉

【4858.com】字符串与Array等联谊的利用,字典的利用。    二. swift中从不非0(nil)即真  Bool –> true/false

1 let a = 20
2 if a > 0 {
3     print("a大于0")
4 } else {
5     print("a不大于0")
6 }
7  

三.叁目运算符

     swift中的3目运算符合OC没怎么差距

let result = m > n ? m : n

4.guard的使用

 

     肆.一 guard是斯威夫特贰.0新扩张的语法

 

     4.二 它与if语句格外类似,它陈设的目标是增高程序的可读性

 

     四.三 guard语句必须带有else语句,它的语法如下:

 

         
4.三.一当条件表明式为true时候跳过else语句中的内容,实行语句组内容

 

         
四.三.二尺度表达式为false时候实施else语句中的内容,跳转语句一般是return、break、continue和throw

 1 func online(age : Int , IDCard : Bool , money : Int)  {
 2     guard age >= 18 else {
 3         print("回家叫家长")
 4         return
 5     }
 6     guard IDCard == true else {
 7         print("回家拿身份证")
 8         return
 9     }
10     guard money >= 5 else {
11         print("回家拿钱")
12         return
13     }
14     print("留下来上网")
15 }
16 online(19, IDCard: true, money: 4) 

 

5.switch分支

 

     5.一苹果在swift中对swift中对switch举行了不小的加强

 

     5.2 Swift中switch和OC中switch的差异

          switch中前边的()能够省略

          case甘休之后能够不加break,也不会发生case穿透

         补充:借使愿意发生case穿透,需求在讲话结束之后加上fallthrough

                 在swift中switch的case前边能够跟上两个规格,
并且五个规格以 , 分割 

1 switch sex {
2 case 0, 1:
3     print("正常")
4 default:
5     print("非正常人")
6 }

      伍.3 swift帮忙三种数据类型决断 

 1 //浮点型switch判断
 2 switch m {
 3 case 3.14:
 4     print("m是π")
 5 default:
 6     print("m非π")
 7 }
 8  
 9 //字符串switch判断
10 switch opration {
11     case "+":
12         result = a + b
13     case "-":
14         result = a - b
15     case "*":
16         result = a * b
17     case "/":
18         result = a / b
19 default:
20     print("非法操作")
21 }
22  

剖断距离类型

如何是距离?

     平时我们指的是数字区间:0~10,100~200

swift中的区间常见有三种

     半开半闭区间:0..<十 表示:0~9,不包括10

     闭区间:0…10 表示:0~10

 1 let score = 92
 2 
 3 switch score {
 4 case 0..<60:
 5     print("不及格")
 6 case 60..<80:
 7     print("及格")
 8 case 80..<90:
 9     print("良好")
10 case 90...100:
11     print("优秀")
12 default:
13     print("不合理分数")
14 }
15  

六.循环

 

相近的大循环有:for/while/do while

1.for循环

     一.一 OC中的for循环写法

1   for (int i = 0; i < 10; i++) {
2  
3   }     

     壹.2 swift中的写法 

 1 // 区间遍历 0..<10 0...9
 2 for i in 0..<10 {
 3     print(i)
 4 }
 5 
 6 for i in 0...9 {
 7     print(i)
 8 }
 9  
10 // 如果一个标识符不需要使用, 那么可以通过 _ 来代替
11 for _ in 0..<10 {
12     print("hello world")
13 }

2.while循环

     二.1 OC中的写法

 int a = 20
 while (a) {
 }

     二.2 swift中的写法

          2.二.一while前面包车型客车()能够简简单单

          2.2.2没有非0(nil)即真

1 var i = 10
2 while i > 0 {
3     print(i)
4     i -= 1
5 }

 

3.do while循环

1 // 区别: 不再使用do while --> repeat while
2 var m = 0
3 repeat {
4     print(m)
5     m += 1
6 } while m < 10

 

七.字符串

一.字符串的介绍 

     1.1字符串在别的的支付中动用都是充裕频仍的

 

     壹.二OC和Swift中字符串的不相同

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

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

 

     1.3使用 String 的原因

          String 是一个结构体,质量越来越高

          NSString 是贰个 OC 对象,质量略差

          String 援救直接遍历

          String 提供了 String 和 NSString之间的无缝调换

 

二.字符串的定义

     二.1概念不可变字符串

let str = "hello swift"

     二.二定义可变字符串

var strM = "hello world"
strM = "hello china" 

 

叁.获取字符串的尺寸

     先获取字符集结,再赢得集合的count属性

let length = str.characters.count

 

肆.遍历字符串

for c in str.characters {
    print(c)
}

 

伍.字符串的拼凑

     伍.1字符串之间的拼凑

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

     

     伍.二字符串和其他标志符间的拼接

let name = "lgp"
let age = 18
let height = 1.98
let infoStr = "my name is \(name), age is \(age), height is \(height)"

 

     5.三字符串格式化

          比方时间:0三:0四  假若展现 三 : 四 就不佳.所以必要格式化

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

 

6.字符串的截取

 

     6.1简单的点子是将String转成NSString来行使

          在标志符后加:as NSString就可以

1 // 1.方式一: 将String类型转成NSString类型, 再进行截取
2 // (urlString as NSString) --> NSString
3 let header = (urlString as NSString).substringToIndex(3)
4 let footer = (urlString as NSString).substringFromIndex(10)
5 let range = NSMakeRange(4, 5)
6 let middle = (urlString as NSString).substringWithRange(range)

     陆.一Swift中提供了奇特的截取情势

          该方法分外麻烦

          Index创造较为麻烦

1 // 2.方式二: Swift原生方式进行截取
2 let headerIndex = urlString.startIndex.advancedBy(3)
3 let header1 = urlString.substringToIndex(headerIndex)
4 
5 let footerIndex = urlString.endIndex.advancedBy(-3)
6 let footer1 = urlString.substringFromIndex(footerIndex)
7  
8 let range1 = headerIndex.advancedBy(1)..<footerIndex.advancedBy(-1)
9 let middle1 = urlString.substringWithRange(range1)

 

8.数组的施用

 

一.数组的介绍

     壹.一 数组(Array)是1串有序的由同样体系成分结合的聚合

     壹.二 数组中的会集成分是平稳的,能够重复出现

     一.三 Swift中的数组

          swift数组类型是Array,是多个泛型集结

 

二.数组的开始化

     2.壹 定义不可变数组,使用let修饰  

          注意:不可变数组要在概念的还要开始化,不然没风趣

     let array = ["why", "yz"]    

 

     2.二 定义可变数组,使用var修饰

          注意:数组是泛型集结,必须明显该数组中存放成分的系列

  //基本写法   
  var arrayM = Array<String>()
  //单写法
  var arrayM = [String]()

 

叁.对可变数组的基本操作(增加和删除改查)

     3.一 添美金素

arrayM.append("ljp")    

     3.二 删除成分 

let removeItem = arrayM.removeAtIndex(1)  返回值为删除的元素
arrayM.removeAll()

     3.3 修改元素

arrayM[0] = "why"

     三.四 查找元素(依照下标获取元素)

let item = arrayM[0]

 

四.数组的遍历

     四.1 遍历下标值

1 for i in 0..<array.count {
2     print(array[i])
3 }

     四.3回历成分

for name in array {
    print(name)
} 

      四.叁遍历下标值和要素

1 for (index, name) in array.enumerate() {
2     print(index)
3     print(name)
4 }

 

五.数组的统1

     一样档案的次序的数组能够相加实行统一

     可变数组和不可变的数组也能统一

1 let array1 = ["why", "yz"]
2 let array2 = ["lmj", "lnj"]
3 let resultArray = array1 + array2

 

九.字典的选择

 

1.字典的介绍

     一.一字典允许根据有些键来访问成分

   
 一.二字典是由两片段集合构成的,贰个是键(key)群集,叁个是值(value)会集

   
 壹.三键成团是不可能有双重成分的,而值集结是可以再一次的,键和值是成对出现的

     一.4斯威夫特中的字典

          斯维夫特字典类型是Dictionary,也是2个泛型会集

 

二.字典的开始化

     贰.壹 定义不可变字典,使用let修饰  

          注意:不可变字典要在概念的同时初阶化,不然没风趣

          
 系统会基于[]中存放的是键值对,如故一个个成分,来剖断该[]是三个数组依旧字典 
 

let dict = ["name" : "why", "age" : 18, "height" : 1.88]

    

     二.贰 定义可变字典,使用var修饰

          注意:字典是泛型会集,必须制定该数组中存放成分的种类

     基本写法      

var dictM = Dictionary<String, NSObject>()

     轻松写法   

var dictM = [String : NSObject]() // 常见

 

4858.com,三.对可变字典的基本操作(增加和删除改查)

     叁.一 添美金素

dictM.updateValue("why", forKey: "name")    

     3.二 删除成分 

1 dictM.removeValueForKey("age") 

     3.叁 修改成分

1 //如果原有没有对应的key/value, 那么就添加键值对
2 // 如果原有已经有对应的key/value, 那么直接修改
3 dictM.updateValue("1.77", forKey: "height")
4 dictM["name"] = "why"

     三.肆 查找成分(获取成分)

1 let item = dictM["name"]

 

四.字典的遍历

     肆.一 遍历字典中有着的key

1 for key in dict.keys {
2     print(key)
3 }       

  四.2 遍历字典中存有的value

1 for value in dict.values {
2     print(value)
3 }

      四.3 遍历字典中具有的key / value

1 for (key, value) in dict {
2     print(key)
3     print(value)
4 }

 

5.字典的统1

     同样等级次序的字典也不可能相加进行联合

   
 能够把内部三个字典改为可变的,遍历不可变得字典,把成分一个一个的拉长到另2个不行变字典中

1 let dict1 = ["name" : "why", "age" : 18]
2 var dict2 = ["height" : 1.88, "phoneNum" : "+86 110"]
3 
4 for (key, value) in dict1 {
5     dict2[key] = value
6 }
7  

 

拾.元组的行使

一.元组的介绍

     一.1元组是Swift中特有的,OC中并未有相关项目

     一.二它是哪些啊?

          一.贰.一 它是一种数据结构,在数学中利用广泛

          一.2.二 类似于数组或然字典

          一.二.3 能够用来定义一组数据

          一.二.四 组成元组类型的数码能够叫做“成分”

 

二.怎么选择元组?

   
 假诺字典或数组保存二种数据类型,那么从字典会数组抽取来的数据类型是NSObject,我们运用的时候很不便宜,要先转移为实际类型

   
 元组保存二种数据类型,抽出来正是该数额的真人真事类型,不必要改作育能直接动用

 

三.元组的概念

1 let infoTuple = ("why", 18, 1.88, "+86 110")
2 // 使用元组描述一个人的信息
3 ("1001", "张三", 30, 90)
4 // 给元素加上元素名称,之后可以通过元素名称访问元素
5 (id:"1001", name:"张三", english_score:30, chinese_score:90)

 4858.com 1

 

 

///  2016.12.29

壹. 变量和常量

在 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

斯威夫特 中常用的 option + click,Swift 相比较于
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

 

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

2. 可选项

贰.1 原始的可选项,在头文件的概念中,有四个值
none 没有值
some 某①类值

let x: Optional = 10
print(x)

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

二.二 轻巧的定义
? 来定义叁个可选值,大概有值, 也可能未有

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

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

2.三 可选值的总结
位置说了,不相同品类的值,是不可能展开总括的,要是三个都以可选值是不是能预计呢?
答案是不能够的,因为可选值,有十分大希望是 nil,不能实行总结

let x: Int? = 10

let y: Int? = 20

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

一、字符串 

1、Swift三 ,字符串的简短利用,直接将代码贴过来,更便利查看

注意:

  • 技术员必须为每多个 ! 负责
  • 先后中,一定要少用 !

1、字符串的字面量 ,
举例”jeck”字面量

//  字符串 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

    }

三. 逻辑分支

三.一 简单的道岔,简单的if…else 剖断

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

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

叁.二 3目运算符
与 OC 中的3目运算符 格式同样

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

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

4858.com 2

 贰、数组的简短利用

四. 可挑选的论断

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.三 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

 

// 数组 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 的更多其他用法点进去查看方法文档
    }

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

二、swift中的字符串和OC中的字符串的差异

三、字典的简要利用

6. for 循环

斯维夫特 中,笔者以为 for 循环 改动还是挺多,不过并不影响代码的阅读
陆.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中的字符串没有可变类型和不可变类型之分,在swift中,字符串到底可变不可变,
取决于评释变量的连串,假若定义的是let正是不可变,借使定义的是var正是可变

    // 字典 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)")



    }

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)

七.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))

柒.四 字符串格式化

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

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

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

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

七.伍 字符串子串
利用 NSString 取子串比较便宜

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

Swift中的字符串是值类型 ,
而OC当中,不加特殊注解的话是引用类型,不用思量内存难题,斯威夫特已经办好了优化,

 

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)]

八.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.四 数组的体量

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 ,可以避免每次都要分配空间

捌.伍 数组的联结

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

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

4858.com 3

9 字典

玖.一 字典的定义
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.二 字典的增加和删除改

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"]

九.三 字典的遍历

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)")
}
结果同上

玖.四 字典的联合

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]

 

3、Swift中可变类型和OC中的NSString做了一应俱全的接入,换句话说,便是swiftStrig能够采用NSString的法子

下边简要介绍下String的局地行使方法:

4858.com 4

  

四、字符串插值

 在swift输出语句中尚无格式化占位符,想要落成那样的功效,咱们要用到字符串插值格式:”\()”

4858.com 5

 

二、swift中的集结

swift中的集结和OC中的会集的差别: 

  一、在swift中的集结类也都以值类型,而OC个中的是援引类型

 
二、在swift中,也是选取引用计数的定义来治本内部存款和储蓄器的,不过引用计数只适用于对象类型,值类型不要求管住

 
三、在swift中,引用计数管理内部存款和储蓄器的法子与OC其中引用计数管理内部存款和储蓄器的办法,照旧分裂的
(见前边内容)

 
四、在swift中数组是足以存舍弃意档期的顺序,不过OC中,只好存放对象类型

 

1、数组(Array)

 

 
在swift中,Array也绝非可变和不可变类型之分,而且取决于用什么首要字来修饰,var正是可变,let正是不足变 

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

 

 
当大家先行评释数组桐月素的类型,内部因素必须1致

4858.com 6 

本来大家也得以像上面那样写:

4858.com 7

 

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

(壹)、数组增新币素

4858.com 8

 

(2)、数组删除成分

透过下边面包车型地铁措施来删除钦命下标的成分

4858.com 9

 

(3)、 退换数组中的元素

4858.com 10

  

(四)、数组查询

4858.com 11

 

数组的开头化,评释存款和储蓄固定类型的数组

 

1、

4858.com 12

2、

4858.com 13

 

行使构造方法创设的是由三个特定数据类型构成的数组

 

 

2、字典(Dictionary)

使用字面量来给字典举办赋值

4858.com 14

 

一、字典键值对的充实

4858.com 15

 

二、字典键值对的删除

4858.com 16

 

三、字典键值对的改造

4858.com 17

 

四、字典键值对的询问

4858.com 18

 

打字与印刷结果如下:

4858.com 19

 

字典早先化的主意也有三种

运用字典初叶化格局展开创办的是定点键值类型的字典

 4858.com 20

 

 

斯维夫特和OC中集中相比

在OC中,大家常用的数组和字典都以援引类型,而Swift中是值类型,那是因为在斯维夫特中,这个结合类的后面部分都以struct

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

4858.com 21

 

 

iOS技术沟通群 四六拾697伍七 接待出席 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有