Swift 必备语法

• 常量和变量就是一个名字和一个指定类型的值关联起来，它们需要在使用前声明

let foundationTime = 2018
var schoolInfo = "百度 http://www.baidu.com"

• 在一行声明多个变量或常量时，可以逗号分割

var schoolName = "百度",schoolUrl = "http://www.taobao.com"
let year = 2018,month = 1, day = 1

• 常用的数据类型指定

//Int 是数据类型
var count1 : Int = 10
//这行语句与上面的语句等效
var count2 = 10

//不合法。变量没有指定类型的情况下必须初始化
//var count3

//合法语句，变量指定了Int类型，所以不用初始化
var count4 : Int

//不合法，常量必须初始化
//let pages1
//不合法，常量必须初始化
let pages2 : Int

//想定义一个常量，必须使用下面的形式

/** 合法的常量定义(不指定数据类型) **/
let pages3 = 10

/** 合法的常量定义(指定数据类型) **/
let pages4 : Int = 10

var value = "abc"

//不合法 value已经是string类型，不能再次Int类型
//value = 20

• 函数：print，这个全局函数可以在任何地方使用，用于在控制台输出指定的信息

/* 普通输出，自定换行 */
print("这是一行输出信息")

/* 分隔符输出多个参数，自动换行 */
print("Swfit","is","Open","Source",separator:"")

/* 分隔符输出多个参数，带后缀，不换行 */
print("Swfit","is","Open","Source",separator:"-", terminator: "!")

基本数据类型及转换

整数类型

let minIntValue = Int32.min
let maxIntValue = Int32.max

print(minIntValue)
print(maxIntValue)

浮点类型

let n1 : Double = 3.1415926
let n2 : Float = 3.14
print(n1)
print(n2)

extension Double {
    //转换
    func format(f: String) -> String {
        return NSString(format: "%\(f)f" as NSString,self) as String
    }
}

//输出固定位数的Double值
let n3 : Double = 3.1415926
print(n3.format(f: "1"))

布尔类型

let IsBest = true
let catIsDog = false

//if语句中使用Bool类型
var IsBestSchool:Bool = true
if IsBestSchool {
    print("Swift进阶教程")
}else{
    //其他代码
}

• Swift的类型安全策略会放置其他布尔类型转换为布尔类型使用，非布尔类型必须换成布尔类型

let m = 200

/* 无法编译通过，m不是Bool类型，是Int类型
if m {
    print("m = \(m)")
}
*/

//正确的写法应该将if后面的部分改成Bool类型的值
let n = 20
if n == 20 {
    // n == 20 的结果是Bool类型，所以可以成功编译
    print("n = \(n)")
}

字符和字符串类型

//这是一个字符
var charValue : Character = "a"

//这是一个字符串
var strValue : String = "abcd"
/**
 没有指定Character类型，虽然只有一个字符，但Swift默认是字符串
 var strValue = "a"
**/

var charValue3 : Character = "上"
/* 虽然charValue4 没有指定Character类型，但右侧返回的是Character类型，所以这个时候，变量charValue4也是Character类型 */
var charValue4 = charValue3

• 初始化一个空串，可以直接使用（""）,可以使用String对象

//初始化一个空的字符串变量
var emptyString1 = "";
//初始化一个空的字符串变量
var emptyString2 = String();

//判断字符串是否为空
if emptyString1.isEmpty {
    print("emptyString1 是空字符串")
}
//或
if emptyString1 == "" {
    print("emptyString1 是空字符串")
}

//字符串设置值的两种方法
var str1 = "abc"
var str2 = String("abc")

//枚举字符串
let charSet = "获取字符串中的每一个字符"
for c in charSet.characters {
    print(c)
}

元祖类型

let product = (2015, "iphone6s plus",6088)
print(product)
//当执行这两行代码时，会输出如下结果
(2015, "iphone6s plus", 6088)

//获取元祖中每一个元素
let product1 = (2015, "iphone6s plus", 6088)
//分别将product1中的3个值赋给3个变量(_year, _name, _price)
var (_year, _name, _price) = product1
//分别输出product1中的3个值
print("year = \(_year) name = \(_name) price = \(_price)")

let (_,name1,_) = product1
//只输出一个name值
print("name1=\(name1)")

//分别输出year, name, price元素值
let product2 = (year:2015, name:"iphone6s plus", price:6088)
print(product2.name)
print(product2.year)
print(product2.price)

可选类型

• 可选类型需要在后面加一个 ？，允许没有值，并设为nil

var stringValue : String
//编译报错
print(stringValue)

var stringValue : String?
if (stringValue != nil) {
    print("stringValue 存在值")
}

//感叹号使用
var stringValue1: String?
print(stringValue1)
print(stringValue1!)
if(stringValue != nil){
   print("stringValue 存在值")
}

• 每次都用感叹号非常的麻烦，以下是定义可选类型，将问好改成感叹号的方法

var numStr: String = "123"
//value必须定义为Int类型，否则无法成功编译
var value1: Int? = Int(numStr)
//value1定义可选Int类型,输出Optional(123)
print(value1)

/**
 var value2: Int7? = Int(numStr);
 编译失败，value2必须写成value2！
 print(value2+6)
*/

基本类型数据之间的转化

• Int类型转Double，Float，String

var j : Int = 3
Double(j)
Float(j)
"\(j)"

• String类型转Int，Double，Float

