着力运算符,斯维夫特学习笔记



本章将会介绍

骨干运算符
字符串和字符

斯威夫特 对空格有须要。

 

 

大旨运算符

运算符是反省、改换、合并值的特殊符号或短语。比方,加号(+)将三个数相加(如
let i = ① + 二)。更扑朔迷离的演算例子包含逻辑与运算符 &&(如 if
enteredDoorCode && passedRetinaScan)。

斯维夫特 协理超过三分之二正经 C
语言的运算符,且创新大多特点来压缩常规编码错误。如:赋值符(=)不重临值,避防范把想要判别相等运算符(==)的地点写成赋值符导致的一无可取。算术运算符(+,-,*,/,%等)会检查评定并不允许值溢出,以此来防止保存变量时由于变量大于或小于其项目所能承载的范围时变成的十三分结果。当然允许你利用
Swift 的溢出运算符来达成溢出。

斯威夫特 还提供了 C 语言未有的抒发两数以内的值的区间运算符(a..<b 和
a…b),那便于大家表达二个间隔内的数值。

斯维夫特数据类型

  • Int 也正是NSInteger,依据不相同平台有例外的长短。
  • 无符号类型UInt,尽量不要接纳UInt。
  • 浮点数,Double(陆拾4个人浮点数),Float(三十二人浮点数)。
  • 布尔值,斯维夫特有伍当中坚的布尔(Boolean)类型,叫做Bool。有多个布尔常量true,和False。在OC中为YES,NO.
  • 字符串,String,OC中对应为NSString。
  • 字符,Character,即单个字母。OC中对应为Char。
  • 可选类型,Optional,用来管理值只怕缺点和失误的处境。表示有值或尚未值

上学地点:    或    

学习地方:    或    

壹. 赋值运算符

项目外号

typealias,对近年来类型定义另二个名字。typealias newStr = String

  1. 假设创立的是 OS X
    playground 须求引进 Cocoa;  即便我们想创设 iOS playground 则须求引进UIKit .

  2. 金立或iTouch的宽为320像素,高为480像素,状态栏高为20像素,toobar高为4肆像素,tabbar高为4玖像素,导航栏高为4四像素。

  3. typealias:类型小名对当前的类型定义了另三个名字;

  4. Swfit语言定义后缀?作为命名类型Optional(可选)的简写;

  1. 设若成立的是 OS X
    playground 须求引进 Cocoa;  纵然大家想创设 iOS playground 则必要引入UIKit .

  2. 魅族或iTouch的宽为320像素,高为480像素,状态栏高为20像素,toobar高为44像素,tabbar高为4九像素,导航栏高为44像素。

  3. typealias:类型外号对现阶段的类型定义了另1个名字;

  4. Swfit语言定义后缀?作为命名类型Optional(可选)的简写;

二. 算术运算符 + – * /

类型安全

type safe,Swift会在编写翻译代码时打开项目检查(type checks)

    var optionalInteger: Int?
    //或者
    var optionalInteger: Optional<Int>
    var optionalInteger: Int?
    //或者
    var optionalInteger: Optional<Int>
三. 求余运算符(取模运算符) %

项目揣度

假诺未有显示钦命项目,Swift会使用项目猜想(type
inference)来采用适当的档期的顺序。浮点数会事先推断为Double。

  1. 强制解析:当你规定可选类型确实包涵值之后,你能够在可选的名字背后加一个感慨号(!)来赢得值。
  1. 强制解析:当您鲜明可选类型确实包罗值之后,你能够在可选的名字背后加1个惊讶号(!)来赢得值。
四. 1元负号运算符 –

Swift可选类型

斯维夫特使用 ?
作为命名类型Optional的简写,Optional是一个包罗二种情况的枚举,None和Some(T),用来代表大概或可能没有值。任何项目都能够申明或隐式调换为可选类型,注明时要确保给操作符一个合适的范围。类型和?之间未有空格。以下二种格局万分。

var optionalInt: Int?
var optionalInt2: Optional<Int>

宣示可选变量如未给定起头值,默感觉nil。

    var myString:String?
        myString = "Hello, Swift!"
        if myString != nil {
           // 强制解析
            print( myString! )
        } else {
           print("myString 值为 nil")
        }

注意:使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前,一定要确定可选包含一个非nil的值。
    var myString:String?
        myString = "Hello, Swift!"
        if myString != nil {
           // 强制解析
            print( myString! )
        } else {
           print("myString 值为 nil")
        }

注意:使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前,一定要确定可选包含一个非nil的值。
五. 壹元旦号运算符 +

强制解析

当使用操作符申明时,假使鲜明可选类型包涵值贰个非nil值,能够在变量前边加上!来强制解析(forced
unwrapping)。假诺值为nil则会导致运营时不当。

  1. 机关分析:你能够在宣称可选变量时利用感叹号(!)替换问号(?)。
  1. 机关分析:你能够在宣称可选变量时行使惊讶号(!)替换问号(?)。
陆. 构成赋值运算符 +=

机动分析

声称可选变量时,使用!替换,那样在分析可选变量时就可以绝不增加!,以促成全自动分析。

    var myString:String!
        myString = "Hello, Swift!"
        if myString != nil {
            print(myString)
        } else {
           print("myString 值为 nil")
        }
    var myString:String!
        myString = "Hello, Swift!"
        if myString != nil {
            print(myString)
        } else {
           print("myString 值为 nil")
        }
柒. 比较运算符 == != > < >= <= === !==

注意: Swift也提供恒等(===)和不恒等(!==)那三个相比符来判定多少个对象是或不是引用同三个目的实例。

当元组中的值能够比较时,你也足以利用这一个运算符来比较它们的轻重。比方,因为
Int 和 String 类型的值能够相比较,所以类型为 (Int, String)
的元组也得以被比较。相反,Bool
不能够被相比较,也代表存有布尔类型的元组无法被相比。
相比元组大小会遵照从左到右、逐值相比较的法门,直到开采有三个值不等时停下。假若具备的值都等于,那么这一对元组我们就称它们是相等的。比方:

(1, "zebra") < (2, "apple")   // true,因为 1 小于 2
(3, "apple") < (3, "bird")    // true,因为 3 等于 3,但是 apple 小于 bird
(4, "dog") == (4, "dog")      // true,因为 4 等于 4,dog 等于 dog

在上头的例子中,你可以看来,在第3行中从左到右的可比行为。因为1小于二,所以(①,
“zebra”)小于(二,
“apple”),不管元组剩下的值什么。所以”zebra”小于”apple”未有其他影响,因为元组的可比已经被第一个要素决定了。不过,当元组的率先个要素同样时候,第3个因素将会用作比较-第三行和第一行代码就生出了这么的可比。

注意:
Swift规范库只好相比多少个以内成分的元组比较函数。如若你的元组成分当先八个时,你必要和睦落成比较运算符。

可选绑定�

行使可选绑定(optional
binding)来决断可选类型是还是不是蕴含值,若是带有就把值复制给1个暂且常量或变量。eg:

