Swift基础

简介
- 2014年推出
特点
- 语法简单,代码简洁,使用方便
创始人
- Chris Lattner在2010年开始设计
Playground
- 所见即所得
- 语法特性发生改变时,可以快速查看
基本语法
- 导入框架时,有时不需要""
- 定义标识符时必须制定该标识符是常量还是变量
  - 格式: 标识符 : 类型
    - let : 定义常量
    - var : 定义变量
- 当一行语句结束时,不再需要写;
- 打印使用print,直接换行
变量和常量
- 注意:
- 1>在开发中优先使用常量,只有在需要修改时更改为变量
- 2>常量的意思: 指向对象不可修改(指针不可以修改)
  - 可以通过指针拿到对象,修改内部的属性
在swift中创建对象,类()
- 在swift中使用枚举: 类型.具体类型
swift类型
- 整型
- 浮点型
swift类型推导
- 如果一个标示符在定义时有直接复制,那么可以根据后面赋值的类型,来推导出前面标示符的类型,那么就可以省略前面标示符的类型
- 可以通过快捷键:option + 左键,查看标示符类型
swift中的基本运算
- 必须保证类型是一致的
  - 因为swift中没有隐式转化
逻辑分支
- if语句
  - 1>判断句可以不加()
  - 2>判断句结果必须是一个真假值
- 三目运算符
  - let score = 98
    let result = score >= 0 ? "成绩正确" : "成绩有误"
guard
- Swift2.0新增语法
- 语法:当满足条件判断就跳过else; 当不满足条件判断时就执行else
- 应用场景: 函数中

func onLine2(age : Int) -> Bool {
    guard age >= 18 else{
        print("不能上网")
        return false
    }
    print("可以上网")
    return true
}
//调用函数
onLine2(19)

switch

let direction = 0
switch direction {
case 0:
    print("north")
case 1:
    print("south")
case 2:
    print("east")
default :
    print("west")
}

case中可以判断多个条件

如果想判断多个条件可以通过,分割

switch direction {
case 0, 1:
    print("north--east")
default:
    print("south--west")
}

特殊用法

1>可以判断浮点型

let r = 1.23
switch r {
case 1.23:
    print("lian")
default:
    print("jie")
}

2>可以判断字符串

let m = 20
let n = 10
let opration = "/"
var result : Int
switch opration {
case "+":
    result = m + n
case "-":
    result = m - n
case "*":
    result = m * n
case "/":
    result = m / n
default:
    print("非法操作符")
}

3>判断区间

全闭区间: 0~10 0…10
半开区间: 0~9 0..<10

let scores = 35
switch scores {
case 0..<60:
    print("不及格")
case 60..<70:
    print("及格")
case 70..<90:
    print("良好")
case 90...100:
    print("优秀")
default:
    print("成绩错误")
}

循环

for

常规写法

for var i = 0; i < 10; i++ {
    print(i)
}

区间for循环

for i in 0..<10 {
    print(i)
}
for i in 0...10 {
    print(i)
}

特殊写法: 如果for循环中没有用到i,可以将i用_代理
- ```
for _ in 0..<10 {
    print("MJHee")
}
```

while

不要()
判断句必须有真假

var w = 10
while w < 20 {
    w++
    print("MJHee")
}

do...while
- 注意: 在do...while循环中,不要使用do,而是使用repeat代替do
- ```
repeat {
    w++
    print("YHee")
} while w < 30
```

字符串

介绍
- string是结构体,性能更高; NSString是一个OC对象,性能略差
- string支持直接遍历
- swift提供了string和NSString之间的无缝转换

使用

遍历字符串

var str = "MJHee"
for s in str.characters {
    print(s)
}

字符串拼接

两个字符串拼接

let str1 = "I Love"
var str2 = " RiZhao"
str2 = str1 + str2

字符串与其他数据拼接

格式: (变量/常量名称)

let iage = 18
let iheight = 1.89
let str3 = "age is (iage), height is (iheight)"

字符串的格式化

let min = 2
let second = 3
let time = "0(min) : 0(second)"
let itime = String(format: "%02d : %02d", arguments: [min, second])

字符串截取

let urlString = "www.MJBaby.com"
let prefixString = (urlString as NSString).substringToIndex(3)
//www
let middleString = (urlString as NSString).substringWithRange(NSRange(location: 4, length: 6))
//MJBaby
let subfixString = (urlString as NSString).substringFromIndex(11)
//com

提示: 不要使用string方法截取, index非常不好创建
- urlString.substringFromIndex(index: Index)
解决方法:
- 建议将string-->NSString-->截取
- String-->NSString: 只需要在string后面跟上: as NSString

数组

类型:
- Array
- 可变数组 var修饰
- 不可变数组 let修饰

初始化

不可变数组

数组定义的写法一:

let names : Array<String> = ["Jack", "Lucy", "Sara"]

数组定义的写法二:

let nameArr : [String] = ["MJHee", "YHee"]

数组定义的写法三:
```
let nameArray = ["MJHee", "hmj", "HMJ"]
```

可变数组

数组定义的写法一:

