swift 1-Day

One Day

基本数据类型

整型

1. 无符号整型
2. 有符号整型
3. Int8
4. Int32
5. Int64
6. Int

浮点型

1. Float
2. Double

布尔型

Bool

集合类型

1. array 数组
2. set 集合
3. dictionary 字典

元组

可选类型

1. nil
2. 数据类型+？

基本使用

变量和常量

定义

//常量
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"]

控制流

1. for in
2. while
3. if else if else
4. 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)