// 可选绑定
if let myInt = optionalInt {
    print(myInt)
}
  1. 可选绑定:使用可选绑定(optional
    binding)来决断可选类型是或不是带有值,纵然含有就把值赋给三个权且常量恐怕变量。
  1. 可选绑定:使用可选绑定(optional
    binding)来剖断可选类型是或不是包罗值,如若含有就把值赋给一个目前常量或然变量。
8. 三目运算符

叁目运算符的特种在于它是有多少个操作数的运算符,它的花样是 难点 ? 答案 一 :
答案 2。它简洁地球表面明依据 难点建立与否作出二选一的操作。如若 难点创制,重回 答案 一 的结果;反之重临 答案 2 的结果。

Swift 常量�

斯维夫特常量使用重要字let宣示,必须早先值。let constantName = <initial value>

    if let constantName = someOptional {
            statements
       }
    // example :
       var myString : String?
       myString = "Hello, Swift!"
       if let yourString = myString {
           print("你的字符串值为 - \(yourString)")
       } else {
           print("你的字符串没有值")
       }
    if let constantName = someOptional {
            statements
       }
    // example :
       var myString : String?
       myString = "Hello, Swift!"
       if let yourString = myString {
           print("你的字符串值为 - \(yourString)")
       } else {
           print("你的字符串没有值")
       }
九. 空合运算符(Nil Coalescing Operator) a??b

澳门葡京备用网址 ,空合运算符(a ?? b)将对可选类型 a 举办空决断,要是 a
包蕴三个值就举办解封,不然就重返贰个私下认可值 b。表明式 a 必须是 Optional
类型。私下认可值 b 的花色必供给和 a 存款和储蓄值的档期的顺序保持壹致。
空合运算符是对以下代码的简要表明方法:

a != nil ? a! : b

上述代码应用了3目运算符。当可选类型 a
的值不为空时,进行强制解封(a!),访问 a 中的值;反之再次回到私下认可值
b。无疑空合运算符(??)提供了一种尤其优雅的章程去封装条件判定和解封三种表现,显得简洁以及更具可读性。

注意: 如果 a 为非空值(non-nil),那么值 b 将不会被计算。这也就是所谓的短路求值。

上面例子选取空合运算符,达成了在暗中同意颜色名和可选自定义颜色名以内选取:

let defaultColorName = "red"
var userDefinedColorName: String?   //默认值为 nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 的值为空,所以 colorNameToUse 的值为 "red"

userDefinedColorName 变量被定义为三个可选的 String 类型,私下认可值为
nil。由于 userDefinedColorName
是一个可选类型,大家能够利用空合运算符去推断其值。在上八个例子中,通过空合运算符为一个名为colorNameToUse 的变量赋予三个字符串类型开端值。 由于
userDefinedColorName 值为空,由此表达式 userDefinedColorName ??
defaultColorName 再次回到 defaultColorName 的值,即 red。

另壹种景况,分配一个非空值(non-nil)给
userDefinedColorName,再一次实行空合运算,运算结果为封包在
userDefaultColorName 中的值,而非暗许值。

userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 非空,因此 colorNameToUse 的值为 "green"

品种标注

声美赞臣个常量大概变量时候能够选用丰盛项目标注(type
annotation),用于注脚常量可能变量中要存款和储蓄的值的类型。使用办法为在常量只怕变量后增进冒号空格,然后加上项目名称。
var constantName: <data type> = <optional initial value>

  1. 整型字面量能够是一个10进制,二进制,八进制或十6进制常量。
    贰进制前缀为 0b,8进制前缀为 0o,十6进制前缀为
    0x,10进制未有前缀

    let decimalInteger = 17           // 17 - 十进制表示
    let binaryInteger = 0b10001       // 17 - 二进制表示
    let octalInteger = 0o21           // 17 - 八进制表示
    let hexadecimalInteger = 0x11     // 17 - 十六进制表示
    
  2. 注意:Swift中的字母选取的是Unicode编码[1]。Unicode叫做统一编码制,它涵盖了澳大伯明翰文字编码,如粤语、日文、土耳其共和国语等字符,以至是大家在聊天工具中接纳的表情符号
    假如一定要选拔重要字作为标志符,能够在重中之重字左右增加重音符号(`)

  3. 浮点型字面量的暗中同意推导类型为 Swift 标准库类型中的
    Double,表示63个人浮点数。
    10进制浮点型字面量 :一.25e贰 意味着 一.二伍 ⨉ 10^二,相当于12伍.0;一样,一.2五e-2 表示 1.25 ⨉ 10^-贰,也正是 0.0125。
    十6进制浮点型字面量:0xFp二 表示 一伍 ⨉ 二^二,也正是 60;一样,0xFp-二表示 1五 ⨉ 二^-二,也正是 3.75。
    eg:   浮点型字面量允许利用下划线 _
    来巩固数字的可读性,下划线会被系统忽略,由此不会影响字面量的值。同样地,也能够在数字前加
    0,并不会影响字面量的值。

  4. 字符串型字面量:
  1. 整型字面量能够是四个10进制,贰进制,八进制或十6进制常量。
    2进制前缀为 0b,捌进制前缀为 0o,十6进制前缀为
    0x,10进制未有前缀

    let decimalInteger = 17           // 17 - 十进制表示
    let binaryInteger = 0b10001       // 17 - 二进制表示
    let octalInteger = 0o21           // 17 - 八进制表示
    let hexadecimalInteger = 0x11     // 17 - 十六进制表示
    
  2. 注意:斯威夫特中的字母采纳的是Unicode编码[1]。Unicode叫做统一编码制,它包罗了欧洲文字编码,如普通话、日文、印度语印尼语等字符,以致是我们在聊天工具中应用的表情符号
    1旦一定要选拔首要字作为标志符,可以在第3字左右增加重音符号(`)

  3. 浮点型字面量的暗中认可推导类型为 Swift 标准库类型中的
    Double,表示陆拾壹位浮点数。
    10进制浮点型字面量 :一.贰伍e二 象征 壹.25 ⨉ 10^2,也便是1二5.0;同样,一.二五e-二 表示 一.25 ⨉ 10^-2,也正是 0.0125。
    十6进制浮点型字面量:0xFp2 表示 一5 ⨉ 2^二,也正是 60;同样,0xFp-2表示 壹五 ⨉ 二^-二,也正是 三.7伍。
    eg:   浮点型字面量允许使用下划线 _
    来巩固数字的可读性,下划线会被系统忽略,由此不会影响字面量的值。同样地,也足以在数字前加
    0,并不会潜移默化字面量的值。

  4. 字符串型字面量:
十.区间运算符(Range Operators)
  • 闭区间运算符

闭区间运算符(a…b)定义一个包蕴从 a 到 b(包罗 a 和
b)的全数值的区间。a 的值不可能高出 b。 ‌
闭区间运算符在迭代一个距离的有所值时是非常实用的,如在 for-in 循环中:

for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25
  • 半开区间运算符

半开区间运算符(a..<b)定义二个从 a 到 b 但不包罗 b 的间隔。
之所以称为半开区间,是因为该区间涵盖第7个值而不包括最终的值。

