swift语法100

Posted 2020-10-15 古成风云

1.打印语句 

print("Hello World") 

2.定义常量和变量

定义一个字符串常量与变量	
let constantString: String = "Hello"  // let 常量名称: 字符串类型 = "字符串"
var varibleString: String = "World"   // var 变量名称: 字符串类型 = "字符串"

3.常量和变量类型会自动推断，使用声明的时候可以省略类型

let constantInt: Int = 1              // 常见的类型有 Int Double Float String
var pi = 3.14                         // 编译器会自动推断出pi是Double类型

4.类型必须匹配

5.输出的语句

print(constantInt)                    // 1
print("π的值是:\(pi)")                 // 输出:3.1415926.输出字符串时将常量或变量放入\()中 

6.类型转换

let three = 3                         // 按住option,鼠标移动到变量名上,点击可以查看常量类型
var pointOneFour = 0.14               // 系统自动推断pointOneFour的类型为:Double
pi = Double(three) + pointOneFour     // 只有类型一直才能操作,转换格式: 类型名(变量或常量)
let piInt = Int(pi)                   // Double转Int,系统自动忽略小数点后面的数,会损失精度

7.元组

元组:多个可以是不同类型原色的集合	
let http404Error = (404, "Not Found") // 类型为:(Int, String),元组中的元素类型可以不同
let (code, message) = http404Error    // 将元组赋值给一个常量
print("code:\(code), message:\(message)") // code:404, message:Not Found
let (_, ErrorMessage) = http404Error  // _ 可以起到省略的作用,这个在swift中应用很广泛
print(http404Error.1)                 // Not Found 通过下标访问元素
let ErrorCode = (requestError:401, 402, 403) // 定义元组的时候可以给单个元素命名
                

8.可选类型，如果有可能赋值为nil，就必须声明为可选类型

1. 可选类型: 用来表示有值或没值的两种状态	
var errorCode: Int? = 404              // 在类型后面添加一个?
print(errorCode)                       // Optional(404)
errorCode = nil                        // 对非可选类型赋值为nil会报错
print(errorCode)                       // nil

9.使用！必须里面不为nil

3. 使用if语句强制解析,可选类型不能直接使用需要转化	
if errorCode != nil {                  // 确定可选类型包含值后可以在变量名后加!强制解析
  print(errorCode!)                    // 404
}

10.可选绑定,将可选类型赋值给一个临时的变量或者常量

if let code = errorCode {
    print(code)                        // 输出:404, 自动解析
}else {
//    print(code)                      // ?,code是局部变量
    print(errorCode)                   // 如果errorCode = nil此处输出nil
}

11.隐式解析可选类型:因为一定有值,所以可以免去解析的麻烦

let assumedString: String! = "A"       // 格式: 可选类型的?改成!
print(assumedString)                   // A
if let TempString = assumedString {    // 隐式解析可选类型可以被当做普通可选类型来使用
    print(TempString)                  // A
}

12.字符串是否为空

emptyString2.isEmpty                   // true, 通过isEmpty方法判断是否为空

13.遍历字符串的所有字符

for char in emptyString1.characters {  // for循环后面会详述
    print(char)                        // 依次输出emptyString1中所有字符
}

14.获取字符串的长度

emptyString1.characters.count          // 9, 获取字符串中字符个数包括空格

15.字符串的链接

var string3 = string1 + string2        // Hello World, 通过"+"将两个字符串相连
string1.append(" !")                   // Hello World !, 通过append()方法拼接
let messages = "Hello \(string2) !"    // Hello World !, 通过将常量或变量放入\()中

16.字符串的截取

let messChar = messages[messages.startIndex]  // H,通过第一个字符的索引获取字符

let firstIndex = messages.index(after: messages.startIndex)  // 1, 第一个字符的索引

let lastIndex = messages.index(before: messages.endIndex)  // 13, 最后一个字符的索引

