【Swift編程基礎】P9-16-有解無憂

視頻：P9-16 日期：4.27/4.28

P9：while 回圈和 repeat while 回圈

1.while 回圈

2.repeat while 回圈（先運行再判斷）

P10：String 基礎操作

1.獲取字串長度

2.獲取子字串

3.其他常用操作

4.遍歷字串

5.格式化文本輸出

6.類轉義輸出

P11：Array 陣列

1.陣列的定義

2.陣列的基本操作

3.陣列排序

4.陣列過濾

5.陣列比較

6.遍歷陣列

P12：Set 集合

1.集合的定義

2.集合常用操作

3.集合相等判斷

4.集合過濾

5.遍歷集合

P13：Dictionary 字典

1.字典的定義

2.字典的基本操作

3.字典過濾

4.遍歷字典

P14：函式定義、函式引數名稱、assert斷言

1.函式定義

2.函式引數名稱問題

3.assert斷言

P15：guard 陳述句

1.guard 陳述句

2.guard 陳述句和 if 陳述句，在處理可選項系結之間的區別比較

P16：inout 關鍵字、函式型別

1.inout 關鍵字

2.函式型別

P9：while 回圈和 repeat while 回圈

1.while 回圈

var a = 0
var b = true
while (b)
{
	print(a)
	a += 1
	if (a > 5)
	{
		b = false
	}
}
/*
0
1
2
3
4
5
*/

2.repeat while 回圈（先運行再判斷）

var a = 0
var b = true
repeat
{
	print(a)
	a += 1
	if (a>5)
	{
		b = false
	}
}
while(b)
/*
0
1
2
3
4
5
*/

P10：String 基礎操作

1.獲取字串長度

import UIKit

var str = "ABCDEF"

let size = str.count //獲取字串長度，有空格也算
print("字串長度 = " + String(size))
/*
字串長度 = 6
*/

2.獲取子字串

值得注意的是，String型別的索引，不是Int型別，而是一個String.Index.

import UIKit

var str = "ABCDEF"

//獲取第一個字串str[str.startIndex]回傳的是一個字串，然后用String()轉成字串了
print("獲取ABCDEF種第一個字串 = " + String(str[str.startIndex]))
//print(str[str.endIndex])//這樣不能獲取最后一個字符
//注意str.index()方法，里面引數是before,而 str.endIndex表示結尾，那么傳給before,表示結尾位置的前一個位置，是字串的最后一個字符位置
print("獲取ABCDEF中最后一個字串 = " + String(str[str.index(before: str.endIndex)]))
//下面代碼就會越界例外，因為str.index表示字串結尾位置，傳給after表示結尾位置的后一個位置，都超過整個字串了，所以報錯
//print(String(str[str.index(after:str.endIndex)]))
print("獲取ABCDEEF中索引為4的字串 = " + String(str[str.index(str.startIndex,offsetBy:4)]))
print("獲取ABCDEF中，開始位置的后一位的字串 = " + String(str[str.index(after:str.startIndex)]))
print("獲取ABCDEF中，結束位置的前一位的字串 = " + String(str[str.index(before:str.endIndex)]))
print("獲取ABCDEF中，從0位置開始，長度為4的子字串 = " + String(str.prefix(4)))
print("獲取ABCDEF中，從0位置開始，長度為4的子字串 = " + String(str.prefix(upTo: str.index(str.startIndex,offsetBy: 4))))

let inde = str.firstIndex(of: "E") ?? str.endIndex//回傳第一次出現的E索引
print("獲取ABCDEF中，從起始位置開始，到E結束的字串 = " + String(str[str.startIndex...inde]))
let inde2 = str.index(str.endIndex,offsetBy:-2)
print("獲取ABCDEF中，后2位的字串 = " + String(str[inde2..<str.endIndex]))

