Swift 基本概念(笔记)

/********************基本概念****************************/

// var 是变量

// let 是常量

var myVariable = 42

myVariable = 50

let myConstant = 42

print(myVariable)

print(myConstant)

// swift 会默认根据值来定义类型

// 如果想确定类型,需要在参数后面加冒号来确定类型

let test1:Float = 4

print(test1)

let label = "The width is "

let width = 94

let widthLabel = label + String(width)

print(widthLabel)

// 如果两个类型不同,不能想加

//let widthLabel1 = label + width

//print(widthLabel1)

// 有一种简单的把值转化为字符串的方法

// 把值写到括号里,并且在括号之前写一个反斜杠.如 \(值)

let apples = 3

let oranges = 5

let appleSummary = "I have \(apples) apples"

let fruitSummary = "I have \(apples + oranges) pieces of fruit"

print(appleSummary)

print(fruitSummary)

let test2:Float = 40

let chat = "hello, My age is \(test2)"

print(chat)

// 数组

// 使用中括号

var shoppingList = ["catfish","water","tulips","blue paint",]

print(shoppingList)

shoppingList[1] = "bottle of water"

print(shoppingList)

print(shoppingList[2])

// 字典

// 也用中括号

var occupations = [

    "Malcolm" : "Captain",

    "Kaylee" : "Mechanic",

    "test1" : "answer1"

]

// 打印顺序是乱的

print(occupations)

occupations["Jayne"] = "Public Relations"

print(occupations)

occupations["test"] = "answer"

print(occupations)

// 要创建一个空数组或者字典,使用初始化语法

let emptyArray = [String]()

let emptyDictionary = [String : Float]()

// 如果类型信息可以被推断出来,则可以用[]和[:]来创建空数组和空字典

shoppingList = []

occupations = [:]

// 使用 if 和 switch 来进行条件判定,使用 for-in、for、while和repeat-while进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号不能省

let individualScores = [75,45,103,87,12]

var teamScore = 0

for score in individualScores{

    // 在 if 语句中,条件必须是一个布尔表达式--这意味着 if score 会报错,不会在自动跟0作对比了

    if score > 50{

        teamScore += 3

    } else {

        teamScore += 1

    }

}

print(teamScore)

// “你可以一起使用if和let来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是nil以表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。”

var optionalString:String? = "hello"

// 直接打印

print(optionalString)

// 返回Optional("hello")

print(optionalString == nil)

var optionalName:String? = "John Appleseed"

optionalName = nil

var greeting = "Hello!"

if let name = optionalName {

    // 把字符串转化为常量

    greeting = "Hello, \(name)"

    print(greeting)

} else {

    greeting = "1111"

    print(greeting)

}

// 如果变量的可选值为 nil,条件会判断为 false,大括号中的代码会被跳过.如果不是 nil, 会将赋值给 let 后面的常量,这样代码中就可以使用这个值了

// 另外一种处理可选值的方法是通过使用??操作符来提供一个默认值.如果可选值缺失的话,可以使用默认值来代替

let nickName:String? = nil

let fullName:String? = "John Appleseed"

let informalGreeting = "HI \(nickName ?? fullName)"

print(informalGreeting)

// switch 支持任意类型的数据以及各种比较操作 -- 不仅仅是整数以及测试相等

let vegetable = "red pepper"

switch vegetable{

case "celery":

    print("Add some raisins and make ants on a log.")

case "cucumber","watercress":

    print("That would make a good tea sandwich.")

case let x where x.hasSuffix("pepper"):

    print("Is it a spicy \(x)?")

default:

    print("Everything tastes good in soup.")

}

let min = UInt.min

print(min)

let max = UInt8.max

print(max)

let decimalInteger = 17

// binary 二进制

let binaryInteger = 0b10001

print(binaryInteger)

// octal八进制

let octalInteger = 0o21

print(octalInteger)

// hexadecimal十六进制

let hexadecimalInteger = 0x11

print(hexadecimalInteger)

// 浮点字面量还有一个特殊的指数

// 十进制用 e, 10的乘方

let decimalFloat = 1.25e3

// 相当于1.25*10^3

print(decimalFloat)

// 十六进制用 p, 2的乘方

let hexadecimalFloat = 0xFp2

// 相当于15.0*2^2

print(0xF) //15

print(0xE) //14

print(0xD) //13

print(hexadecimalFloat)

let hexadecimalDouble = 0xC.3p0

print(hexadecimalDouble)

// 数值类字面量可以包括额外的格式来增强可读性,整数和浮点数都可以添加额外的零并且包含下划线,并不会影响字面量

let oneMillion = 1_000_000

// Int8 是-128~127

// UInt8 是0~255

// typealias 类型别名

// 感觉就是宏

typealias AudioSample = UInt16

var minAmplitudefound = AudioSample.min

print(minAmplitudefound)

var maxAmplitudefound = AudioSample.max

print(maxAmplitudefound)

// Bool

// Bool只能是 true 或者是 false.0和非0不会再进行判定

let orangeAreOrange = true

