IOS（一）swift知识点速记

注释

单行 //
多行 /* xxxx */
注释嵌套
/* xxx
/* aaaa*/
fff */

打印输出

print("aaa")
不换行输出

for x in 0...10{
    print("\(x) ", terminator: "")
}
//  0 1 2 3 4 5 6 7 8 9 10

打印变量

var name = "name"
var age = "1"

print("\(name)的年龄：\(age)")   //    name的年龄：1

变量类型

Int
UInt
Float
Double
String 一串字母如 “aaa"
Bool true or false
Character 单个字母如"C"
Optional 使用可选类型来处理值可能缺失的情况。可选类型表示有值或没有值。

变量声明

var a = "ddd"
print(a)

常量声明

let a = 1
print(a)

给变量或常量添加类型标注，指定要存储的类型。

var b : Int = 1

可选类型Optional

声明：

var a: Int?   // 简写形式
var b: Optional<Int>    //  全写形式

取值使用！，每次取值需要先判断是否为nil

var myString:String? = nil
if myString != nil {
    print(myString)    //前面做了判断 是否为nil    这里取值可以省略！
 // 或者print(myString!)     严格来写
}else{
    print("字符串为 nil")
}

可选绑定

var myString:String?
myString = "Hello, Swift!"
if let yourString = myString { // 如果myString不为nil就将值给yourString
   print("你的字符串值为 - \(yourString)")
}else{
   print("你的字符串没有值")
}

字面量

整型字面量可以是一个十进制，二进制，八进制或十六进制常量。二进制前缀为 0b，八进制前缀为 0o，十六进制前缀为 0x，十进制没有前缀：

let a = 17           // 17 - 十进制表示
let b = 0b10001       // 17 - 二进制表示
let c = 0o21           // 17 - 八进制表示
let d = 0x11     // 17 - 十六进制表示

布尔型字面量的默认类型是 Bool。布尔值字面量有三个值，它们是 Swift 的保留关键字：

true 表示真。
false 表示假。
nil 表示没有值。

运算符

swift3中取消来 ++ -- 运算符
其他常规运算符
区间运算符

print("闭区间运算符:")
for index in 1...5 {  // 包含1 5
    print("\(index) * 5 = \(index * 5)")
}

print("半开区间运算符:")
for index in 1..<5 {  // 包含1  
    print("\(index) * 5 = \(index * 5)")
}

条件语句

if
if...else
if...else if...else
switch

循环语句