let a = str.index(str.startIndex,offsetBy: 2)
let b = str.index(str.startIndex,offsetBy: 4)
print("獲取ABCDEF中，索引為2到4的字串 = " + String(str[a...b]))
/*
獲取ABCDEF種第一個字串 = A
獲取ABCDEF中最后一個字串 = F
獲取ABCDEEF中索引為4的字串 = E
獲取ABCDEF中，開始位置的后一位的字串 = B
獲取ABCDEF中，結束位置的前一位的字串 = F
獲取ABCDEF中，從0位置開始，長度為4的子字串 = ABCD
獲取ABCDEF中，從0位置開始，長度為4的子字串 = ABCD
獲取ABCDEF中，從起始位置開始，到E結束的字串 = ABCDE
獲取ABCDEF中，后2位的字串 = EF
獲取ABCDEF中，索引為2到4的字串 = CDE
*/

3.其他常用操作

//其他常用操作
import UIKit

var str = "ABCDEF"

//判斷是否包含某個字串
print("判斷ABCDEF是否包含某個字串 = " + String(str.contains("ABC")))
print("判斷ABCDEF是否包含某個字串 = " + String(str.contains(where:String.contains("BK"))))//只要一個字符在str中，就回傳true
print("判斷ABCDEF是否包含某個字串前綴 = " + String(str.hasPrefix("AB")))//只要一個字符在str中，就回傳true
print("判斷ABCDEF是否包含某個字串后綴 = " + String(str.hasSuffix("EF")))//只要一個字符在str中，就回傳true

str.append("GHIJK") //在原來的字串中追加字串
print("在原來的字串中追加字串 = " + str)

str.insert(contentsOf:"hello",at:str.index(str.startIndex,offsetBy:2))//在原來的字串中，索引為2的位置插入新字串
print("在原來字串中索引為2的位置插入新字串 = " + str)

let index1 = str.index(str.startIndex,offsetBy:1)
let index2 = str.index(str.startIndex,offsetBy:3)
let range = index1...index2
str.replaceSubrange(range,with:"123")//替換原字串1-3的索引位置
print("將原來字串中索引為1-3的位置，替換成字串123 = " + str)

var new_value = str.replacingOccurrences(of:"IJ", with: "888")
print("在原來字串中索引為2的位置插入新字串 = " + new_value)

str.remove(at:str.index(str.startIndex,offsetBy:2))
print("洗掉原來字串中的索引為2位置的字串 = " + str)
str.removeSubrange((str.index(str.startIndex,offsetBy: 1)...(str.index(str.startIndex,offsetBy: 3))))
print("洗掉原來字串中的索引為1-3位置的字串 = " + str)
/*
判斷ABCDEF是否包含某個字串 = true
判斷ABCDEF是否包含某個字串 = true
判斷ABCDEF是否包含某個字串前綴 = true
判斷ABCDEF是否包含某個字串后綴 = true
在原來的字串中追加字串 = ABCDEFGHIJK
在原來字串中索引為2的位置插入新字串 = ABhelloCDEFGHIJK
將原來字串中索引為1-3的位置，替換成字串123 = A123lloCDEFGHIJK
在原來字串中索引為2的位置插入新字串 = A123lloCDEFGH888K
洗掉原來字串中的索引為2位置的字串 = A13lloCDEFGHIJK
洗掉原來字串中的索引為1-3位置的字串 = AloCDEFGHIJK
*/

4.遍歷字串

import UIKit

var str = "ABCDEF"

//第一種方法，直接遍歷
for value in str
{
    print(value)
}
print("\n")
//第二種方法，利用索引
for index in 0..<str.count
{
    print(String(str[str.index(str.startIndex,offsetBy: index)]))
}
print("\n")
//反向遍歷
for index in (0..<str.count).reversed()
{
    print(String(str[str.index(str.startIndex,offsetBy: index)]))
}
/*
A
B
C
D
E
F


A
B
C
D
E
F


F
E
D
C
B
A

*/

5.格式化文本輸出

var value = """
                hello
                    swift
            world
            """
print(value)
/*
    hello
        swift
world

*/

6.類轉義輸出