var names1 : [String] = ["hmj", "lxx"]
names1.append("HYH")

数组定义的写法二:

var names2 : [String] = [String]()
names2.append("HMJ")

基本操作

1.添加元素

names3.append("MJHee")
names3.append("HeeYH")
names3.append(12)
names3.append(true)

2.删除元素

names3.removeLast()
names3.removeAtIndex(0)

3.修改元素
```
names3[1] = "MJBaby"
```
4.取出数组中的元素
```
names3[1]
```

遍历数组

1>通过下标值遍历

for i in 0..<names3.count{
    print(names3[i])
}

2>forin方式
```
for item innames3{
    print(item)
}
```

3>区间遍历

for i in 0..<2{
    print(names3[i])
}
for item innames3[0..<2]{
    print(item)
}

合并数组

let array1 = ["hmj", 23, "+86 12344555"]
let array2 = [1.70, "China"]
let array3 = array1 + array2
//不同类型的数组合并
let name1 = ["hyh", "mj"]
let ages1 = [12, 23, 18]
var array4 = [AnyObject]()
for item in name1{
    array4.append(item)
}
for item in ages1{
    array4.append(item)
}

字典

初始化

不可变字典

1>初始化方法一:

let dict1 : Dictionary<String, AnyObject> = ["name" : "hmj", "age" : 23]

2>初始化方法二:

let dict2 : [String : AnyObject] = ["name" : "hmj", "age" : 23]

3>初始化方法三:

let dict3 = ["name" : "hmj", "age" : 23]

可变字典

1>初始化方式一

var dictA1 = Dictionary<String, AnyObject>()

2>初始化方法二:
```
var dictA2 = [String : AnyObject]()
```

3>初始化方法三:

var dictA3 = ["name" : "hmj", "age" : 23]

基本操作

1>添加元素

dictA["name"] = "hmj"
dictA["age"] = 23
dictA["height"] = 1.70
dictA["like"] = 13

2>删除元素

//dictA.removeAll()
dictA.removeValueForKey("like")

dictA["age"] = 18

注意: 通过该方式来修改元素,如果有对应的键就修改,没有对应的键则添加元素

4>取出
```
dictA["age"]
```

对字典的遍历

1>遍历字典中所有的键
```
for key in dictA.keys{
    print(key)
}
```

2>遍历字典中所有的值

for value indictA.values{
    print(value)
}

3>遍历所有的键值对

for (key, value) indictA{
    print(key)
    print(value)
}

字典合并

var dict1A = ["name" : "hmj", "age" : 23]
let dict2A = ["phone" : "+86 1234556"]
for (key ,value) in dict2A{
    dict1A[key] = value
}

注意: 字典无论类型是否一致,都不可以通过直接相加来合并

元组

简介

定义

定义元组方式一:
```
let tem1 = ("hmj", 23, 1.70)
```

定义元组方式二:最常用

let tem2 = (name : "hmj", age : 23, height : 1.70)

定义元组方式三:

let (name, age, height) = ("hmj", 23, 1.70);

使用

let error = (404, "Not Found")
error.0
error.1

let error1 = (errorCode : 404, errorInfo : "Not Found")
error1.errorCode
error1.errorInfo

let(errorCode1, errorInfo1) = (404, "Not Found")
errorCode1
errorInfo1

可选类型

注意: 多利用Xcode的提示来使用
概念: nil也是一个特殊的类型,因此推出可选类型

定义可选类型

基本写法

1>方式一:

optional<String>
class Person {
    //定义属性    var name : Optional<String>
}
var avaName : Optional<String>
//给可选类型赋值avaName = "HMJ"//打印可选类型:Optional("HMJ")
print(avaName)
//取出可选类型中的值
//取值: 可选类型 + !,强制解包print(avaName!)
//拼接let info = "My name is " + avaName!

语法糖

2>方式二:语法糖: 类型?

let phoneNum : String?
phoneNum = "+86 123556"
let phoneInfo = "My phoneNum is " + phoneNum!

