字符串与Array等集中的利用,基础语法

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

历次学完部分斯维夫特,都发篇文字,记录一下就学收获。多少个目标,
率先是复习一下这一次学的知识点;
说不上是和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 发布

历史

二〇〇玖 年 7 月,苹果开垦者工具部门老总 Chris Lattner字符串与Array等集中的利用,基础语法。 初始开头 Swift编制程序语言的统一筹算工作

用一年时光,实现宗旨架构

Swift 大约历经 四 年的开拓期,2014 年 6 月公布

 

克里斯·拉特纳何许人?

          LLVM 项目标机要发起人与作者之壹

          Clang 编写翻译器的小编

          苹果集团『开荒者工具』部门的牵头

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

          斯维夫特的绝大诸多基础架构均由她一个人实现

 

特点

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

     语法轻易、代码简洁、使用方便

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

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

 

何以设计斯维夫特语言

     让使用开垦更轻松、越来越快、更牢固

     确认保证最终使用具备越来越好的质量

 

Swift初体验

Playground是什么?

从Xcode六开端产出(Swift开首出现)

翻译为:操场/游乐场

对于学习Swift基本语法12分有利于

     所见即所得(连忙查看结果)

     语法脾性产生更动时,能够非常快查看.

 

壹.斯威夫特最主题的语法变化

 

一.导入框架  

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

2.概念标记符

     OC: int a = 20;

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

 

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

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

 

     Swift中定义标记符,必须注解该标记符是变量(var)依然常量(let)

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

             1行内有多条语句 ; 不能够轻巧,   不建议一行写多条语句

 

叁.Swift中的打印    

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

 

二.常量&变量

 

一.什么样是常量和变量?

 

     在斯威夫特中规定:在概念3个标志符时,必须旗帜鲜明表达该标志符是常量如故变量

     使用let来定义常量,定义之后,不可能拓展退换

     使用var来定义变量,定义之后,能够张开修改

 

二.常量个变量的使用注意

 

     在选用中,建议先选取常量,那样更安全,幸免非常的大心修改从前的值

     假设急需修改时,再把常量修改为变量

   
 注意:常量的五指山真面目是,指向的内部存款和储蓄器地址不可能改改,但可以找到内部存款和储蓄器地址对应的靶子,修改对象内部的习性

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

 

3.类型推导

 

一.怎么样是类别推导?

   
 在斯维夫特中,假如在概念标志符的同时一向对其进展赋值,那么系统会自行依照赋的值的数据类型,推导出标志符的类型

     要是定义标记符的还要一直赋值,那么标记符前边的数据类型能够简轻便单

     能够经过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的差异

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

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

3.三目运算符

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

let result = m > n ? m : n

4.guard的使用

 

     4.一 guard是Swift2.0新添的语法

 

     肆.2 它与if语句卓殊类似,它陈设的目标是提高程序的可读性

 

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

 

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

 

         
四.3.二规范表明式为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分支

 

     五.一苹果在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 }

      5.三 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..<10 表示: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循环

     1.壹 OC中的for循环写法

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

     壹.二 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循环

     贰.一 OC中的写法

 int a = 20
 while (a) {
 }

     二.二 swift中的写法

          2.二.1while前面包车型地铁()可以简单

          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.2OC和斯维夫特中字符串的分别

          在OC中字符串类型时NSString,在斯维夫特中字符串类型是String

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

 

     1.3使用 String 的原因

          String 是三个结构体,品质越来越高

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

          String 匡助直接遍历

          String 提供了 String 和 NSString之间的无缝转变

 

2.字符串的概念

     二.1定义不可变字符串

let str = "hello swift"

     二.2定义可变字符串

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

 

三.获得字符串的尺寸

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

let length = str.characters.count

 

四.遍历字符串

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

 

5.字符串的拼凑

     伍.1字符串之间的拼凑

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

     

     5.2字符串和其他标记符间的拼接

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

 

     五.三字符串格式化

          举个例子时间:03:0四  倘若呈现 三 : 四 就不佳.所以须要格式化

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

 