var value = #""hello""#
print(value)
var value2 = #""he""llo""#
print(value2)
/*
"hello"
"he""llo"
*/

P11：Array 陣列

1.陣列的定義

import UIKit 

var array:Array<Int> = [] //定義可以存放Int型別的空陣列
print(array)
print("--------------------")

var arra1 = [Int]()	//通過初始化器，定義可變的空陣列
arra1.append(1)
arra1.append(2)
arra1.append(3)
print(arra1)
print("--------------------")

let arra2 = [4,5,6]	//用let定義的常量，不可變陣列，不能改變長度和資料，但是可以取值
//arra2.append(7) //報錯，不能添加
//arra2[0] = 10 //報錯，無法修改
print(arra2)
print("--------------------")

var arra3 = Array(repeating:-1,count:3) //通過Array初始化器，生成一個，初始值為-1，長度為3的陣列
print(arra3)
arra3.replaceSubrange((0..<arra3.count),with:[7,8,9]) //全部替換成7，8，9
print(arra3)
print("--------------------")

//簡單定義陣列的方式-型別推斷
var a = [1,2,3,4]
print(a)
//定義陣列元素型別是String的定義方式
var b:[String] = ["hello","world"]
print(b)
//Double
var c:Array<Double> = [1.4,1.6]
print(c)

c[0] = 12.5    //修改陣列Array的值

print(c[0])    //直接索引陣列的值
print(c[1])

/*
[]
--------------------
[1, 2, 3]
--------------------
[4, 5, 6]
--------------------
[-1, -1, -1]
[7, 8, 9]
--------------------
[1, 2, 3, 4]
["hello", "world"]
[1.4, 1.6]
12.5
1.6
*/

2.陣列的基本操作

import UIKit
var array = ["hello","world","swift"]
print(array.count)	//獲取陣列長度
var value = array[0]	//通過索引獲得array陣列中的第一個資料

print(value)
array[1] = "apple"	//通過索引修改相應資料
print(array)

array.append("ipone")	//在結尾處添加新資料
print(array)
array.insert("macbook",at:2)	//在指定索引位置插入新資料
print(array)

array.replaceSubrange((1...3),with:["macos","windows"])
//將陣列索引1，2，3位置的資料，替換成后面{"macos","windows"]資料
print(array)
array.replaceSubrange((0..<1),with:["android","linux"])
//將陣列索引位置為0的資料替換為后面["android","linux"]資料
print(array)

var new_array = array + ["win10","win7"]//用+拼接陣列，回傳新陣列
print(new_array)
new_array.remove(at:0) //洗掉指定索引位置上的資料
print(new_array)
var b = new_arrray.contains("macos")	//陣列中是否包含指定資料
print(b)

/*
3
hello
["hello", "apple", "swift"]
["hello", "apple", "swift", "ipone"]
["hello", "apple", "macbook", "swift", "ipone"]
["hello", "macos", "windows", "ipone"]
["android", "linux", "macos", "windows", "ipone"]
["android", "linux", "macos", "windows", "ipone", "win10", "win7"]
["linux", "macos", "windows", "ipone", "win10", "win7"]
true
*/

3.陣列排序

var array = ["A","C","D","B","F","E"]
//正序排序
array.sort(by:{(item1,item2) -> Bool in
			   if (item1 > item2)
			   {
				   return false
			   }
			   else
			   {
				   return true
			   }
			})
print(array)
//倒序排序
array.sort(by:{(item1,item2) -> Bool in
			   if (item1 > item2)
			   {
				   return true
			   }
			   else
			   {
				   return false
			   }
			})
print(array)
/*
["A", "B", "C", "D", "E", "F"]
["F", "E", "D", "C", "B", "A"]
*/

4.陣列過濾

//陣列過濾
var array = [2,3,1,5,9,7]

//過濾陣列，回傳新的陣列
var array2 = array.filter({(item) -> Bool in 
							if (item > 5 )
						   {
							   return true
						   }
						   else
						   {
							   return false
						   }
						  })