var s: String = "2.156asd2"
Int(s)
var s1 = s as NSString
s1.integerValue
s1.doubleValue
s1.floatValue
print(s1.integerValue)
print(s1.doubleValue)
print(s1.floatValue)

• Double，Float，Int类型转String

var d: Double = 1.68
"\(d)"

var f:Float = 1.68
"\(f)"

var i: Int = 1
"\(i)"

运算符和表达式

let b = 20
var a = 10
//a现在等于20
a = b

//字符串拼接
var newString = "hello，" + "world"
let endChar: Character = "!"
//字符串追加一个字符
newString.append(endChar)


//一元负号
let three = 3
let minusThree = -three
let plusThree = -minusThree

//一元正号
let minusSix = -6
let alsoMinusSix = +minusSix

//复合赋值
var aF = 1
aF += 2

//比较运算符
1 == 1
2 != 1
2 > 1
1 < 2
1 >= 1
2 <= 1

//三元条件运算
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)

//区间运算符
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}

//半闭区间
for index in 1..<5{
    print("\(index) * 5 = \(index * 5)")
}

//逻辑运算
//是否购买了本书
var book: Bool = true
//是否去无线互联网
var bjwxhl : Bool = true
//是否有oc基础
var oc : Bool = true

//有oc基础，购买了本书并且去了无线互联网
if (oc && book && bjwxhl) {
    print("恭喜你 你快成为Swift专家")
}else if ((!oc && book && bjwxhl) || (oc && !book && bjwxhl)){
    //没有oc基础，但是购买了书并且去互联网学习，或者有oc基础，没有买书，但是去了互联网学习
    print("在无线互联网下，你很容易掌握Swift语言")
}else{
    //只有oc基础，或者只购买了本书，或者去互联网学习
    print("你需要经过自己努力才能掌握Swift语言")
}

1. 表达式as类型
2. 表达式as？类型
3. 表达式is类型
4. 这种特定类型的转换成功，那么这个表达式被返回特定类型的一个实例，典型的例子是向上转型

class SomeSuperType{}
class SomeType: SomeSuperType{}
class SomeChildType: SomeType{}

let st = SomeType()
//成功，返回值SomeSuperType
let x = st as SomeSuperType
/**
 失败，编译错误
let y = st as Int
 编译失败，返回值类型为SomeChildType
let z = st as! SomeChildType
*/

//使用as表明类型
let y1 = x as! SomeType
//使用类型声明
let y2 : SomeSuperType = x

控制流

for index in 1...6 {
    print("\(index) * 6 = \(index * 6)")
}

//if while,switch条件语句
//if语句
//可以与else配合执行条件
//是否购买了本书
var book: Bool = true
//是否去无线互联网
var bjwxhl : Bool = true
//购买了本书
if(book){
    print("你购买了本书，很快成为Swift专家")
}else{
   print("你没有了本书，很难成为Swift专家")
}

//对于稍微比较复杂一点的条件，我们可以使用if else if else 这样的语句
if(book){
    print("你购买了本书")
}else if(bjwxhl){
    print("你参与了无线互联网学习")
}else{
    print("你什么都没有做")
}

//switch语句
var day1 = "Mon"
switch day1 {
    case "Mon": print("星期一")
    case "Tue": print("星期二")
    case "Wes": print("星期三")

default:
    print("不知道今天是星期几")
}

//switch分支使用范围
let count = 3_000
var naturalThings: String
switch count {
case 0:
    naturalThings = "数字0"
case 1...3:
    naturalThings = "数字1...3"
case 4...9:
    naturalThings = "数字4...9"
case 10...99:
    naturalThings = "数字10...99"
case 100...999:
    naturalThings = "数字100...999"
default:
    naturalThings = "数字999以上"
}
print(naturalThings)

控制转移语句

var m = 3
while (m<5) {
    if (m == 3) {
        break
    }
    print("😁")
}

//循环中的转移语句continue
var k = 0
var l = 0
while (k<3) {
    while (l < 3) {
        if (l == 2) {
            l = 10
            continue
        }
        print("😀")
    }
    print("☺️")
}

//fallthrough 语句的使用
let number = 5
switch number {
case 2,3,5,7:
    print("这是一个质数")
    fallthrough
case 5:
    print("5")
default:
    print("这是一个整数")
}
print(descriptorFontTableTag)

枚举和结构体

enum SomeEumeration {
    //在这里定义枚举
}
//以下是地图四个方面的一个例子

enum MapDirection {
    case North
    case South
    case East
    case West
    
    func simpleDesctiption() -> String  {
        switch self {
        case .North:
            return "North"
        case .South:
            return "South"
        case .East:
            return "East"
        case .West:
            return "West"
        default:
            return String("unknow")
        }
    }
}

//结构体的定义和使用
struct Summation {
    var addend:Int
    var augend:Int
    func sum() -> Int {
        return addend + augend
    }
}

//创建一个结构体
let newStruct = Summation(addend: 6, augend: 8)

//使用结构内方法
let newNum = newStruct.sum()
print(newNum)

宏定义

//判断iPhone4
let IPHONE4_DEV:Bool! = (UIScreen.main).bounds.size.height == 480 ? true : false

//判断iPhone5
let IPHONE5_DEV:Bool! = (UIScreen.main).bounds.size.height == 558 ? true : false

//判断iPhoneiPad
let iPad_DEV:Bool! = (UIDevice.current).userInterfaceIdiom == .pad ? true : false