陆.字符串的截取

 

     陆.一轻巧的办法是将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)

     6.1斯维夫特中提供了特殊的截取格局

          该措施要命艰辛

          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)

 

八.数组的采取

 

一.数组的介绍

     一.一 数组(Array)是一串有序的由一样档期的顺序成分结合的聚众

     一.二 数组中的集结成分是板上钉钉的,能够另行出现

     1.三 Swift中的数组

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

 

二.数组的起初化

     2.1 定义不可变数组,使用let修饰  

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

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

 

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

          注意:数组是泛型会集,必须分明该数组中存放成分的品种

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

 

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

     3.一 添美成分

arrayM.append("ljp")    

     三.二 删除成分 

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

     三.三 修改元素

arrayM[0] = "why"

     三.4 查找成分(依照下标获取成分)

let item = arrayM[0]

 

四.数组的遍历

     四.一 遍历下标值

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

     四.1回历成分

for name in array {
    print(name)
} 

      四.3次历下标值和因素

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

 

玖.字典的应用

 

壹.字典的介绍

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

   
 一.2字典是由两某些集结构成的,贰个是键(key)集结,四个是值(value)集合

   
 一.叁键凑合是不可能有再度成分的,而值集结是能够重复的,键和值是成对出现的

     1.4Swift中的字典

          Swift字典类型是Dictionary,也是1个泛型会集

 

2.字典的初阶化

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

          注意:不可变字典要在概念的还要伊始化,不然未有意义

          
 系统会基于[]中存放的是键值对,依然三个个元素,来剖断该[]是一个数组照旧字典 
 

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

    

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

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

     基本写法      

var dictM = Dictionary<String, NSObject>()

     轻易写法   

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

 

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

     3.壹 添法郎素

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

     3.二 删除元素 

1 dictM.removeValueForKey("age") 

     三.三 修改成分

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

     3.4 查找元素(获取成分)

1 let item = dictM["name"]

 

4.字典的遍历

     4.1 遍历字典中具备的key

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

  四.贰 遍历字典中负有的value

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

      四.三 遍历字典中持有的key / value

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

 

5.字典的统1

     一样类别的字典也不能相加进行统壹

   
 能够把内部二个字典改为可变的,遍历不可变得字典,把成分二个3个的充裕到另叁个不行变字典中

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中并从未有关品种

     一.贰它是哪些啊?

          一.二.1 它是壹种数据结构,在数学中动用普遍

          一.2.2 类似于数组或许字典

          一.2.三 能够用于定义一组数据

          一.二.肆 组成元组类型的多少足以称呼“成分”

 

2.为何选取元组?

   
 就算字典或数组保存多样数据类型,那么从字典会数组收取来的数据类型是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)

 澳门葡京备用网址 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

Swift 中常用的 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>>

斯维夫特 中对项目供给12分凶狠
其他例外品种的数据里面,不容许直接运算
斯维夫特 不会做暗中同意的隐式调换,全数的花色分明都以由程序猿担负
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. 可选项

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

let x: Optional = 10
print(x)

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

贰.二 轻便的概念
? 来定义1个可选值,恐怕有值, 也说不定未有

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

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

二.三 可选值的持筹握算
上面说了,分化类其余值,是不能够拓展计算的,假使三个都以可选值是还是不是能揣度呢?
答案是不能够的,因为可选值,有异常的大或然是 nil,无法实行估测计算

let x: Int? = 10

let y: Int? = 20

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

一、字符串 

1、Swift3 ,字符串的简约利用,直接将代码贴过来,更有益查看

注意:

  • 程序猿必须为每三个 ! 负责
  • 先后中,一定要少用 !

一、字符串的字面量 ,
比如”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

    }

三. 逻辑分支

③.1 容易的分段,轻巧的if…else 决断

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

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

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

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

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