print(array) //保留了大于5的值
print(array2)
/*
[2, 3, 1, 5, 9, 7]
[9, 7]
*/

5.陣列比較

var array1 = [1,2,3]
var array2 = [1,2,3]

if (array1 == array2)	//判斷陣列順序內容和長度是否相等
{
	print("array1與array2相等")
}
else
{
	print("array1與array2不相等")
}

var array3 = [1,2,3]
var array4 = [1,2]

if (array3 == array4)	//判斷陣列順序內容和長度是否相等
{
	print("array3與array4相等")
}
else
{
	print("array3與array4不相等")
}
	
/*
array1與array2相等
array3與array4不相等
*/

6.遍歷陣列

//遍歷
var array = ["A","B","C","D"]

print("// 1 直接取值遍歷")
//查看遍歷陣列
for item in array
{
	print(item)
}
print("// 2 通過區間運算子直接取值遍歷")
//利用區間運算子0...配合回圈直接獲取陣列里的值
//這里需要注意的是0...雖然表示0到無限大，但是在陣列內，就表示0..<array.count
for item in array[0...]
{
	print(item)
}
print("// 3 利用區間運算子控制范圍直接取值遍歷")
for item in array[0...]
{
	print(item)
}
print("// 4 通過區間運算子獲取索引遍歷")
//通過索引遍歷資料
for index in 0..<array.count
{
	print(array[index])
}
print("// 5 通過區間運算子獲取索引，反向遍歷")
//反向遍歷陣列
for index in (0..<array.count).reversed()
{
	print(array[index])
}
	
/*
// 1 直接取值遍歷
A
B
C
D
// 2 通過區間運算子直接取值遍歷
A
B
C
D
// 3 利用區間運算子控制范圍直接取值遍歷
A
B
C
D
// 4 通過區間運算子獲取索引遍歷
A
B
C
D
// 5 通過區間運算子獲取索引，反向遍歷
D
C
B
A
*/

P12：Set 集合

注意，swift中集合也是無序的，

1.集合的定義

//定義set集合
var a:Set = ["hello","world","swift"] //通過數字創建一個Set型別的集合
print(a)
var b:Set<Int> = [1,2,3] //通過陣列創建一個Set型別的集合，并且明確指定Set集合里面的資料是Int型別
print(b)
let c:Set = ["a","b","c"] //創建不可修改的Set集合
print(c)
var d:Set<String> = [] //創建空Set集合
print(d)
/*
["hello", "swift", "world"]
[2, 3, 1]
["b", "c", "a"]
[]
*/

2.集合常用操作

var set_list:Set = ["hello","world","swift"]
print(set_list.count) //獲取長度
set_list.insert("ios") //添加新資料
print("set_list :" , set_list)
var b = set_list.contains("ios") //是否包含某個資料
print(b)
set_list.remove("hello") //洗掉某個資料
print("set_list去掉hello :" , set_list)

let data:Set = ["iphone","android","ios","swift"]
print("data = ",data)
//union()函式--取并集
var new_set1 = set_list.union(data) //將兩個Set合并，回傳新的Set
print("并集：", new_set1)
//intersection()函式--取交集
var new_set2 = set_list.intersection(data) //回傳兩個Set中相同的資料
print("交集: ", new_set2)
//symmetricDifference()函式--取不同的值
var new_set3 = set_list.symmetricDifference(data)//回傳兩個Set中不同的資料
print("取不同的值 :" , new_set3)
//subtracting()函式--回傳前面set中與后面set不同的值
var new_set4 = set_list.subtracting(data) //兩個set比較，回傳前面Set中與后面Set中不同的資料
print("前面set中與后面set不同 : " , new_set4)
/*
3
set_list : ["world", "swift", "hello", "ios"]
true
set_list去掉hello : ["world", "swift", "ios"]
data =  ["swift", "android", "iphone", "ios"]
并集： ["world", "iphone", "swift", "ios", "android"]
交集:  ["swift", "ios"]
取不同的值 : ["world", "iphone", "android"]
前面set中與后面set不同 :  ["world"]
*/

