1.逻辑分支

• 分支：if/switch/三目运算符
• if
  • if后面的()可以省略
  • swift中必须有明确的真假
    • Bool两个取值：false/true
    • 没有非零即真，也没有非空即真

let a = 20
if a >0{
}else{
}
let score = 88
if score < 0 || score >100{
print("不合理")
}else if score <60{
print("不及格")
}else{
print("优秀")
}

• 三目运算符
  • 使用方法和oc是一致的

let m = 30
let n = 20
let result : Int = m > n ? m : n

• guard的使用
  • swift2.0新增语法
  • 和if语句非常相似，是为了提高程序的可读性
  • guard语句必须带有else语句
    • 当条件表达式为true的时候，跳过else语句，执行语句组内容
    • 当条件表达式为false的时候，执行else语句中的内容
    • 跳转语句一般是break/return/continue/throw
      • return :结束执行，一般用在方法里
      • break: 跳出循环
      • continue:跳出本次循环，进入下一个循环
      • throw:抛出异常
  • guard写在函数里

//guard格式：
guard 条件表达式 else{
//条件语句
break
}
//---------------
let age = 20
//定义函数
func online(age :Int) -> Void {
//大于18岁，带了身份证，带了钱
    guard age >=18 else{
       print("回家去")
       return
    }
    guard 带了身份证 else{
       print ("回家取身份证")
       return
    }
    guard 带了钱 else{
       print("回家拿钱")
       return
    }
//执行语句
print(“留下来上网”)
}
//调用函数
online(20)

• switch
  • 苹果对switch进行了大大的增强，使其拥有了其他语言中没有的特性
  • switch的简单使用
    • 基本用法和OC用法一致
    • 不同之处：
      • switch后面可以不跟（）
      • case后可以不跟break(默认会有break)，不会产生case穿透
  • 如果希望产生case穿透，需要在语句结束时候，加上另一个关键字fallthrough
  • 在swift中switch的case后面可以跟上多个条件，并且多个条件以逗号（,）分隔

//基本用法:sex 0:男 1 :女
let sex = 0
switch sex {
case 0 :
print("男")
case 1 :
print("女")
}
//-------------------
switch sex {
case 0 ,1 :
print("正常人")
default:
print("非正常人")
}

• swift的特殊用法
  • 判断浮点型
  • 判断字符串类型
  • 支持区间判断
    • 半开半闭区间 0..<10 :0~9 不包含10
    • 闭区间 0...10 :0~10 包含10

//判断浮点型
let m = 3.14
switch m{
 case 3.14:
 print("m是一个π")
 default:
 print("m非π")
}
//判断字符串类型
let a = 30
let b = 20
let opration = "*"
var result = 0
switch opration{
case "+":
result =  a + b
case "-":
result = a-b 
case "*":
result = a *b 
case "/"
result = a/b
default :
print("非法操作")
}
//支持区间判断
let score = 88
switch score {
case 0..60:
  print("不及格")
case 60..80:
  print(“及格”)
case 80..90:
  print("良好")
case 90...100:
  print("优秀")
default: 
  print("不合理分数")
}

• 总结
• swift初体验
  • 导入框架 import 框架名称
  • 定义标识符
    • 定义标识符必须指定常量和变量
  • 如果一行当中只有一条语句，那么语句结束，分号可以省略
  • 打印内容 print("")
• 常量和变量的使用
  • var :修饰变量
  • let :修饰常量
  • 使用注意：
    • 优先使用常量，防止被修改
    • 常量的本质：指向的内存地址不可以修改，但是可以通过内存地址找到对应的对象，之后修改对象内部的属性
• 数据类型
  • 整型和浮点型
  • 类型推导：
    • 如果在定义一个标识符时，如果有直接给该标识符赋值，那么会根据赋值的类型推导前面标识的类型
    • 那么这个时候标识符的类型可以省略
    • option+鼠标左键
  • 基本运算
    • swift中没有隐式类型转化
    • 所有必须保证类型一致才能进行运算
• 逻辑分支
  • if分支
    • if后面()可以省略
    • 没有非零即真，必须有明确真假
    • Bool:true/false
  • 三目运算符
  • guard
    • guard
      • 方法return
      • 循环break/continue
      • 抛出异常throw
    • 条件为true执行语句块，条件为false执行else{}
  • switch
    • switch后面的()可以省略
    • case结束后可以不加break
    • 希望case穿透：fallthrough
    • 特殊用法
      • 判断浮点型
      • 判断字符串
      • 判断区间类型
        • 半开半闭区间 0..<10
        • 闭区间 0...10

