10000*365=27.3972603

0%

Swift基础01

Posted on Edited on In

常量和变量

使用let关键字来声明常量

1
let temp = 10

使用var关键字来声明变量

1
2
var temp = 0
temp = 10

可以在一行中声明多个变量或常量，用逗号分隔

1
var x=0.1, y=10.1, z=1.0

类型标注

在声明一个变量或常量的时候提供类型标注，来明确变量或常量能够储存值的类型

添加类型标注的方法是在变量或常量的名字后边加一个冒号，再跟一个空格，最后加上要使用的类型名称

可以在一行中定义多个相关的变量为相同类型，用逗号分隔，只要在最后的变量名字后边加上类型标注

1
2
var msg: String
msg = "message"

变量和常量命名

几乎可以使用任何自负，甚至包括Unicode字符

不能包括空白字符、数学符号、箭头、保留的（或无效的）Unicode码位、连线和制表符。也不能以数字开头。

打印常量和变量

print

字符串插值

1
2
let str = "show string"
print("显示str\(str)")

数值类型

整数

8，16，32，64位编码的有符号和无符号整数（例如：UInt8,Int8）

通过min和max属性访问每个整数类型的最小值和最大值

Int，拥有与当前平台的原生字相同的长度；UInt，与平台长度相关的无符号整数。

1
print("UInt8 min \(UInt8.min), UInt8 max \(UInt8.max)")

浮点数

Double 64位浮点数，至少有15位数字的精度

Float 32位浮点数，至少有6位数字的精度

Bool

表示true和false

Swift的类型安全机制会阻止你用一个非布尔量的值替代掉Bool

数值范围

Swift_数值范围

类型别名

类型别名是一个为已存在类型定义的一个可选择的名字
typealias

1
2
typealias AudioSample = UInt8
let sample: AudioSample = 32

Tuple

使用Tuple组合多个值

元组把多个值合并成单一的复合型的值

元组内的值可以是任何类型，而且可以不必是同一类型

1
2
3
let error = (1, "没有权限")
print(error.0)
print(error.1)

元素命名

元组中的每一个元素可以制定对应的元素名称

如果没有制定名称的元素也可以使用下标的方式来引用

1
2
3
let error = (error: 1,  errorMsg: "没有权限")
print(error.error)
print(error.errorMsg)

Tuple修改

用var定义的元组就是可变元组，let定义的就是不可变元组

不管是可变还是不可变元组，元组在创建后就不能增加和删除元素

可以对可变元组的元素进行修改，但是不能改变其类型

Any类型可以改为任何类型

1
2
3
4
var error:(errorCode: Int, errorMsg:Any) = (errorCode: 1, errorMsg: "没有权限")
error.errorCode = 2
error.errorMsg = 3
print(error)

分解

可以将一个元组的内容分解成单独的常量或变量

1
2
3
4
let error = (1, "没有权限")
let (error, errorMsg) = error
print(error)
print(errorMsg)

如果只需要使用其中的一部分数据，不需要的数据可以用下划线_代替

1
2
3
let error = (1, "没有权限")
let (_, errorMsg) = error
print(errorMsg)

作为函数返回值

使用Tuple为函数返回多个值

返回值的Tuple可以在函数的返回类型部分被命名

1
2
3
4
5
func requestWithUrl(url: String) -> (errorCode: Int, errorMsg: String) {
    return (1, "没有权限")
}
let error = requestWithUrl(url: "")
print(error)

Optional

通过在变量类型后面加?表示：这里有一个值，它表示x，或者这里根本没有值

可以通过给可选变量赋值一个nil来将之设置为没有值

在Swift中，nil不是指针，他是值缺失的一种特殊类型，任何类型的可选类项都可以设置成nil而不仅仅是对西那个类型

1
var str : String? = nil

Optional-if

可选项是没法直接食用的，需要用!展开之后才能使用

1
2
3
4
5
var str : String? = "abc"
if str != nil {
    let cont = str!.count
    print(count)
}

Optional-绑定

可以使用可选项的绑定来判断是否包含值，如果包含就把值赋给一个临时的常量或者变量