半开区间的实用性在于当您采用三个从 0
开始的列表(如数组)时,卓殊便于地从0数到列表的尺寸。

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("第 \(i + 1) 个人叫 \(names[i])")
}
// 第 1 个人叫 Anna
// 第 2 个人叫 Alex
// 第 3 个人叫 Brian
// 第 4 个人叫 Jack

数组有 四 个成分,但 0..<count
只数到三(最终三个因素的下标),因为它是半开区间。

输出

Swift中使用print轮换了原本的println函数来输出常量和变量。在字符串中得以行使\()来插入常量和变量。

<table>
<thead>
<tr class="header">
<th>转移字符</th>
<th>含义</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>\0</td>
<td>空字符</td>
</tr>
<tr class="even">
<td>\\</td>
<td>反斜线 \</td>
</tr>
<tr class="odd">
<td>\b</td>
<td>退格(BS) ,将当前位置移到前一列</td>
</tr>
<tr class="even">
<td>\f</td>
<td>换页(FF),将当前位置移到下页开头</td>
</tr>
<tr class="odd">
<td>\n</td>
<td>换行符</td>
</tr>
<tr class="even">
<td>\r</td>
<td>回车符</td>
</tr>
<tr class="odd">
<td>\t</td>
<td>水平制表符</td>
</tr>
<tr class="even">
<td>\v</td>
<td>垂直制表符</td>
</tr>
<tr class="odd">
<td>\'</td>
<td>单引号</td>
</tr>
<tr class="even">
<td>\&quot;</td>
<td>双引号</td>
</tr>
<tr class="odd">
<td>\000</td>
<td>1到3位八进制数所代表的任意字符</td>
</tr>
<tr class="even">
<td>\xhh...</td>
<td>1到2位十六进制所代表的任意字符</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr class="header">
<th>转移字符</th>
<th>含义</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td>\0</td>
<td>空字符</td>
</tr>
<tr class="even">
<td>\\</td>
<td>反斜线 \</td>
</tr>
<tr class="odd">
<td>\b</td>
<td>退格(BS) ,将当前位置移到前一列</td>
</tr>
<tr class="even">
<td>\f</td>
<td>换页(FF),将当前位置移到下页开头</td>
</tr>
<tr class="odd">
<td>\n</td>
<td>换行符</td>
</tr>
<tr class="even">
<td>\r</td>
<td>回车符</td>
</tr>
<tr class="odd">
<td>\t</td>
<td>水平制表符</td>
</tr>
<tr class="even">
<td>\v</td>
<td>垂直制表符</td>
</tr>
<tr class="odd">
<td>\'</td>
<td>单引号</td>
</tr>
<tr class="even">
<td>\&quot;</td>
<td>双引号</td>
</tr>
<tr class="odd">
<td>\000</td>
<td>1到3位八进制数所代表的任意字符</td>
</tr>
<tr class="even">
<td>\xhh...</td>
<td>1到2位十六进制所代表的任意字符</td>
</tr>
</tbody>
</table>
1一.逻辑运算符(Logical Operators)

逻辑运算符的操作对象是逻辑布尔值

  • 逻辑非(!a)
  • 逻辑与(a && b)
  • 逻辑或(a || b)

Swift字面量

字面量:可以直接了当的提议自身的等级次序并为变量举行赋值的值,如整型字面量、浮点型字面量、字符串型字面量和布尔型字面量。

字符串型字面量的转义

转义字符 含义
\0 空字符
\ 反斜线 \
\b 退格(BS) , 将当前位置移到前一列
\f 换页(FF),将当前位置移到下页开头
\n 换行符
\r 回车符
\t 水平制表符
\v 垂直制表符
单引号
" 双引号
\000 1到3位八进制数所代表的任意字符
\xhh… 1到2位十六进制所代表的任意字符

