One Day

基本数据类型

整型

无符号整型
有符号整型
Int8
Int32
Int64
Int

浮点型

Float
Double

布尔型

Bool

集合类型

array 数组
set 集合
dictionary 字典

元组

可选类型

nil
数据类型+？

基本使用

变量和常量

定义

//常量
let this_const="我是一个常量"
//变量
var this_var="我是一个变量"

多种定义变量方式

//第一种------var 变量名：数据类型
var nilvar：String
//第二种------var 变量名=表达式（具体值）
var add=1+1
//第三种------var 多个变量名：数据类型
var a,b,c,d:Int

元组定义

//元组  var 变量=（数据类型：数据类型）var（变量，变量）=(表达式，表达式)。
var add=("加法",1+1)
print(add.0,add.1) //加法 2
var (add,sub)=(1+1,2-1)
print(add,sub) //2 1
//如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记
var (add,_)=(1,2)
//你可以在定义元组的时候给单个元素命名：
let http200Status = (statusCode: 200, description: "OK")
print("The status code is \(http200Status.statusCode)")
// 输出“The status code is 200”
print("The status message is \(http200Status.description)")
// 输出“The status message is OK”

集合定义

//Array 空数组 默认数组 数组拼接 数组初始化
var emarray:[Int]=[]
var defaultarray=Array(repeating: 0.0, count: 3)
emarray+=defaultarray
var strarray=['hello','world']
//Sets 空集合 集合初始化 
var emset:Set=[]
var strset:Set=['nihao','world'] 
//dictionary 空字典 字典初始化
var emdict:[Int:Int]=[:]
var strdict:[String:String]=["hello":"world"]

控制流

for in
while
if else if else
switch case where

函数

//定义方式 func 函数名(变量名:数据类型)->返回类型
func minMax(array: [Int]) -> (min: Int, max: Int) {
    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)
}
let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)")
// 打印“min is -6 and max is 109”

Test

九九乘法表

let n=9
for i in 1...9{
    for j in 1...i{
        print("\(i)*\(j)=\(i*j)",terminator: "\t")
    }
    print()
}
/*
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	
*/

冒泡排序

func bubbleSort(_ array: inout [Int]){
    if array.isEmpty {return}
    var lastExchangeIndex:Int = 0
    //无序数列的边界，每次比较只需要比到这里为止
    var sortBorder:Int = array.count - 1
    for i in 0..<array.count - 1
    {
        //有序标记，每一轮的初始是true
        var isSorted:Bool = true
        for j in 0..<sortBorder
        {
            if(array[j] > array[j + 1])
            {
                //交换数据
                array.swapAt(j, j + 1)
                //有元素交换，所以不是有序，标记变为false
                isSorted = false
                //把无序数列的边界更新为最后一次交换元素的位置
                lastExchangeIndex = j
            }
        }
        sortBorder = lastExchangeIndex
        if isSorted {break}
    }
}
var arr=Array(repeating: 0, count: 10)
for i in stride(from: 10, to: 0, by:-1){
    arr[10-i]=i
}
bubbleSort(&arr)
print(arr)