3.集合相等判斷

var a:Set = ["A","B"]
var b:Set = ["B","A"]

if (a == b)
{
	print("兩個集合相等")
}
else
{
	print("兩個集合不相等")
}
//因為是無序的，所以即使順序不一樣，只要元素相同，集合仍然是相等的，
/*
兩個集合相等
*/

4.集合過濾

//Set過濾
var set_list:Set = ["A","B","C","D"]
var new_set = set_list.filter({(item) -> Bool in
				if(item == "B" || item == "D") //過濾掉B和D
		                {
				    return false
				}
				else
			        {
				    return true
				}
			})
print(new_set)
/*
["C", "A"]
*/

5.遍歷集合

//因為Set無序，所以不能用索引進行遍歷

var set_list:Set = ["A","B","C","D"]
for item in set_list
{
	print(item)
}
/*
A
C
B
D
*/

P13：Dictionary 字典

1.字典的定義

var dic1:Dictionary<String,String> = ["a":"apple","b":"back","c":"call"] //指定鍵值對型別
print(dic1)
var dic2 = [1:"ios",2:"android",3:"windows"] //鍵值對型別推斷
print(dic2)
var dic3:[Int:String] = [1:"ios",2:"android",3:"windows"]//指定型別
print(dic3)
var dic4:Dictionary<Int,String> = [Int:String]() //空字典
print(dic4)
var dic5 = [Int:String]() //空字典
print(dic5)
let dic6 = ["a":"A","b":"B","c":"C"] //空字典
print(dic6)
/*
["b": "back", "a": "apple", "c": "call"]
[2: "android", 3: "windows", 1: "ios"]
[2: "android", 1: "ios", 3: "windows"]
[:]
[:]
["a": "A", "c": "C", "b": "B"]
*/

2.字典的基本操作

//字典基本操作
var dic = ["a":"A","b":"B","c":"C"]
print(dic.count) //獲得長度
print(dic)
dic["a"] = "apple" //修改鍵對應的值
print(dic)
dic.updateValue("background",forKey:"b") //更新鍵對應的值
print(dic)
dic.updateValue("dicionary",forKey:"d") //如果key不存在就添加新的鍵值對
print(dic)

//可選項系結，前面關于if陳述句的章節中介紹過，就不解釋了
//簡單來說如果有指定的key就回傳值，賦給item，執行if陳述句，如果沒有key就回傳nil，不執行if陳述句
if let item = dic["c"]
{
	print(item)
}
dic.removeValue(forKey:"c") //洗掉某個key對應的值
print(dic)
/*
3
["c": "C", "b": "B", "a": "A"]
["c": "C", "b": "B", "a": "apple"]
["c": "C", "b": "background", "a": "apple"]
["b": "background", "d": "dicionary", "a": "apple", "c": "C"]
C
["d": "dicionary", "a": "apple", "b": "background"]
*/

3.字典過濾

//過濾
var dic = ["a":"A","b":"B","c":"C"]
//過濾字典集合，回傳新的字典集合
var new_dic = dic.filter({(key,value) -> Bool in
			if (key != "b")
			{
				return true
			}
			else
			{
				return false
			}
		})
print(new_dic)
/*
["a": "A", "c": "C"]
*/

4.遍歷字典

var dic = ["a":"A","b":"B","c":"C"]
//直接遍歷
for (key,value) in dic
{
	print("key = " + key + "value = " + value)
}
/*
key = avalue = A
key = bvalue = B
key = cvalue = C
*/

P14：函式定義、函式引數名稱、assert斷言

1.函式定義

import UIKit
//不帶引數直接定義
func test()
{
    print("test()hhh")
}
test()
//不帶引數回傳指定Int型別
func test2() -> Int
{
    return 100
}
print(test2())
//帶String引數回傳指定String型別
func test3(name:String) -> String
{
    return name
}
print(test3(name:"hello world"))
//帶String型別的很多個引數，不指定回傳型別
func test4(name:String...)
{
    for item in name
    {
        print(item)
    }
}
test4(name:"a","b",String(3))