布尔型字面量私下认可类型为Bool,包罗三个值:true , false着力运算符,斯维夫特学习笔记。 , nil

  1. 位运算符:位运算符用来对二进制位举行操作,~,&,|,^分别为取反,按位与与,按位与或,按位与异或运算,如下表实例:

    p q p & q p | q p ^ q
    0 0 0 0 0
    0 1 0 1 1
    1 1 1 1 0
    1 0 0 1 1
    指定  A = 0011 1100      ;   B = 0000 1101
    
    运算符 描述 图解 实例
    & 按位与。按位与运算符对两个数进行操作,然后返回一个新的数,这个数的每个位都需要两个输入数的同一位都为1时才为1。 (A & B) 结果为 12, 二进制为 0000 1100
    | 按位或。按位或运算符|比较两个数,然后返回一个新的数,这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1,或都为1)。 (A | B) 结果为 61, 二进制为 0011 1101
    ^ 按位异或. 按位异或运算符^比较两个数,然后返回一个数,这个数的每个位设为1的条件是两个输入数的同一位不同,如果相同就设为0。 (A ^ B) 结果为 49, 二进制为 0011 0001
    ~ 按位取反运算符~对一个操作数的每一位都取反。 (~A ) 结果为 -61, 二进制为 1100 0011 in 2’s complement form.
    << 按位左移。左移操作符(<<)将操作数的所有位向左移动指定的位数。

    下图展示了11111111 << 1(11111111 左移一位)的结果。蓝色数字表示被移动位,灰色表示被丢弃位,空位用橙色的0填充。

    A << 2 结果为 240, 二进制为 1111 0000
    >> 按位右移。右移操作符(<<)将操作数的所有位向又移动指定的位数。

    下图展示了11111111 >> 1(11111111 右移一位)的结果。蓝色数字表示被移动位,灰色表示被丢弃位,空位用橙色的0填充。

    A >> 2 结果为 15, 二进制为 0000 1111
  2. 赋值运算:

    运算符 描述 实例
    = 简单的赋值运算,指定右边操作数赋值给左边的操作数。 C = A + B 将 A + B 的运算结果赋值给 C
    += 相加后再赋值,将左右两边的操作数相加后再赋值给左边的操作数。 C += A 相当于 C = C + A
    -= 相减后再赋值,将左右两边的操作数相减后再赋值给左边的操作数。 C -= A 相当于 C = C – A
    *= 相乘后再赋值,将左右两边的操作数相乘后再赋值给左边的操作数。 C *= A 相当于 C = C * A
    /= 相除后再赋值,将左右两边的操作数相除后再赋值给左边的操作数。 C /= A 相当于 C = C / A
    %= 求余后再赋值,将左右两边的操作数求余后再赋值给左边的操作数。 C %= A 相当于 C = C % A
    <<= 按位左移后再赋值 C <<= 2 相当于 C = C << 2
    >>= 按位右移后再赋值 C >>= 2 相当于 C = C >> 2
    &= 按位与运算后赋值 C &= 2 相当于 C = C & 2
    ^= 按位异或运算符后再赋值 C ^= 2 相当于 C = C ^ 2
    |= 按位或运算后再赋值 C |= 2 相当于 C = C | 2
  3. 区间运算符:

    运算符 描述 实例
    闭区间运算符 闭区间运算符(a…b)定义一个包含从a到b(包括a和b)的所有值的区间,b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的,如在for-in循环中: 1…5 区间值为 1, 2, 3, 4 和 5
    半开区间运算符 半开区间(a..<b)定义一个从a到b但不包括b的区间。 之所以称为半开区间,是因为该区间包含第一个值而不包括最后的值。<="" td=""> 1..< 5 区间值为 1, 2, 3, 和 4
  4. 3目运算符:(a ? b : c) -- 如果a为true,值为b,否则为c.

  1. 位运算符:位运算符用来对贰进制位实行操作,~,&,|,^分别为取反,按位与与,按位与或,按位与异或运算,如下表实例:

    p q p & q p | q p ^ q
    0 0 0 0 0
    0 1 0 1 1
    1 1 1 1 0
    1 0 0 1 1
    指定  A = 0011 1100      ;   B = 0000 1101
    
    运算符 描述 图解 实例
    & 按位与。按位与运算符对两个数进行操作,然后返回一个新的数,这个数的每个位都需要两个输入数的同一位都为1时才为1。 (A & B) 结果为 12, 二进制为 0000 1100
    | 按位或。按位或运算符|比较两个数,然后返回一个新的数,这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1,或都为1)。 (A | B) 结果为 61, 二进制为 0011 1101
    ^ 按位异或. 按位异或运算符^比较两个数,然后返回一个数,这个数的每个位设为1的条件是两个输入数的同一位不同,如果相同就设为0。 (A ^ B) 结果为 49, 二进制为 0011 0001
    ~ 按位取反运算符~对一个操作数的每一位都取反。 (~A ) 结果为 -61, 二进制为 1100 0011 in 2’s complement form.
    << 按位左移。左移操作符(<<)将操作数的所有位向左移动指定的位数。

    下图展示了11111111 << 1(11111111 左移一位)的结果。蓝色数字表示被移动位,灰色表示被丢弃位,空位用橙色的0填充。

    A << 2 结果为 240, 二进制为 1111 0000
    >> 按位右移。右移操作符(<<)将操作数的所有位向又移动指定的位数。

    下图展示了11111111 >> 1(11111111 右移一位)的结果。蓝色数字表示被移动位,灰色表示被丢弃位,空位用橙色的0填充。

    A >> 2 结果为 15, 二进制为 0000 1111
  2. 赋值运算:

    运算符 描述 实例
    = 简单的赋值运算,指定右边操作数赋值给左边的操作数。 C = A + B 将 A + B 的运算结果赋值给 C
    += 相加后再赋值,将左右两边的操作数相加后再赋值给左边的操作数。 C += A 相当于 C = C + A
    -= 相减后再赋值,将左右两边的操作数相减后再赋值给左边的操作数。 C -= A 相当于 C = C – A
    *= 相乘后再赋值,将左右两边的操作数相乘后再赋值给左边的操作数。 C *= A 相当于 C = C * A
    /= 相除后再赋值,将左右两边的操作数相除后再赋值给左边的操作数。 C /= A 相当于 C = C / A
    %= 求余后再赋值,将左右两边的操作数求余后再赋值给左边的操作数。 C %= A 相当于 C = C % A
    <<= 按位左移后再赋值 C <<= 2 相当于 C = C << 2
    >>= 按位右移后再赋值 C >>= 2 相当于 C = C >> 2
    &= 按位与运算后赋值 C &= 2 相当于 C = C & 2
    ^= 按位异或运算符后再赋值 C ^= 2 相当于 C = C ^ 2
    |= 按位或运算后再赋值 C |= 2 相当于 C = C | 2
  3. 距离运算符:

    运算符 描述 实例
    闭区间运算符 闭区间运算符(a…b)定义一个包含从a到b(包括a和b)的所有值的区间,b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的,如在for-in循环中: 1…5 区间值为 1, 2, 3, 4 和 5
    半开区间运算符 半开区间(a..<b)定义一个从a到b但不包括b的区间。 之所以称为半开区间,是因为该区间包含第一个值而不包括最后的值。<="" td=""> 1..< 5 区间值为 1, 2, 3, 和 4
  4. 三目运算符:(a ? b : c) -- 如果a为true,值为b,否则为c.

1贰.行使括号来明显优先级

Swift运算符

运算符是八个符号,用户告知编写翻译器推行2个数学或逻辑运算。包蕴

  • 算数运算符
  • 正如运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 间隔运算符(闭区间运算符:...。 半开区间运算符:..<。)
  • 别的运算符(1元加、壹元减、长富运算符)
  • 指南针最优,单目运算优于双目运算。如正负号。
  • 先乘除(模),后加减。
  • 先算术运算,后移动运算,最终位运算。请越发注意:一 << 三 + 2 & 柒等价于 (1 << (3 + 二))&7
  • 逻辑运算最终总计
    运算符类型 运算符 结合方向
    表达式运算 () [] . expr++ expr– 左到右
    一元运算符

    * & + – ! ~ ++expr –expr

    * / %

    + –

    >> <<

    < > <= >=

    == !=

    右到左
    位运算符

    &

    ^

    |

    &&

    ||

    左到右
    三元运算符 ?: 右到左
    赋值运算符 = += -= *= /= %= >>= <<= &= ^= |= 右到左
    逗号 , 左到右
  • 指南针最优,单目运算优于双目运算。如正负号。
  • 先乘除(模),后加减。
  • 先算术运算,后活动运算,最终位运算。请特别注意:1 << 三 + 二 & 柒等价于 (1 << (③ + 二))&柒
  • 逻辑运算最终计算
    运算符类型 运算符 结合方向
    表达式运算 () [] . expr++ expr– 左到右
    一元运算符

    * & + – ! ~ ++expr –expr

    * / %

    + –

    >> <<

    < > <= >=

    == !=

    右到左
    位运算符

    &

    ^

    |

    &&

    ||

    左到右
    三元运算符 ?: 右到左
    赋值运算符 = += -= *= /= %= >>= <<= &= ^= |= 右到左
    逗号 , 左到右

字符串和字符

字符串是比如说”hello,
world”,”albatross”那样的平稳的Character(字符)类型的值的相会。通过String类型来表示。
1个String的剧情能够用许多办法读取,包蕴作为二个Character值的联谊。

Swift 的String和Character类型提供了急速和兼容 Unicode
的秘技供你的代码应用。创设和操作字符串的语法与 C
语言中字符串操作相似,轻量并且易读。
字符串连接操作只要求轻松地因此+符号将多个字符串相连就可以。与 Swift中任何值一样,能或不可能改造字符串的值,取决于其被定义为常量依旧变量。你也得以在字符串内插进度中动用字符串插入常量、变量、字面量表完成更加长的字符串,那样能够很轻易的开创自定义的字符串值,举办展示、存款和储蓄以及打字与印刷。

固然语法简易,但String类型是一种高效、当代化的字符串完毕。
种种字符串都是由编码非亲非故的 Unicode 字符组成,并协理访问字符的有余
Unicode 表示方式(representations)。

注意:
Swift 的String类型与 Foundation NSString类举行了无缝桥接。Foundation
也足以对String实行增添,暴光在NSString中定义的艺术。
那意味,假如您在String中调用那些NSString的不2诀要,将毫无实行转移。

斯维夫特条件语句