let index = messages.index(messages.startIndex, offsetBy: 4)  // 4, 初始位置偏移4
messages[index]                        // o, 通过索引获得的字符为o

messages[messages.endIndex]            // ?, 注意:索引不能越界

17.数组的创建

var arrTitle = [String]()

18.数组的添加

arrTitle.append("超值出游");
arrTitle.append("精选门票");
arrTitle.append("享游港澳");

19.数组的遍历

for arrItem in twoDouble {             // 通过for in 循环遍历
    print(arrItem)                     // 依次打印每个元素
}

for (index, value) in twoDouble.enumerated() {  // 使用迭代器获取数组元素以及索引号
    print("索引:\(index), 元素:\(value)")  // 依次打印索引号及元素 索引号:0, 元素:3.0 ...
}   

20.字典的声明

var charDict = ["char1":"A", "char2":"B"]  // 系统会作自动类型推断,类型也可以省略

21.字典的添加

chars["char3"] = "C"  

21.字典的移除

chars.removeValue(forKey: "char2") 

22.字典的更新

chars.updateValue("b", forKey: "char2")    // 更新键值对,要是这个键不存在则会添加一个

23.字典的遍历

for (key, value) in charDict {             // 遍历字典中的所有key value
    print("\(key): \(value)")              // char2: B 换行 char1: A
}
for key in charDict.keys {                 // 遍历字典中的所有key
    print(key)                             // char2 换行 char1
}

for value in charDict.values {             // 遍历字典中的所有value
    print(value)                           // B 换行 A
}

24.for循环的操作

for num in 1...5 {                     // 依次把闭区间[1, 5]中的值赋值给num
    print(num)                         // 依次输出5个数字
}

25.if/else

num = 3
if num == 3 {                          // if后判断语句返回为真,执行后面{}
    print(num)                         // if语句后面的{}不能省略
}else {                                // if后判断语句返回为假,执行else后面{}
    print("num is not equeal to 3")
}

26.switch

num = 12
switch num {
case 2:
    print("num等于2")                  // 每个case分支至少需要包含一条语句
    print("num等于2")                  // case分支末尾不需要写break,不会发生贯穿
case 3, 4, 5:                         // case语句可以匹配多个值,之间用(,)隔开
    print("num == 3 or 4 or 5")
case 6..<10:                          // case语句也支持区间
    print("num大于等于6,且小于10")
case 10..<19 where num % 3 == 0:      // 使用where语句来增加额外判断条件
    print("num大于等于10,且小于19,且能被3整除")
default:
    print("上面的情况都不满足")
}

27.基本函数： 用来完成特定任务的独立代码片段

func minMax(currentArray array:[Int]) -> (min:Int,max:Int) {
        
        var currentMin = array[0];
        var currentMax = array[0];
        for arrItem in array {
            if arrItem < currentMin
            {
                currentMin = arrItem;
            }
            
            if(arrItem>currentMax)
            {
                currentMax = arrItem;
            }
        }
        return (currentMin,currentMax)
    }

28.不确定参数个数的函数：

// 计算多个数的平均数
func avarageNum(_ num: Double...) -> Double { // 参数后面加...表示有多个参数
    var total: Double = 0
    for number in num {
        total += number
    }
    return total/Double(num.count)
}

avarageNum(2, 6, 4, 8, 7)               // 5.4, 参数个数不限
avarageNum(5)                           // 注意: 一个函数只能有一个可变参数

 27.网络请求框架

 Alamofire.request("http://wimg.mangocity.com/bms/api/app/index/index.json", method: .get, parameters: nil, encoding: JSONEncoding.default)
            .downloadProgress(queue: DispatchQueue.global(qos: .utility)) { progress in
                print("Progress: \(progress.fractionCompleted)")
            }
            .validate { request, response, data in
                debugPrint(response)
                return .success
            }
            .responseJSON { response in
                debugPrint(response)
        }