澳门葡京备用网址 2

 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 有值,但是打印结果不同,缺点也很明显,就是?? 优先级太低了 使用时候,最好加()

肆.三 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 循环 退换如故挺多,但是并不影响代码的开卷
陆.一 正序遍历

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中,字符串到底可变不可变,
取决于注解变量的花色,借使定义的是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. 字符串

柒.一 字符串的遍历

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

打印结果:
你
要
飞
吗

7.二 字符串长度

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

柒.4 字符串格式化

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

7.五 字符串子串
选取 NSString 取子串相比较方便

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

Swift中的字符串是值类型 ,
而OC当中,不加特殊证明的话是引用类型,不用顾忌内存难题,斯威夫特已经做好了优化,

 

8. 数组

八.1 数组的定义
OC 使用 [] 定义数组, 斯维夫特 一样,不过尚未 @

// 自动推导的结果,[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)]

八.二 数组的遍历

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

澳门葡京备用网址 3

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(字典或然数组)必须遵循以下规则

  • 1品节点是数组/字典
  • 持有目的必须是 NSString,NSNumber 或 NSNull
  • NSArray,NSDictionary 能够嵌套使用
  • 所有的KEY,都是NSString
  • NSNumber 无法为空 或 无穷大

玖.二 字典的增加和删除改

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

玖.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]

 

3、Swift中可变类型和OC中的NSString做了完美的过渡,换句话说,正是swiftStrig能够运用NSString的秘籍

上面简要介绍下String的部分选取办法:

澳门葡京备用网址 4

  

4、字符串插值

 在swift输出语句中尚无格式化占位符,想要落成如此的法力,大家要用到字符串插值格式:”\()”

澳门葡京备用网址 5

 

贰、swift中的集合

swift中的集合和OC中的集结的界别: 

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

 
二、在swift中,也是选用引用计数的定义来管理内部存款和储蓄器的,不过引用计数只适用于对象类型,值类型不供给处理

 
三、在swift中,引用计数管理内存的方法与OC个中引用计数管理内部存款和储蓄器的法子,依然区别的
(见前面内容)

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

 

1、数组(Array)

 

 
在swift中,Array也尚未可变和不足变类型之分,而且取决于用哪些重要字来修饰,var便是可变,let就是不行变 

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

 

 
当我们事先注解数组七月素的门类,内部因素必须1律

澳门葡京备用网址 6 

自然大家也得以像上边那样写:

澳门葡京备用网址 7

 

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

(壹)、数组增法郎素

澳门葡京备用网址 8

 

(贰)、数组删除成分

透过下边面包车型客车不二秘诀来删除内定下标的元素

澳门葡京备用网址 9

 

(3)、 改换数组中的成分

澳门葡京备用网址 10

  

(四)、数组查询

澳门葡京备用网址 11

 

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

 

1、

澳门葡京备用网址 12

2、

澳门葡京备用网址 13

 

使用构造方法成立的是由2个一定数据类型构成的数组

 

 

2、字典(Dictionary)

选取字面量来给字典进行赋值

澳门葡京备用网址 14

 

一、字典键值对的扩大

澳门葡京备用网址 15

 

二、字典键值对的删除

澳门葡京备用网址 16

 

三、字典键值对的改造

澳门葡京备用网址 17

 

肆、字典键值对的询问

澳门葡京备用网址 18

 

打字与印刷结果如下:

澳门葡京备用网址 19

 

字典初步化的方式也有两种

应用字典伊始化方式开始展览创办的是恒久键值类型的字典

 澳门葡京备用网址 20

 

 

Swift和OC中聚焦相比较

在OC中,大家常用的数组和字典都是引用类型,而Swift中是值类型,那是因为在斯威夫特中,这一个结合类的底层都以struct

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

澳门葡京备用网址 21

 

 

iOS工夫交换群 四陆10697伍7 招待到场 

相关文章

发表评论

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

*
*
Website