语句 描述
if 语句 if 语句由一个布尔表达式和一个或多个执行语句组成。
if…else语句 if 语句后可以有可选的 else 语句, else 语句在布尔表达式为 false 时执行。可用?:代替
if…else if…else 语句 if 后可以有可选的 else if…else 语句, else if…else 语句常用于多个条件判断。
内嵌 if 语句 你可以在 if 或 else if 中内嵌 if 或 else if 语句。
switch 语句 switch 语句允许测试一个变量等于多个值时的情况。

斯威夫特 条件语句

Swift 条件语句

一.字符串字面量

您能够在你的代码中包罗一段预约义的字符串值作为字符串字面量。字符串字面量是由双引号
(“”) 包裹着的全部稳固顺序的文本字符集。
字符串字面量能够用来为常量和变量提供伊始值:

let someString = "Some string literal value"

只顾someString常量通过字符串字面量举行开始化,Swift会估计该常量为String类型。

Swift循环

语句 描述

if 语句

if 语句 由一个布尔表达式和一个或多个执行语句组成。

if…else 语句

if 语句 后可以有可选的 else 语句else 语句在布尔表达式为 false 时执行。

if…else if…else 语句

if 后可以有可选的 else if…else 语句, else if…else 语句常用于多个条件判断。

内嵌 if 语句

你可以在 if 或 else if 中内嵌 if 或 else if 语句。

switch 语句

switch 语句允许测试一个变量等于多个值时的情况。

语句 描述

if 语句

if 语句 由一个布尔表达式和一个或多个执行语句组成。

if…else 语句

if 语句 后可以有可选的 else 语句else 语句在布尔表达式为 false 时执行。

if…else if…else 语句

if 后可以有可选的 else if…else 语句, else if…else 语句常用于多个条件判断。

内嵌 if 语句

你可以在 if 或 else if 中内嵌 if 或 else if 语句。

switch 语句

switch 语句允许测试一个变量等于多个值时的情况。

二.开端化空字符串

要创建三个空字符串作为伊始值,能够将空的字符串字面量赋值给变量,也能够起始化3个新的String实例:

var emptyString = ""               // 空字符串字面量
var anotherEmptyString = String()  // 初始化方法
// 两个字符串均为空并等价。

您能够由此检查其Bool类型的isEmpty属性来推断该字符串是不是为空:

if emptyString.isEmpty {
    print("Nothing to see here")
}
// 打印输出:"Nothing to see here"

循环类型

循环类型 描述
for-in 遍历一个集合里面的所有元素,例如由数字表示的区间、数组中的元素、字符串中的字符。
for 循环 用来重复执行一系列语句直到达成特定条件达成,一般通过在每次循环完成后增加计数器的值来实现。
while 循环 运行一系列语句,如果条件为true,会重复运行,直到条件变为false。
repeat…while 循环 类似 while 语句区别在于判断循环条件之前,先执行一次循环的代码块。类似于do…while。

Swift 循环

Swift 循环

三.字符串可变性

你能够透过将2个特定字符串分配给四个变量来对其张开改换,也许分配给二个常量来保管其不会被改动:

var variableString = "Horse"
variableString += " and carriage"
// variableString 现在为 "Horse and carriage"

let constantString = "Highlander"
constantString += " and another Highlander"
// 这会报告一个编译错误 (compile-time error) - 常量字符串不可以被修改。

巡回调控语句

控制语句 描述
continue 语句 告诉一个循环体立刻停止本次循环迭代,重新开始下次循环迭代。
break 语句 中断当前循环。
fallthrough 语句 如果在一个case执行完后,继续执行下面的case,需要使用fallthrough(贯穿)关键字。
循环类型 描述

for-in

遍历一个集合里面的所有元素,例如由数字表示的区间、数组中的元素、字符串中的字符。

for 循环

用来重复执行一系列语句直到达成特定条件达成,一般通过在每次循环完成后增加计数器的值来实现。

while 循环

运行一系列语句,如果条件为true,会重复运行,直到条件变为false。

repeat…while 循环

类似 while 语句区别在于判断循环条件之前,先执行一次循环的代码块。
循环类型 描述

for-in

遍历一个集合里面的所有元素,例如由数字表示的区间、数组中的元素、字符串中的字符。

for 循环

用来重复执行一系列语句直到达成特定条件达成,一般通过在每次循环完成后增加计数器的值来实现。

while 循环

运行一系列语句,如果条件为true,会重复运行,直到条件变为false。

repeat…while 循环

类似 while 语句区别在于判断循环条件之前,先执行一次循环的代码块。
四.字符串是值类型

Swift 的String类型是值类型
假如您成立了三个新的字符串,那么当其进行常量、变量赋值操作,或在函数/方法中传递时,会进行值拷贝
任何情状下,都会对已有字符串值创制新别本,并对该新别本实行传递或赋值操作。
值类型在 结构体和枚举是值类型 中实行了详细描述。

斯维夫特 暗中同意字符串拷贝的法子确定保障了在函数/方法中传递的是字符串的值。
很明显无论该值来自于何地,都以您独自具备的。
您能够确信传递的字符串不会被涂改,除非您自身去修改它。

在骨子里编写翻译时,Swift编写翻译器会优化字符串的应用,使实际的复制只发生在相对供给的事态下,那象征你将字符串作为值类型的还要能够赢得异常高的属性。

Swift字符串

Swift字符串类型为String

控制语句 描述

continue 语句

告诉一个循环体立刻停止本次循环迭代,重新开始下次循环迭代。

break 语句

中断当前循环。

fallthrough 语句

如果在一个case执行完后,继续执行下面的case,需要使用fallthrough(贯穿)关键字。
控制语句 描述

continue 语句

告诉一个循环体立刻停止本次循环迭代,重新开始下次循环迭代。

break 语句

中断当前循环。

fallthrough 语句

如果在一个case执行完后,继续执行下面的case,需要使用fallthrough(贯穿)关键字。
5.选拔字符

您可因而for-in循环来遍历字符串中的characters属性来获得每三个字符的值:

for character in "Dog!🐶".characters {
    print(character)
}
// D
// o
// g
// !
// 🐶

此外,通过标记二个Character类型并用字符字面量举行赋值,能够建立三个单独的字符常量或变量:

let exclamationMark: Character = "!"

字符串能够通过传递三个值类型为Character的数组作为自变量来初步化:

let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// 打印输出:"Cat!🐱"

字符串成立

var stringA = "I`m string" // 字面量创建
var stringB = String("I`m string too") // String实例化,不推荐

Swift 字符串
开创字符串:你能够由此采取字符串字面量或 String
类的实例来创设一个字符串:

Swift 字符串
开创字符串:您能够经过行使字符串字面量或 String
类的实例来成立一个字符串:

6.连接字符串和字符

字符串能够通过加法运算符(+)相加在协同(或称“连接”)创造三个新的字符串:

let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome 现在等于 "hello there"

您也能够通过加法赋值运算符 (+=)
将几个字符串增加到3个曾经存在字符串变量上:

var instruction = "look over"
instruction += string2
// instruction 现在等于 "look over there"

你能够用append()方法将一个字符附加到一个字符串变量的尾巴:

let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome 现在等于 "hello there!"

空字符串

始建空字符串:

var stringA = "" // 字面量创建
var stringB = String() // String实例化创建