//let orangeAreOrange:Bool = 1 //这样写就不对

print(orangeAreOrange)

// 元祖

// 元祖(tuples)把多个值组合成一个复合值,元祖内的值可以是任意类别,并不要求是相同类型

let http404Error = (404,"Not Found");

// http404Error的类型是[Int,String]

print(http404Error)

// 可以把任意顺序,任意类型组合成一个元祖

// 也可以讲元祖内容分解

let (statusCode,statusMessage) = http404Error;

//print(statusMessage)

//print(statusCode)

print("The status code is \(statusCode)");

// 输出是The status code is 404

// 如果你只需要一部分元祖,那么在分解的时候可以把要省略的部分用下划线标注出来

let (justTheStatusCode,_) = http404Error

print("The status code is \(justTheStatusCode)")

// 通过下标取得

// 下标从0开始

print(http404Error.1)

// 也可以在定义元祖的时候给单个元素命名

// 然后用直接点出来

let http200Status = (statusCode:200,description:"OK")

print(http200Status.statusCode)

print(http200Status.description)

// 元祖建议用在临时创建的组织值,但是并不适合复杂的数组结构

/*****************************可选值****************************/

// 如果你的代码里有常量或者是变量需要处理值缺失的情况,请把他们声明对应的可选类型

// 如果你声明一个可选变量或者变量没有赋值,那么他们会自动设置为 nil

var surveyAnswer:String?

print(surveyAnswer)

let possibleNumber = "123"

let convertedNumber = Int(possibleNumber)

// 这个时候 convertedNumber 的类型就是 Int?

// 因为不确定能不能转,如果是"123"可以转成123,如果是"hello"就转不了

// 注意: swift 的 nil 指的是这是一个不确定的值,用来表示值的缺失,任何类型都可以被设置成 nil, 不只是对象类型

if convertedNumber != nil {

    print("covertedNumber has an integer value of \(convertedNumber).")

    // 如果确定这个可选类型有值,可以在后面加个!

    // 加了感叹号,表示我确定这个值有值,给我取出来

    print("covertedNumber has an integer value of \(convertedNumber!).")

}

// 用!之前一定要确定有值,如果没有,那么会报错

// 可选绑定

if let actualNumber = Int(possibleNumber) {

    print("'\(possibleNumber)' has an interger value of \(actualNumber)")

    // 这俩是一样的

//    print("\'\(possibleNumber)\' has an interger value of \(actualNumber)")

} else {

    print("\'\(possibleNumber)\' could not be converted to an integer")

}

// 如果有多个可选值,那么可以用 where 字句做布尔值判断

if let firstNumber = Int("4") , secondNumber = Int("42") where firstNumber < secondNumber {

    print("\(firstNumber) < \(secondNumber)");

}

// 也就是说,可选类型暗示了常量或者变量可以"没有值".可选可以通过if 来通过判定是否有值,如果有值的话可以通过可选绑定来解析值

let float1 = 3.123

let float2 = 3.2

var add = float1 + float2

print(add)

/*************************报错******************/

func canThrowAnError() throws {

    // 这个函数可能的错误

}

// 一个函数可以通过在声明中添加 throws 关键字来抛出错误信息.当你的函数能抛出错误信息时,你应该在表达式中前置 try关键字

do {

    try canThrowAnError()

    // 没有错误信息抛出

} catch {

    // 有一个错误信息抛出

}

// 一个 do 语句创建了一个新的包含作用域,使得错误能被传播到一个或多个 catch 从句

// example   没看懂

//func makeASandwich() throws {

//    // ...

//}

//

//do {

//    try makeASandwich()

//    eatASandwich()

//} catch Error.OutOfCleanDishes {

//    washDishes()

//} catch Error.Missingingredients(let ingredients) {

//    buyGroceries(ingredients)

//}

/**********************断言*************************/

// 断言会在运行中判定某个逻辑条件是否为真,如果为真就会执行,不为真代码执行结束

// 在执行代码之前,下断言判定某些重要的条件是否满足,如果满足,代码会继续执行,不满足,就结束

// 在 xcode 运行时,通过断言能清楚地看到在哪里发生的不合法状态和你断言被触发时候应用的状态

// 此外,断言允许你附加一条调试信息

// 全局断言

// assert(_:_file:line:)

// 向一个函数传入一个结果为 true 活着 false的表达式和一条信息,如果为 false, 传递出这条信息

let age = -3

//assert(age >= 0,"A person's age cannot be less than zero")

// 以为age < 0 ,所以断言被触发

// 如果不需要断言信息,可胜率

//assert(age >= 0)

// 当代码使用优化编译的时候,断言会被禁用,例如 Xcode 中,使用默认的 target Release 配置选项来 build 时,断言会被禁用

// 使用断言的场景

/**

*  整数类型的下表索引被传入一个自定义下标脚本实现,但是下标索引值可能太小活着太大

*  需要给函数传入一个值,但是非法的值可能导致函数不能正常执行

*  一个可选值现在是 nil, 但是后面的代码运行需要一个非 nil 值

*/