for ...in
注意没有for循环来
while
repeat...while (类似 do while）

repeat
{
   statement(s);
}while( condition );

循环控制

break
continue
fallthrough 如果在一个case执行完后，继续执行下面的case，需要使用fallthrough(贯穿)关键字。

var index = 10
switch index {
   case 100  :
      print( "index 的值为 100")
      fallthrough
   case 10,15  :
      print( "index 的值为 10 或 15")
      fallthrough
   case 5  :
      print( "index 的值为 5")
   default :
      print( "默认 case")
}

字符串

声明

var a = "aaa"
var b = String("bc")
var c = "" //空字符串
var d = String()  // 空字符串

属性

isEmpty 是否为空

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

count 字符串长度

var a = "aaaaa"
print(a.count)

方法

字符串连接 +

var a = "aaa"
a += "ccc"
var b = "bbb"
var c = a + b

字符串中插入值

var a = "aaa"
let b = "bbb"
var c = "cc\(a)dd\(b)"

字符串比较 ==

var varA   = "Hello, Swift!"
var varB   = "Hello, World!"
if varA == varB {
   print( "\(varA) 与 \(varB) 是相等的" )
} else {
   print( "\(varA) 与 \(varB) 是不相等的" )
}

< 比较两个字符串，对两个字符串的字母逐一比较。
!= 比较两个字符串是否不相等。
hasPrefix(prefix: String)检查字符串是否拥有特定前缀
hasSuffix(suffix: String)检查字符串是否拥有特定后缀。
Int(String)转换字符串数字为整型。

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

遍历字符串中字符

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

字符串连接字符

var varA:String = "Hello "
let varB:Character = "G"
varA.append( varB )

数组有序列表存储同一类型的多个值

数组赋给变量则，可以增删修数组元素；如果赋给常量，则数组大小内容都不可更改。

创建数组

var a = [Int]()   //  空数组
var b = [Int](repeating: 0, count: 3) // 类型为 Int ，数量为 3，初始值为 0 
var c:[Int] = [10, 20, 30]

访问数组元素

var a = [Int](repeating: 11, count: 13)
print( "第一个元素的值 \(a)" )
print( "第二个元素的值 \(a[1])" )
print( "第三个元素的值 \(a[2])" )

数组操作

var a = [Int]()
a.append(1) // 增加元素
a += [2] // 增加元素  也可成合并数组
a[1] = 3 // 修改元素

遍历数组

var c:[Int] = [10, 20, 30]
for item in c {
   print(item)
}
for (index, item) in c.enumerated() {
    print("在 index = \(index) 位置上的值为 \(item)")
}

合并数组

var a = [Int](repeating: 2, count:2)
var b = [Int](repeating: 1, count:1)
var c = a + b

数组属性

var a = [Int](repeating: 2, count:2)
print(a.count) // 数组长度
print(a.isEmpty) // 是否为空

字典

用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。
创建字典，赋给变量，则可增删修，赋给常量，则什么都不能变。

创建字典

var a = [Int: String]() // 空字典
var b:[Int:String] = [1:"One", 2:"Two", 3:"Three"] // 有值字典

访问字典

var b:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
print(b[1])// 访问key为1的值
print(b)  // 打印所有

修改字典

var b:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = b.updateValue("One 新的值", forKey: 1) // 存在则更新，不存在则增加
b[2]= "3333"//  直接修改指定key的值

字典内删除元素

var b:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
b.removeValue(forKey: 2) // 方法1
b[2] = nil  // 方法2

字典遍历

var b:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (key, value) in b {
   print("字典 key \(key) -  字典 value \(value)")
}

字典转换为数组，将key单独抽取出来形成数组，将value单独抽取出来形成数组

var b:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
let dictKeys = [Int](b.keys)
let dictValues = [String](b.values)

字典属性

vvar b:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
print(b.count) // 长度
print(b.isEmpty) // 是否为空

元祖

元组与数组类似，不同的是，元组中的元素可以是任意类型，使用的是圆括号。

let a = "22"
let b = 33
let c = (a,b)
print(c.a)
print(c.b)

函数中使用元祖

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("最小值为 \(bounds.min)，组大值为 \(bounds.max)")
}

函数

如果没有显示指定函数返回值，隐式返回值将会是Void。
函数定义和调用

// 定义
func sitename() -> String { // 无参数
    return "大哥"
}
func runoob(site: String) { //  无返回值
    print("\(site)")
}
func runoob(site: String) -> String {
    return (site)
}
// 调用
print(runoob(site: "www.runoob.com"))

函数参数名

局部参数名在函数内部使用，或调用函数时指定参数使用

func sample(number: Int) {   // 这个number就是局部参数名
    print(number)
}
sample(number: 1) // 调用时也用这个

外部参数名在函数调用指定参数名时使用

func pow(firstArg a: Int, secondArg b: Int) -> Int {// 函数体内使用ab
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}
pow(firstArg:5, secondArg:3)  // 函数调用使用firstArg  secondArg

可变参数，可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的。可变参数通过在变量类型名后面加入（...）的方式来定义。

func vari<N>(members: N...){
    for i in members {
        print(i)
    }
}

参数类型：

常量参数函数体内不能改变参数值 func f1(a:String)
变量参数函数体内可以改变参数值 func f2(a: inout String)
IO参数可以改变传入的那个变量的值，调用时使用 f2(&x)

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}
var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")
x 现在的值 5, y 现在的值 1

函数类型，使用函数类型就像使用其他类型一样，可以自己定义函数类型

var addition: (Int, Int) -> Int = sum

定义一个叫做 addition 的变量，参数与返回值类型均是 Int ，并让这个新变量指向 sum 函数。注意，sum 和 addition 要有同样的类型。

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

函数嵌套，指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。

func calcDecrement(forDecrement total: Int) -> () -> Int { // 返回值是函数类型
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer   // 返回值是个函数
}
let decrem = calcDecrement(forDecrement: 30)// decrem是个函数
print(decrem())// 调用函数

本文参考菜鸟教程 swift教程做的笔记
https://www.runoob.com/swift/swift-tutorial.html

转载于:https://www.jianshu.com/p/88d0f2a0d2e8