isEmpty可用来判断字符串是或不是为空!

import UIKit

// 使用字符串字面量
var stringA = "Hello, World!"
print( stringA )

// String 实例化
var stringB = String("Hello, World!")
print( stringB )
import UIKit

// 使用字符串字面量
var stringA = "Hello, World!"
print( stringA )

// String 实例化
var stringB = String("Hello, World!")
print( stringB )
七.字符串插值

字符串插值是一种创设新字符串的措施,能够在其间积存常量、变量、字面量和表达式。
您插入的字符串字面量的每壹项都在以反斜线为前缀的圆括号中:

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message 是 "3 times 2.5 is 7.5"

在上面的例子中,multiplier作为(multiplier)被插入到八个字符串常量量中。
当成立字符串施行插值总结时此占位符会被轮换为multiplier实际的值。

multiplier的值也视作字符串中前边表达式的一部分。
该表明式总括Double(multiplier) * 二.5的值并将结果 (七.5) 插入到字符串中。
在这一个事例中,表明式写为(Double(multiplier) *
2.5)并涵盖在字符串字面量中。

注意:
插值字符串中写在括号中的表明式无法包罗非转义反斜杠
(),并且不能够包括回车或换行符。可是,插值字符串可以涵盖其余字面量。

字符串连接

字符串可通过+来连接

空字符串:您能够使用空的字符串字面量赋值给变量或早先化叁个String类的实例来开始值1个空的字符串。
大家得以行使字符串属性 isEmpty 来剖断字符串是或不是为空:

空字符串:你能够使用空的字符串字面量赋值给变量或开头化1个String类的实例来开端值一个空的字符串。
大家可以动用字符串属性 isEmpty 来判别字符串是或不是为空:

8.Unicode

Unicode是二个国际规范,用于文书的编码和代表。
它使您能够用规范格式表示来自任意语言差不多全部的字符,并可以对文件文件或网页那样的表面能源中的字符进行读写操作。
斯维夫特 的String和Character类型是全然相称 Unicode 规范的。

Swift 的String类型是依赖 Unicode 标量 建立的。 Unicode
标量是对应字符或然修饰符的绝无仅有的二壹位数字,比如U+00六一表示小写的拉丁字母(LATIN
SMALL LETTE卡宴 A)(“a”),U+一F4二5表示小鸡表情(FRONT-FACING BABY CHICK)
(“”)。

字符串长度

字符串可通过String.characters.count质量来测算

import UIKit

// 使用字符串字面量创建空字符串
var stringA = ""

if stringA.isEmpty {
   print( "stringA 是空的" )
} else {
   print( "stringA 不是空的" )
}

// 实例化 String 类来创建空字符串
let stringB = String()

if stringB.isEmpty {
   print( "stringB 是空的" )
} else {
   print( "stringB 不是空的" )
}
import UIKit

// 使用字符串字面量创建空字符串
var stringA = ""

if stringA.isEmpty {
   print( "stringA 是空的" )
} else {
   print( "stringA 不是空的" )
}

// 实例化 String 类来创建空字符串
let stringB = String()

if stringB.isEmpty {
   print( "stringB 是空的" )
} else {
   print( "stringB 不是空的" )
}
9. 字符串字面量的特殊字符

字符串字面量能够包括以下特殊字符:

  • 转义字符\0(空字符)\\(反斜线)\t(水平制表符)\n(换行符)\r(回车符)\"(双引号)\'(单引号)
  • Unicode
    标量,写成\u{n}(u为题写),在那之中n为放肆一到五位十陆进制数且可用的
    Unicode 位码。

上边包车型客车代码为各样特殊字符的使用示例。 wiseWords常量包罗了七个双引号。
dollarSign、blackHeart和sparklingHeart常量演示了三种分歧格式的 Unicode
标量:

let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
// "Imageination is more important than knowledge" - Enistein
let dollarSign = "\u{24}"             // $, Unicode 标量 U+0024
let blackHeart = "\u{2665}"           // ♥, Unicode 标量 U+2665
let sparklingHeart = "\u{1F496}"      // 💖, Unicode 标量 U+1F496

字符串相比

字符串通过==来比较是或不是等于

字符串常量:你能够将多少个字符串赋值给一个变量或常量,变量是可修改的,常量是不行修改的。
字符串中插入值:字符串插值是一种营造新字符串的办法,能够在在那之中富含常量、变量、字面量和表明式。
您插入的字符串字面量的每1项都在以反斜线为前缀的圆括号中:

字符串常量:您能够将八个字符串赋值给一个变量或常量,变量是可修改的,常量是不行修改的。
字符串中插入值:字符串插值是一种创设新字符串的措施,可以在其间包罗常量、变量、字面量和表明式。
您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中:

10.总计字符数量

一经想要获得一个字符串中Character值的多寡,可以应用字符串的characters属性的count属性:

let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
// 打印输出 "unusualMenagerie has 40 characters"

注意:
可扩大的字符群集能够组成三个仍然四个 Unicode
标量。那意味着分裂的字符以及同样字符的不一样代表方法只怕须求区别数量的内部存款和储蓄器空间来存储。所以
斯维夫特中的字符在七个字符串中并不一定占用同样的内部存款和储蓄器空间数量。由此在未有拿走字符串的可扩充的字符群的限量时候,就不可能总计出字符串的字符数量。假如你正在管理一个长字符串,必要注意characters属性必须遍历全体的
Unicode 标量,来明确字符串的字符数量。

除此以外部必要要小心的是透过characters属性重临的字符数量并不总是与富含一样字符的NSString的length属性一样。NSString的length属性是采取UTF-16 表示的15个人代码单元数字,而不是 Unicode 可扩展的字符会集。

字符串函数和平运动算符

  1. isEmpty 剖断字符串是或不是为空,再次来到布尔值
  2. hasPrefix(prefix: String) ,检查字符串是不是持有一定后缀
  3. hasSuffix(suffix: String) ,检查字符串是还是不是具备一定后缀。
  4. Int(String) ,转变字符串数字为整型。 实例:
    let myString: String = "256" let myInt: Int? = Int(myString)
  5. String.characters.count ,总结字符串的长短
  6. utf捌 ,您能够经过遍历 String 的 utf八 属性来访问它的 UTF-八 编码
  7. utf1陆 ,您可以透过遍历 String 的 utf8 属性来访问它的 UTF-1六 编码
  8. unicodeScalars 您能够透过遍历String值的unicodeScalars属性来走访它的
    Unicode 标量编码.
    • 连年八个字符串,并重临3个新的字符串
  9. += 连接操作符两边的字符串并将新字符串赋值给左侧的操作符变量

  10. == 推断五个字符串是或不是等于
  11. < 相比较四个字符串,对多个字符串的假名逐一比较。
  12. != 相比较多个字符串�是还是不是不等于。
import UIKit

var varA   = 20
let constA = 100
var varC:Float = 20.0

var stringA = "\(varA) 乘以 \(constA) 等于 \(varC * 100)"
print( stringA )
import UIKit

var varA   = 20
let constA = 100
var varC:Float = 20.0

