Swift3.0温习之基础篇

前言:

重新系统的温习一下swift3.0的东西，因为一两个月不用，有的东西就记得不是太清楚了。以下整理了一些基础的知识，如果哪里写的有问题，还请指出我马上做修改。后续还会有一些关于swift的文章会持续更新，如果有兴趣请关注我。

目录

  • 函数使用的注意事项

  • 类的使用

  • 闭包

  • 懒加载

  • 自定义Log信息

一、函数

使用注意一

  • 函数的参数，内部参数和外部参数。
    • 内部参数：在函数内部可以看的见的参数是内部参数，默认都是内部参数。
    • 外部参数：就是外部可以看见的参数，为外部参数。默认从参数的第二个开始都是外部参数。
//有返回值的函数
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2;
}


//不带默认参数的函数
func makeEatFood(foodName: String) -> String {
    return "吃了\(foodName)"
}

使用注意二

使用注意三

  • 可变参数：在参数的后面添加...，表示可变参数。
//可变参数
func makeEatFood(foodName: String ...) -> String {
    return "吃了\(foodName)"
}

makeEatFood(foodName: "河牛","海鱼","马沙")

使用注意四

  • 函数的指针：使用关键字func swap( a : inout Int, b : inout Int){}
//函数指针,交换两个变量的值
var a = 50
var b = 100

func swap( a : inout Int, b : inout Int){
    let temp = a
    a = b
    b = temp
}

swap(&a, &b)

print("a:\(a), b:\(b)")

使用注意五

  • 函数的嵌套使用
//函数嵌套使用
func nestTest(){
    
    func test1(){
        print("test1")
    }
    
    print("nestTest")//这里先被调用:1
    //这里调用test1()的打印情况是:先打印nestTest,再打印 test1()
    test1()//:2
}

//这里调用的时候，只会打印nestTest,因为并没有调用test1()这个方法
nestTest()

二、类

类的创建:class

  • 分为继承自NSObject和不继承自NSObject。
class Person{
    var age : Int = 0
}

let p = Person()

p.age = 20


class Person : NSObject {
    var age : Int = 0
    //这时下面的代码就非常的有用，否则就会报错
    override func setValuesForKeys(_ keyedValues: [String : Any]) {
        
    }
}

let p = Person()

p.age = 20
//正常的情况下
//p.setValuesForKeys(["age" : 100])

//不正常的情况下处理，添加没有属性到类属性中
p.setValuesForKeys(["age" : 100, "name" : "marlonxlj"])
p.age

类的属性,定义就不再做详细介绍

  • 存储属性
  • 类属性
  • 计算属性
class Student: NSObject {
    //定义属性，需要做初始化
    var age : Int = 0
    //可选类型
    var name : String?
    
    var englishScore : Double = 0.0
    var chineseScore : Double = 0.0
    
    //计算属性
    var averScore : Double {
        return (englishScore + chineseScore) * 0.5
    }
    
    //类属性,一般用来定义单例
    static var stuCount : Int = 0
}

//给类属性赋值
Student.stuCount = 5

//创建对象
let stu = Student()
//给对象赋值
stu.age = 10
stu.name = "marlonxlj"

print(stu.age)

//对可选包进行解包
if let name = stu.name{
    print(name)
}

stu.englishScore = 80
stu.chineseScore = 50
print("\(stu.averScore)")

类的构造函数

  • 构造函数类似于oc中的初始化方法:init
  • 默认情况下创建一个类时，必然会调用一个构造函数
  • 即便没有写任何的构造函数，编译器也会提供一个默认的构造函数
  • 如果继承自NSObject可以对父类的构造函数进行重写

构造函数的基本使用

  • 类的属性必须有值
  • 如果不是在定义时初始化值，可以在构造函数中赋值
class Person : NSObject {
    var name : String?
    var age : Int = 0
    
    override init() {
        //在构造函数中，如果没有明确super.init(),那么系统会默认帮我们调用
        //super.init()
        print("++++++")
    }
    
    //自定义构造函数
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
 
    
    init(dict : [String : AnyObject]) {
       let tempName = dict["name"]
        //as? 最终会转换成一个可选类型
       name = tempName as? String
       
        
        let tempAge = dict["age"]
        //as! 会转称成一个确定的类型,这里有一个强制解包的问题
        
        let tempAge1 = tempAge as! Int
        if tempAge1 != nil {
            age = tempAge1
        }
 
        if let tempAge = dict["age"] as? Int {
            age = tempAge
        }
        
        
let p = Person()

let p1 = Person(name: "marlonxlj", age: 25)

print(p1.age)
print(p1.name)

属性监听器

class Person : NSObject {
    //属性监听器
    var totalSteps : String? {
        
        willSet{
            print(totalSteps)
//            print(newValue)
        }
        
        didSet{
            print(totalSteps)
//            print(oldValue)
        }
        
    }
    
    
}
let p = Person()

p.totalSteps = "marlonxlj"
p.totalSteps = "xiaoming"

三、闭包

  • 闭包和OC中的block非常相似
  • OC中的block是匿名的函数
  • swift中的闭包是一个特殊的函数
  • block和闭包都经常用于回调

//闭包赋值
var multipyClouser: (Int, Int) -> Int

multipyClouser = { (a: Int, b: Int) -> Int in return a * b}

let result = multipyClouser(4, 2)

print("result: \(result)")

//闭包函数:完整写法

var multiplyClosureTola = { (a: Int, b: Int) -> Int in a * b}

let rest = multiplyClosureTola(3,5)
print("mutlip:\(rest)")

//函数实例
func opeartionNum(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
    let restl = operation(a, b)
    print(restl)
    
    return restl
}

//定义一个闭包
let addClouse = { (a: Int, b: Int) in a + b}

opeartionNum(4, 5, operation: addClouse)

闭包循环引用的解决方法：

  • 第一种使用weak来解决:
weak var weakself = self
  • 第二种使用unowned:[unowned self]
    self.view.backgroundColor = UIColor.redColor()
  • 第三种使用 weak self
    self?. view.backgroundColor = UIColor.redColor

尾随闭包:如果闭包作为方法的最后一个参数，那么闭包可以将()省略掉

  • 1.普通写法: loadData ({})
  • 2.写法一: loadData() {}
  • 3.写法二: loadData {}

四、懒加载

  • 格式
lazy var 变量: 类型 = {创建变量代码}()
  • 懒加载的使用
//定义了一个array数组的懒加载
    lazy var array: [String] = {
        () -> [String] in return ["marlonxlj", "marlon", "marlonxxx"]
    }()

extension类似OC的category,只能扩充方法，不能扩充属性

自定义log信息

func MXLog<T>(message:T, fileName: String = #file, funcName: String = #function, lineNum: Int = #line){
    
    #if DEBUG
        let filePath = (fileName as NSString).lastPathComponent
        print("[\(filePath)]:\(funcName):line:\(lineNum)] -- \(message)")
    #endif
    
}

🐼🐶🐶如果对你有帮助，或觉得可以。请右上角star一下，这是对我一种鼓励，让我知道我写的东西有人认可，我才会后续不断的进行完善。

有任何问题或建议请及时issues me，以便我能更快的进行更新修复。

Email: marlonxlj@163.com

posted @ 2017-02-26 16:37  marlonxlj  阅读(496)  评论(0)  编辑  收藏  举报