//下面這種情況報錯，不能有多個...的型別，只能有一個
/*
func test5(name:String...,n:Int...)
{
    for item in name
    {
        print(item)
    }
}
test5(name:"a","b",String(3),n:1,2)
 */

//傳人陣列型別的引數，傳出陣列型別的引數，進行索引操作輸出
func test5(name:(n1:String,n2:Int)) -> (String,Int)
{
    var value:(a:String,b:Int)
    value.a = name.n1 + "world"
    value.b = name.n2 + 10
    return value
    
}
var value = test5(name:("hello ",20))
print(value.0)
print(value.1)

/*
test()hhh
100
hello world
a
b
3
hello world
30
*/

2.函式引數名稱問題

import UIKit

//outname是外部呼叫名，inname是內部使用名，用空格分隔，與回傳值無關
//且兩個name的值完全相等，只是用的位置不同
func test(outname inname:String)
{
    print(inname)
}
test(outname:"hello")

//若不穿入outname，可以直接用下劃線代替，但是在呼叫函式的時候就不能傳入outname了，會報錯
/*
func test2(_ inname:String)
{
    print(inname)
}
test2(outname:"swift")
*/
//應該改成：
func test2(_ inname:String) //表示忽略outname
{
    print(inname)
}
test2("swift") //在這里直接傳值就ok
//也不能寫 test2(inname:"swift") 不能直接傳入內部名稱
//也不能寫 func test2(outname _:String) 不能忽略inname

//正常使用：
func test3(outn1 inn1:String, outn2 inn2:Int)
{
    print(inn1,inn2)
}
test3(outn1: "aaaaa", outn2: 123456)

/*
hello
swift
aaaaa 123456
*/

3.assert斷言

//assert斷言：
//assert函式可以讓程式停止運行
import UIKit
func play(param:Int)
{
    if (param<10)
    {
        assert(false , "停止運行")
    }
    print("值 = " + String(param))
}

play(param: 10) //程式沒有停止運行
play(param: 5)  //整個程式停止運行
/*
值 = 10
Assertion failed: 停止運行: file __lldb_expr_1/MyPlayground1.playground, line 43
*/

P15：guard 陳述句

1.guard 陳述句

import UIKit

//guard陳述句就是一個進行攔截的guard+else+return 陳述句
func test1(param:Int)
{
    guard (param < 5) else
    {
        print("進入guard陳述句，param = " + String(param))
        return
    }
    print("沒有進入guard陳述句，param = " + String(param))
}
test1(param: 10) //沒有進入guard陳述句
print()
test1(param: 3)  //進入guard陳述句
print("--------------------------------")
//與if陳述句進行對比
func test2(param:Int)
{
    if (param < 5)
    {
        print("進入if陳述句，param = " + String(param))
    }
    else
    {
        print("進入if else 陳述句，param = " + String(param))
        return  //進入if else 陳述句之后就return了，后面的就不會再執行了
    }
    print("在 if 陳述句外部")  //進入if陳述句后沒有return 還是會繼續執行
}
test2(param: 10)
print()
test2(param: 3)
/*
進入guard陳述句，param = 10

沒有進入guard陳述句，param = 3
--------------------------------
進入if else 陳述句，param = 10

進入if陳述句，param = 3
在 if 陳述句外部
*/

2.guard 陳述句和 if 陳述句，在處理可選項系結之間的區別比較

guard 陳述句也可以用 if 陳述句寫

import UIKit
//優點：進行空值判斷，如果變成了空值就進行攔截
var a:String? = "swift"
var b:String? = nil

func test1(param:String?)
{
    guard let value = param else
    {
        print("進入guard陳述句里")
        return //進行攔截
    }
    print(value)
}
test1(param: a)
//如果a有值就把a的值傳給param，如果param有值就不攔截，如果value沒值就被攔截
test1(param: b)
//因為b沒值，所以進入guard陳述句進行攔截
/*
swift
進入guard陳述句里
*/