var stringA = "\(varA) 乘以 \(constA) 等于 \(varC * 100)"
print( stringA )
1一.字符串索引

每3个String值都有贰个涉及的目录(index)类型,String.Index,它对应着字符串中的每3个Character的岗位。

前边提到,区别的字符可能会占领区别数额的内部存款和储蓄器空间,所以要通晓Character的规定地方,就必须从String开头遍历每八个Unicode 标量直到最终。因而,斯维夫特 的字符串不能够用整数(integer)做索引。

利用startIndex属性能够博得一个String的首先个Character的目录。使用endIndex属性可以获取最终二个Character的后二个职务的目录。因而,endIndex属性不可能同日而语八个字符串的实用下标。假诺String是空荡荡,startIndex和endIndex是十三分的。

透过调用 String 的 index(before:) 或 index(after:)
方法,能够立时获得前边或前边的1个目录。您还足以经过调用
index(_:offsetBy:) 方法来博取相应偏移量的目录,那种格局得以幸免频仍调用
index(before:) 或 index(after:) 方法。

你能够运用下标语法来访问 String 特定索引的 Character。

let greeting = "Guten Tag!"
greeting[greeting.startIndex]
// G
greeting[greeting.index(before: greeting.endIndex)]
// !
greeting[greeting.index(after: greeting.startIndex)]
// u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]
// a

使用 characters 属性的 indices
属性会成立1个饱含全体索引的界定(Range),用来在叁个字符串中访问单个字符。

for index in greeting.characters.indices {
   print("\(greeting[index]) ", terminator: "")
}
// 打印输出 "G u t e n   T a g ! "

注意:
您能够动用 startIndex 和 endIndex 属性恐怕 index(before:)
、index(after:) 和 index(_:offsetBy:) 方法在随心所欲一个认可的并依照Collection 协议的等级次序里面,如上文所示是使用在 String
中,您也可以动用在 Array、Dictionary 和 Set中。

swift字符

斯威夫特字符数据类型为Character.Swift无法创造空的Character类型的变量或常量。

遍历字符串中的字符

for ch in "I`m string".characters {
    print(ch)
}

字符串连接:字符串能够透过 + 号来连接。
字符串长度:字符串长度使用 String.characters.count 属性来计量
字符串相比较:能够使用 == 来相比较三个字符串是还是不是等于
Unicode 字符串:Unicode 是3个国际规范,用于文书的编码,斯威夫特 的
String 类型是基于 Unicode建立的。你能够循环迭代出字符串中 UTF-八 与
UTF-16 的编码,实比如下:

字符串连接:字符串可以经过 + 号来接二连三。
字符串长度:字符串长度使用 String.characters.count 属性来测算
字符串相比较:能够运用 == 来相比较多少个字符串是还是不是等于
Unicode 字符串:Unicode 是二个国际标准,用于文书的编码,Swift 的
String 类型是基于 Unicode建立的。你能够循环迭代出字符串中 UTF-8 与
UTF-1陆 的编码,实举例下:

1二.陈设和删除

调用 insert(_:at:) 方法能够在一个字符串的钦定索引插入三个字符,调用
insert(contentsOf:at:) 方法能够在2个字符串的钦点索引插入二个段字符串。

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome 变量现在等于 "hello!"

welcome.insert(contentsOf:" there".characters, at: welcome.index(before: welcome.endIndex))
// welcome 变量现在等于 "hello there!"

调用 remove(at:) 方法能够在二个字符串的钦命索引删除贰个字符,调用
removeSubrange(_:) 方法能够在一个字符串的钦点索引删除1个子字符串。

welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome 现在等于 "hello there"

let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome 现在等于 "hello"

留意: 您能够利用
insert(_:at:)insert(contentsOf:at:)remove(at:)
removeSubrange(_:) 方法在随心所欲二个确认的并根据
RangeReplaceableCollection 协议的档次里面,如上文所示是利用在 String
中,您也能够应用在 Array、Dictionary 和 Set 中。

字符串连接字符

能够采纳String的append(c: Character)来接二连三字符

var char: Character = "A"
stringA.append(char)
print(stringA)
import UIKit

var unicodeString   = "学习教程"

print("UTF-8 编码: ")
for code in unicodeString.utf8 {
   print("\(code) ")
}

print("\n")

print("UTF-16 编码: ")
for code in unicodeString.utf16 {
   print("\(code) ")
}
import UIKit

var unicodeString   = "学习教程"

print("UTF-8 编码: ")
for code in unicodeString.utf8 {
   print("\(code) ")
}

print("\n")

print("UTF-16 编码: ")
for code in unicodeString.utf16 {
   print("\(code) ")
}
一3.相比字符串

Swift 提供了两种艺术来比较文本值:字符串字符相等、前缀相等和后缀相等。

  • 字符串/字符可以用卓越操作符(==)和不对等操作符(!=)

let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
    print("These two strings are considered equal")
}
// 打印输出 "These two strings are considered equal"
  • 前缀/后缀相等
    通过调用字符串的hasPrefix(_:)/hasSuffix(_:)艺术来检查字符串是否具备一定前缀/后缀,四个措施均收到3个String类型的参数,并赶回一个布尔值。

Swift数组

Swift中数组的数据类型为Array,使用有体系表存款和储蓄同一类别的五个值。斯威夫特中的数组成分类型未有限定。

字符串函数以及运算符:

字符串函数以及运算符:

创设数组

var emptyArray = [someType]() // 空数组
var sizeArray = [someType](repeating: 0, count: 3) // 大小为3,初始值为0的数组
var someArray = [1,2,3] // 直接创建
序号 函数/运算符 & 描述
1

isEmpty

判断字符串是否为空,返回布尔值

2

hasPrefix(prefix: String)

检查字符串是否拥有特定前缀

3

hasSuffix(suffix: String)

检查字符串是否拥有特定后缀。

4

Int(String)

转换字符串数字为整型。 实例:

let myString: String = "256"
let myInt: Int? = Int(myString)

 

5

String.characters.count

计算字符串的长度

6

utf8

您可以通过遍历 String 的 utf8 属性来访问它的 UTF-8 编码

7

utf16

您可以通过遍历 String 的 utf8 属性来访问它的 UTF-16 编码

8

unicodeScalars

您可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量编码.

9

+

连接两个字符串,并返回一个新的字符串

10

+=

连接操作符两边的字符串并将新字符串赋值给左边的操作符变量

11

==

判断两个字符串是否相等

12

<

比较两个字符串,对两个字符串的字母逐一比较。

13

!=

比较两个字符串 是否不相等。

序号 函数/运算符 & 描述
1

isEmpty

判断字符串是否为空,返回布尔值

2

hasPrefix(prefix: String)

检查字符串是否拥有特定前缀

3

hasSuffix(suffix: String)

检查字符串是否拥有特定后缀。

4

Int(String)

转换字符串数字为整型。 实例:

let myString: String = "256"
let myInt: Int? = Int(myString)

 

5

String.characters.count

计算字符串的长度

6

utf8

您可以通过遍历 String 的 utf8 属性来访问它的 UTF-8 编码

7

utf16

您可以通过遍历 String 的 utf8 属性来访问它的 UTF-16 编码

8