可选绑定可以与if和while的语句使用来检查可选项内部的值，并赋值给一个变量或常量

同一个if语句中包含多个可选项绑定时，用逗号分隔开即可。如果人一个选项绑定结果是nil或者布尔值为false，那么整个if判断会被看作false

1
2
3
4
5
var str : String? = "abc"
if let actualStr = str {
    let cont = str!.count
    print(count)
}

Optional-隐式展开

有些可选项一旦被设定值之后，就会一直拥有值，在这种情况下，就可以去掉检查的需求，也不必每次访问的时候都进行展开

通过在声明的类型后边添加一个叹号!而非问好来书写隐式展开可选项

隐式展开可选项主要被用于Swift类的初始化过程中

1
2
3
var str : String! = "abc"
let cont = str!.count
print(count)

Optional-可选链

可选项后面加问号

如果可选项不为nil，返回一个可选项结果，否则返回nil

1
2
3
4
5
6
var str : String? = "abc"
let cont = str?.count
if count != nil {
    let lastIndex = count! - 1
    print(lastIndex)
}

字符串

初始化空串

1
2
3
4
5
var emptyString = ""
var anotherEmptyString = String()
if emptyString.isEmpty {
    print(Noting")
}

字面量

字符串字面亮是被双引号"包裹的固定顺序的文本字符

1
var str = "some string"

多行字面量

字多行符串字面量是被三个双引号"""引起来的一系列字符

开始和结束默认不会有换行符

反斜杠只会在代码阅读上方便，输出时没有实际的换行功能\

1
2
3
4
5
6
let str = """var emptyString = "" \
var anotherEmptyString = String() \
if emptyString.isEmpty { \
    print(Noting") \
"""
print(str)

字符串里的特殊字符

转义特殊字符

任意的Unicode标量 

1
2


扩展字符串分隔符

在字符串字面量中放置扩展分隔符来在字符串中包含特殊字符而不让它们真的生效

将字符串放在双引号内并由井号#包裹

如果字符串里有”#则首尾需要两个##(首尾##与包含的”#不一样即可)

如果你需要字符串中某个特殊符号的效果，使用匹配你包裹的#号数量的#号，并在前面添加转义符号\

1
2
let str = #"122\n\n444"#
let str = #"122\#n\n444"#

字符串的可变形

var 可修改
let 不可修改

字符串是值类型

String 值在传递给方法或者函数的时候会被复制过去

赋值给常量和变量的时候也是一样

操作字符

for-in 循环遍历String中的每一个独立的Character

Character类型

String值可以通过传入Character 数组来构造

1
2
3
4
5
for character in "abcdef" {
    print(character)
}
let tempCharacters: [Character] = ["d","f","d","h"]
let str = String(tempCharacters)

字符串拼接

通过加运算符+创建新字符串

使用加赋值符号+=在已经存在的String值末尾追加一个String值

使用String类型的append()方法来给一个String变量的末尾追加character值

字符串插值

\(some) some代表：混合常量、变量、字面量和表达式的字符串面量

1
print(#"1 * 3 = \#(1*3)."#)

字符串索引

每个String值都有相关的索引类型，String.index，它相当于每个Character在字符串重的位置

startIndex属性来访问String中第一个Character的位置。endIndex属性就是String中最后一个字符后的位置

endIndex属性并不是字符串下表脚本的合法实际参数

如果String为空，则startIndex与endIndex相等

使用index(before:)和index(after:)方法来访问给定索引的前后

要访问给定索引更远的索引，你可以使用index(_:offsetBy:)

使用indices属性来访问字符串中每个字符的索引

1
2
3
4
5
6
let hello = "hello"
hello[hello.startIndex]
hello[hello.index(before: hello.endIndex)]
hello[hello.index(after: hello.startIndex)]
let index = hello.index(hello.startIndex, offsetBy: 2)
hello[index]

插入

插入字符，使用insert(_:at:)方法

插入另一个字符串的内容到特定的索引，使用insert(contentsOs:at:)方法

1
2
3
4
var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)

welcome.insert(contentsOf: "ererer", at: welcome.index(before: welcome.endIndex))

删除

移除字符串remove(at:)

移除特定范围的字符串removeSubrange(range)

1
2
3
4
welcome.remove(at: welcome.index(before: welcome.endIndex))

let range = welcome.index(welcome.endIndex, offsetBy: -1)..<welcome.endIndex
welcome.removeSubrange(range)

子字符串

使用下表或者累死prefix(_:)的方法得到的子字符串是SubString类型

SubString拥有String的大部分方法

SubString可以转成String类型

1
2
3
4
let index3 = hello.lastIndex(of: "o") ?? hello.endIndex
let begin = hello[..<index3]

let newHello = String(begin)

字符串比较

字符串和字符相等性(==和==)

前缀相等hasPrefix(_:)

后缀相等hasSuffix(_:)

赋值和算术运算符

一元运算符、二元运算符、三元运算符

赋值运算符不会返回值

如何处理算术结果溢出

在默认情况下，当一个整数赋超过它容量的值时，Swift会报错而不是生成一个无效的数，给我们操作过大或者过小的数的时候提供了额外的安全性

同时提供了三个算术溢出运算符来让系统支持整数溢出的运算

溢出加法&+

溢出减法&-

溢出乘法&*

值溢出

溢出也会发生在有符号整形数值上

对于无符号与有符号整形数值来说，当出现上溢时，它们会从数值所能容纳的最大数变成最小的数。同样，当发生下溢时，它们会从所能容纳的最小数变成最大的数。

合并空值运算符??

合并空值运算符(a??b)如果选项a有值则展开，如果没有值，是nil，则返回默认值b

表达式a必须是一个可选类型。表达式b必须与a的存储类型相同。

实际上它就是相当于三目运算符_?_:_

1
2
3
func addTwoNum(num1: Int?, num2: Int2?) -> Int {
    return (num1 ?? 0) +(num2 ?? 0)
}

区间运算符

闭区间运算符a...b

定义了从a到b的一组范围，并且包含a和b

a的值不能大于b的值

半开区间运算符a..<b

定义了从a到b但不包含b的区间

a的值不能大于b的值，如果a与b的值相等，那返回的区间将会是空的

单侧区间

比如说，一个包含数组所有的元素的区间，从索引2到数组的结束。在这种情况下，你可以省略区间运算符一侧的值。

1
2
3
4
5
6
7
for name in names[2...] {
    print(name)
}

for name in names[...2] {
    print(name)
}

倒序索引

1
2
3
for i in (0..<10>).reversed(){
    print(i)
}

区间运算符在字符串上的运用

1
2
3
4
5
var welcome = "hello,world"
let range = welcome.startIndex...welcome.index(welcome.endIndex, offsetBy: -6)
welcome.removeSubrange(range)

print(welcome)]

区间运算符在比较类型上的运用

1
2
3
4
5
6
7
8
let welcome = "hello,world"
let interval = "a"..."z"

for c in welcome {
    if !interval.contains(String(c)) {
        print("\(c)不是小写字母")
    }
}

位运算符

位取反运算符

位取反运算符(~)是对所有位的数字进行取反操作

位与运算符

位与运算符(&)是对两个数的比特位进行合并。它会返回一个新的数，只有当这两个数都是1的时候才能返回1。

位或运算符

位或运算符(|)是对两个数的比特位进行比较。它会返回一个新的数，只要两个操作位任意一个为1时，那么对应的位数就为1。

位异或运算符

位异或运算符(^))，当两个操作数的对应位不相同时，那么该数对应的位数就为1。

位左移和右移运算符

位左移(<<)和右移运算符(>>)可以吧所有位数的数字向左或向右移动一个确定的位数。

位座椅和右移具有给整数乘以或除以二的效果。将一个数左移一位相当于把这个数翻倍，将一个数右移一位相当于把这个数减半。

无符号整数的唯一操作

用0填充左移或右移后产生的空白位

有符号整数的移位操作

第一位表示整数还是负数（0正数，1负数）

位运算符应用

  • 两个数字交换
  • 求赋符号整形数二进制中1的个数
  • 判断一个整数是否为为2的整数次幂