P16：inout 關鍵字、函式型別

1.inout 關鍵字

相當于把值傳遞變為傳“參考”

（別忘記inout 和 &）

import UIKit

//在一般情況下不能直接使用傳入函式的引數param，會報錯，例如：
/*
func test(param:Int)
{
    param = param * 2 //Cannot assign to value: 'param' is a 'let' constant
    print(param)
}
test(10)  //Missing argument label 'param:' in call
*/

//但是inout關鍵字可以幫助我們使用傳入引數本身：
func test2(param: inout Int)
{
    param = param * 2
    print(param)
}
var a = 10
print("傳遞前 a = " + String(a))
test2(param: &a)
print("傳遞后 a = " + String(a))
/*
傳遞前 a = 10
20
傳遞后 a = 20
*/

2.函式型別

函式型別的定義

//定義幾個函式型別
var a:() -> Void  //最好帶上Void，否則()可能會被誤解為定義了一個元組

var b:(Int,String) -> String

var c:(Bool,Array<Int>) -> String

let d:([Int]) -> (Int,String)

let e:((name1:Int,name2:String)) -> Dictionary<String,String>

函式型別的使用: 函式型別的變數或常量賦值

func test1() -> Void
{
    print( "test1()" )
}

var a:() -> Void = test1
a()
print("-------------------------")

//1 匿名函式使用
var b:() -> Void = ({() -> Void in //這個in不能省略
    print("test1()")
})
b()
print("-------------------------")

//2 一般使用
func test2(param1:String,param2:Int)-> String
{
    return param1 + String(param2)
}
var c:(String,Int) -> String = test2
print(c("hello",12))
print("-------------------------")

//2-匿名函式使用
var d:(String,Int) -> String = ({(param1:String,param2:Int) -> String in
    return param1 + String(param2)
})
print(d("hello",13))
/*
test1()
-------------------------
test1()
-------------------------
hello12
-------------------------
hello13
*/

//也可以用常量
//3 一般使用
func test3(param:[Int]) -> String
{
    var temp:String = "hao"
    for item in param
    {
        temp = temp + String(item)
    }
    return temp
}
let e:([Int]) -> String = test3
print(e([1,2,3]))
print("-------------------------")
//3 匿名函式使用
let f:([Int]) -> String = ({(param:[Int]) -> String in
    var temp:String = "hao"
    for item in param
    {
        temp = temp + String(item)
    }
    return temp
})
print(f([3,4,5]))
/*
hao123
-------------------------
hao345
*/

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/281294.html

標籤：其他

上一篇：Xcode 運行HyperLPR開源專案蘋果APP

下一篇：uni-app 自定義發送訊息通知彈框

【Swift編程基礎】P9-16

P9：while 回圈和 repeat while 回圈

1.while 回圈

2.repeat while 回圈 （先運行再判斷）

P10：String 基礎操作

1.獲取字串長度

2.獲取子字串

3.其他常用操作

4.遍歷字串

5.格式化文本輸出

6.類轉義輸出

P11：Array 陣列

1.陣列的定義

2.陣列的基本操作

3.陣列排序

4.陣列過濾

5.陣列比較

6.遍歷陣列

P12：Set 集合

1.集合的定義

2.集合常用操作

3.集合相等判斷

4.集合過濾

5.遍歷集合

P13：Dictionary 字典

1.字典的定義

2.字典的基本操作

3.字典過濾

4.遍歷字典

P14：函式定義、函式引數名稱、assert斷言

1.函式定義

2.函式引數名稱問題

3.assert斷言

P15：guard 陳述句

1.guard 陳述句

2.guard 陳述句和 if 陳述句，在處理可選項系結之間的區別比較

P16：inout 關鍵字、函式型別

1.inout 關鍵字

2.函式型別

2.repeat while 回圈（先運行再判斷）