使用注意: 如果一个可选类型中没有值,强制解包会报错
- 在强制解包之前,最好对可选类型进行判断,如果有值再进行解包
  - 判断是否有值
    - if phoneNum != nil { let phoneInfo = "My phoneNum is " + phoneNum! }
    - 可选绑定
      1>如果没有值,就直接跳过{}
      2>如果有值,将可选类型进行解包,并且将解包后的值赋值给tempPhoneNum
      if let tempPhoneNum = phoneNum { print(phoneNum)//显示: Optional("+86 123556") print(tempPhoneNum)//显示: +86 123556 }

应用场景

let urlstring = "http://www.baidu.com"
//如果写类型那么必须写成可选类型
let url : NSURL? = NSURL(string: urlstring)
//如果有中文就会报错
NSURLRequest(URL: url!)
//进行判断
if url != nil {
    NSURLRequest(URL: url!)
}
//可选绑定
if let tempUrl = url {
    NSURLRequest(URL: tempUrl)
}

函数

格式
- func 函数名(参数列表) -> 返回值类型 {代码块 return 返回值}

类型

1.没有参数,没有返回值的函数

func about1() -> Void{
    print("手机型号是iPhone6s Plus玫瑰金")
}
about1()
注意: 如果一个函数没有返回值,那么:(-> Void)可省略
func about2() {
    print("手机型号是iPhone6s Plus玫瑰金")
}

2.没有参数,有返回值的函数

func readMessage() -> String {
    return"吃饭了吗?"
}

3.有参数,有返回值
注意: 如果有多个参数,则参数使用","分割

func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
sum(20, num2: 30)

4.有参数,没有返回值

func callPhone(phoneNum : String) -> Void {
    print("打电话给: " + phoneNum)
}
callPhone("+86 13355")

函数使用注意点

1.注意一: 内部参数和外部参数
**num1: 在外部看不见的参数,就是内部参数
**num2: 在外部可以看见的参数,就是外部参数(即是内部参数也是外部参数)
**内部参数和外部参数的使用方法
- 1>默认情况下,函数从第二个从哪回溯开始都是外部参数
```
func sum(num1 : Int, num2 : Int, num3 : Int) -> Int {
    return num1 + num2 + num3
}
sum(1, num2: 0, num3: 3)
```
- 2>如果想让第一个参数成为外部参数,可以在标示符前加"别名"
```
func sum(num1 num1 : Int, num2 : Int, num3 : Int) -> Int {
    return num1 + num2 + num3
}
sum(num1: 1, num2: 2, num3: 3)
```
- 3>如果一个参数不想成为外部参数,在标示符前加"_"
```
func sum(num1 num1 : Int, _ num2 : Int, num3 : Int) -> Int {
    return num1 + num2 + num3
}
sum(num1: 1, 3, num3: 3)
```

2.注意二: 默认参数

func makeCoffee(coffeeName : String = "拿铁") -> String {
    return"已经制作好一杯(coffeeName)"
}
makeCoffee("卡布奇诺")
makeCoffee()

3.注意三: 可变参数

func sumNum(nums : Int...) -> Int {
    var result = 0
    for num in nums {
        result += num
    }
    return result
}
sumNum(19, 20, 1, 3, 8, 15)

4.注意四: 传入(引用类型)

var aa = 10
var bb = 20
//默认情况下,形参是let类型func swapNum(var num1 : Int, var num2 : Int) {
    let temp = num1
    num1 = num2
    num2 = temp
}
//默认是值传递swapNum(aa, num2: bb)
aa//10
bb//20
//地址传递: 需要加关键字inout
func swapNum(inout num1 : Int, inout num2 : Int) {
    let temp = num1
    num1 = num2
    num2 = temp
}
swapNum(&aa, num2: &bb)
aa//20
bb//10

5.注意五: 函数的嵌套(不建议这样来写)

func test() {
    func demo() {
        func operation() {
           
        }
    }
}

类

介绍
- 定义类: class 类名 : SuperClass {定义属性和方法}
注意
- 可以没有父类,那么该类是rootClass
- 通常情况下,定义类时,继承自NSObject(非OC的NSObject)

类的使用

class Student : NSObject {
    //类的属性
    //**存储属性:
    //注意:
    //1>如果类型是结构体或者类,通常定义为可选类型
    //2>如果类型是基本数据类型,可以在定义时直接初始化为0或者0.0
    var name : String?
    var age : Int = 0
    var chineseScore : Double = 0.0
    var mathScore :Double = 0.0
    //**计算属性: 并不存储实际的值; 必须提供get方法
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) * 0.5
        }
        //可选的setter方法,并且在setter方法中有一个系统的标示符,用于记录外界传入的值
        //newValue: 用于记录外界传入的值
        set {
            print(newValue)
            //没有意义
            self.averageScore = newValue
        }
    }
   
    //类属性
    static var courseCount : Int = 0
   
}
//创建对象
//<__lldb_expr_37.Student: 0x7fb771f210b0>
//命名空间:__lldb_expr_282
//存储地址:0x7fff1b65d700
let stu = Student()

//设置或获取其中的值时,必须通过类名调用
Student.courseCount = 2

stu.name = "hyh"
stu.age = 10
stu.chineseScore = 98
stu.mathScore = 100
print(stu.averageScore)

//stu.averageScore = 100
print(stu.averageScore)

监听属性的改变

class Person : NSObject {
    //Swift中提供了属性监听器,可以监听属性的改变    var name : String? {
        //即将改变       
        //在willSet方法中,系统提供一个标示符        
        //newValue: 用于记录新传入的数据  
     
        //自定义newValue的名称       
        //willSet(new)
        willSet {
            print(name)//nil
            print(newValue)//Optional("hmj")
            //重命名后调用时
            print(new)
        }

        //已经改变       
        //在didSet方法中,系统提供一个标示符       
        //oldValue: 用户记录之前的值 
      
        //自定义oldValue的名称        
        //didSet(old)
        didSet {
            print(name)//Optional("hmj")
            print(oldValue)//nil
            //重命名后调用时
            print(old)
        }
    }
    var age : Int = 0
}

let p = Person()
p.name = "hmj"p.age = 18
//OC监听属性的改变: 重写set方法