2.循环

• for
  • 如果一个标识符不需要使用，那么可以通过_来代替
  • 建议区间遍历

//区间遍历
for i in  0..<10 {
 print(i)
}
for _ in 0...9 {
 print("hello world")
}

• while
  • while后面的（）可以省略
  • 没有非零即真

//i最后一次打印是打印的1
var i = 10 
while i >0 {
  print(i)
  i -= 1 
}

• do while
  • 区别：不再使用do while ——>repeat while

//m最后一次打印是打印9
var m = 0
repeat {
print(m)
m += 1
}while m < 10

3.字符串的使用

• String
  • string 是一个结构体，性能更高
  • NSString是一个OC对象，性能略差
  • String支持直接遍历
  • Swift提供了String 和NString之间的无缝转换
• 字符的定义
  • 定义不可变字符串 ：let修饰的字符串就是不可变的
  • 定义可变字符串： var修饰的字符串就是可变的
• 如何遍历字符串中所有字符

    for c in str.characters{
    print(c)
    }

• 获取字符串的长度

let length = str.characters.count

• 字符串的拼接
  • 字符串之间的拼接
  • 字符串和其他标识符之间的拼接
  • 在拼接过程中的格式化

//字符串之间的拼接
let str1 ="殷鸣"
let str2 = "李依隆"
let resultStr = str1 + str2 
//字符串和其他标识符之间的拼接
let name = "ym"
let height = 1.60
let age =28
let infoStr = "my name is \(name) ,age is \(age) ,height is \(height) "
print(infoStr)
//在拼接过程中格式化:QQ音乐分钟秒钟拼接
let min = 2
let second = 3
let timeStr = Sting(format:"%02d:%02d",arguments:[min,second])

• 字符串的截取
  • 将string类型转成NSString类型再进行截取
    • (urlString as NSString) ——>NSString
  • 苹果原生方式进行截取

let urlString = "www.520it.com"
//方式1：将string类型转成NSString类型再进行截取
let header = (urlString as NSString ).substringToIndex(3)
let footer = (urlString as NSString).substringFromIndex(10)
let range = NSMakeRange(4,5)
let middle = (urlString as NSString).substringWithRange(range)
//方式2：swift原生方式进行截取
let headerIndex = urlString.startIndex.advanceBy(3)
let header = urlString.substringToIndex(headerIndex)
let footerIndex = urlString.endIndex.advancedBy(-3)
let footer = urlString.substringFromIndex(footerIndex)
let range = Range(start:headerIndex.advancedBy(1),end:footerIndex.advancedBy(-1)) 
//上面range方法过期了 ，苹果建议写成区间形式
let range = headerIndex.advancedBy(1)..<footerIndex.advancedBy(-1)
let middle = urlString.substringWithRange(range)

4.数组

• 数组：是一串有序的由相同类型元素构成的集合

• 数组中的集合元素是有序的，可以重复出现

• swift数组类型是Array,是一个泛型集合

• 如何定义数组

  • 定义不可变数组，使用let修饰
    • let array : Array<String> = ["why","yz","lmj","lnj"]
    • 如果直接初始化的话，可以省略: Array<String>，让其直接类型推导
    • let array :[String] = ["why","yz","lmj","lnj"]
    • let array = ["why","yz","lmj","lnj"]
  • 定义可变数组,使用var修饰
    • 数组是泛型集合，必须明确指定该数组之后存放的元素
    • var arrayM = Array<String>()
    • 简便写法：var arrayM = [String]()
    • arrayM.append("123")

• 对可变数组的基本操作

  • 增删改查——>数据库
  • 添加元素
    • arrayM.append("lmj")
  • 删除元素
    • removeAtIndex()
    • removeAll
  • 修改元素
    • arrayM[0] = "Why"
    • arrayM
  • 根据下标获取元素
    • let item = arrayM[0]

• 遍历数组中所有的元素(三种方式)

  • for i in 0..<array.count{
    print(array[i]获取下标值)
    }
  • for name in array {
    print("类型推导出name的类型，只能获取元素，不能获取下标值")
    }
  • 可以获取到下标值和元素
  • for(index ,name) in array .enumerate(){
    print(index)
    print(name)
    }

• 数组的合并

  • 相同类型的数组可以相加进行合并
  • let array1 = ["why","yz"]
  • let array2 = ["lmj","lnj"]
  • 合并：let resultArray = array1 + array2
  • 类型不一样的数组，不可以进行相加合并