unicodeScalars

您可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量编码.

9

+

连接两个字符串,并返回一个新的字符串

10

+=

连接操作符两边的字符串并将新字符串赋值给左边的操作符变量

11

==

判断两个字符串是否相等

12

<

比较两个字符串,对两个字符串的字母逐一比较。

13

!=

比较两个字符串是否不相等。

做客数组

据悉数组的索引来访问数组的成分。var someVar = someArray[index]

使用count性能来测算数组成分个数

使用isEmpty品质判别数组是否为空,重回布尔值。

Swift 字符(Character)
斯维夫特 的字符是三个纯净的字符字符串字面量,数据类型为 Character:

Swift 字符(Character)
Swift 的字符是贰个纯净的字符字符串字面量,数据类型为 Character:

修改数组

  • 经过索引来直接改造成分的值
  • 通过append()主意仍旧赋值运算符+=在数组末尾添英镑素。
import UIKit

let char1: Character = "A"
let char2: Character = "B"

print("char1 的值为 \(char1)")
print("char2 的值为 \(char2)")
import UIKit

let char1: Character = "A"
let char2: Character = "B"

print("char1 的值为 \(char1)")
print("char2 的值为 \(char2)")

遍历数组

  • 使用for in 遍历
  • 使用enumerate()主意开始展览数组遍历。

留意:假如想在 Character(字符)
类型的常量中存储更加多的字符,则程序试行会报错。
     斯威夫特 中无法创造空的 Character(字符) 类型变量或常量。
遍历字符串中的字符:斯维夫特 的
String 类型表示一定体系的 Character(字符) 类型值的集纳;
每二个字符值代表2个 Unicode
字符;您可透过for-in循环来遍历字符串中的characters属性来博取每2个字符的值:

小心:假如想在 Character(字符)
类型的常量中积存更加多的字符,则程序试行会报错。
     Swift 中不能够创造空的 Character(字符) 类型变量或常量。
遍历字符串中的字符:Swift 的
String 类型表示一定体系的 Character(字符) 类型值的集纳;
每二个字符值代表三个 Unicode
字符;您可经过for-in循环来遍历字符串中的characters属性来取得每一个字符的值:

统一数组

使用+来统1二种同等等级次序的数组。新数组的档案的次序会从多个数组的数据类型中推断出来。

import UIKit

for ch in "Hello".characters {
   print(ch)
}
import UIKit

for ch in "Hello".characters {
   print(ch)
}

Swift字典

Swift字典用来积存冬日的同样档期的顺序数据的集纳。Swift中的Key和Value的项目没有界定。

字符串连接字符:使用 String 的 append() 方法来达成字符串连接字符:

字符串连接字符:动用 String 的 append() 方法来兑现字符串连接字符:

创设字典

与数组相似。

var emptyDict = [keyType : valueType]() // 空字典
var someDict: [Int : Int] = [1:11, 2: 22] // 字典实例
import UIKit

var varA:String = "Hello "
let varB:Character = "G"

varA.append( varB )

print("varC  =  \(varA)")
import UIKit

var varA:String = "Hello "
let varB:Character = "G"

varA.append( varB )

print("varC  =  \(varA)")

访问字典

透过字典的索引Key来访问数组成分。var someVar = someDict[key]

应用只读属性count算算字典有多少键值对

行使只读属性isEmpty属性来决断字典是不是为空,重返布尔值。

Swift 数组
创办数组:
      能够行使结构语法来成立一个由特定数据类型构成的空数组:
        var someArray = [someType]()

Swift 数组
制造数组:
      能够使用结构语法来创造三个由特定数据类型构成的空数组:
        var someArray = [someType]()

修改字典

  • 经过下标key扩充或修改字典。key存在则修改,key不设有则扩张
  • 通过updateValue(value: Value, forKey key: Key) -> Value?来扩展或退换字典。规则同上。

      成立3个初阶化大小数组的语法:
           var someArray = [someType](count: NumberofElements,
repeatedValues: InitialValue)
      创造三个种类为Int,大小为三,开头值为0的空数组:
           var someInts = [Int](count: 3, repeatedValues: 0)
      创建含有三个因素的数组:
           var someInts:[Int] = [10,20,30]

      创建2个开端化大小数组的语法:
           var someArray = [someType](count: NumberofElements,
repeatedValues: InitialValue)
      创立3个品类为Int,大小为三,开端值为0的空数组:
           var someInts = [Int](count: 3, repeatedValues: 0)
      制造含有多个要素的数组:
           var someInts:[Int] = [10,20,30]

移除Key-Value

  • 通过安装下标key的Value为nil来移除。
  • 通过removeValue(forKey: Key) -> Value?来移除,若key存在则赶回value值,反之重返nil.

走访数组:咱俩得以依赖数组的索引来访问数组的要素:
      var someVar = someArray[index]

走访数组:大家得以依靠数组的索引来访问数组的要素:
      var someVar = someArray[index]

遍历字典

  • 应用for-in循环遍历
  • 使用enumerate()进行遍历,重返字典索引和键值对

for (key , value) in someDict {
    print("\(key):\(value)")
}

for (index , value) in someDict.enumerate() {
    print("\(index):\(value)")
}

修改数组:能够应用 append() 方法恐怕赋值运算符 +=
在数组末尾添比索素,如下所示,大家起头化贰个数组,并向其添              
美金素,也能够通过索引修改数组成分的值。

修改数组:能够选拔 append() 方法或许赋值运算符 +=
在数组末尾添美金素,如下所示,大家初始化三个数组,并向其添              
美金素,也得以因此索引修改数组成分的值。

字典调换为数组

领到字典的键值,并转移为单身的数组。

let arrayKeys = [Int](someDict.keys)
let arrayValues = [Int](someDict.values)

参考:

斯威夫特 教程 |
新手教程

遍历数组:可以使用for-in循环来遍历全部数组中的数据项,要是大家还要须要各样数据项的值和索引值,能够利用
String                 的 enumerate() 方法来举行数组遍历:
              

遍历数组:能够利用for-in循环来遍历全体数组中的数据项,假设大家还要必要各种数据项的值和索引值,能够运用
String                 的 enumerate() 方法来举行数组遍历:
              

import UIKit

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]

for (index, item) in someStrs.enumerate() {
   print("在 index = \(index) 位置上的值为 \(item)")
}
import UIKit

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]

for (index, item) in someStrs.enumerate() {
   print("在 index = \(index) 位置上的值为 \(item)")
}

联合数组:小编们得以采取加法操作符(+)来统一三种已存在的一样种类数组。新数组的数据类型会从八个数组的数据类型中
              估摸出来。
Count属性:能够使用count属性来计量数组成分个数;

集结数组:大家得以行使加法操作符(+)来归并三种已存在的均等档案的次序数组。新数组的数据类型会从多个数组的数据类型中
              猜度出来。
Count属性:能够选拔count属性来总计数组成分个数;

isEmpty属性:能够透过只读属性 isEmpty
来决断数组是不是为空,再次来到布尔值;

isEmpty属性:能够透过只读属性 isEmpty
来决断数组是不是为空,重返布尔值;

相关文章

发表评论

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

*
*
Website