Swift-基本语法-字面量协议-运算符重载-函数式编程的综合实例

时间  2019-12-16
标签 swift 基本 语法 字面 协议 运算符 重载 函数 编程 综合 实例 栏目 Swift 繁體版
原文   原文链接

Swift相比于Objective-C的语法来说更加的酷炫，不过也更加的复杂的难懂，为了将Swift的各类语法可以穿插起来，作一个综合笔记，这里实现一个应用多种Swift特性来实现的小功能。git

假设如今有一个零售水果的在线商店，须要频繁的用到不一样的重量单位，可是最终服务器都是以kg来计算和存储，因此须要频繁的将其余的重量单位转为kg来作为数据的存储，又须要频繁的将kg转换成其余的重量单位来做为显示。github

存储属性和计算属性

这里采用封装为一个结构体的方式实现：编程

struct Kilogram {
	var kg: Double
	var lb: Double {
		set {
			self.kg = newValue * 0.45359237
		}
		get {
			self.kg * 2.20462262
		}
	}

	init(_ kg: Double) {
		self.kg = kg
	}
	
	init() {
		self.kg = 0
	}
}
复制代码

上面结构体中，只有kg是存储属性，而lb是计算属性，这样就实现咱们上面的需求：实现以kg为基础单位的存储功能，同时实现其余单位的换算。api

字面量协议

如今结构体能够经过初始化方法初始化：bash

var w1 = Kilogram()
var w2 = Kilogram(2)
print(w1.kg, w1.lb) // 0.0 0.0 
print(w2.kg, w2.lb) // 2.0 4.40924524 
复制代码

为了更方便的直接经过字面量初始化，能够实现对应类型的协议：服务器

struct Kilogram: ExpressibleByFloatLiteral, ExpressibleByIntegerLiteral, ExpressibleByStringLiteral, ExpressibleByNilLiteral {
	var kg: Double
	var lb: Double {
		set {
			self.kg = newValue * 0.45359237
		}
		get {
			self.kg * 2.20462262
		}
	}
	
	init(_ kg: Double) {
		self.kg = kg
	}
	
	init() {
		self.kg = 0
	}
	
	init(floatLiteral value: Double) {
		self.kg = value
	}
	
	init(integerLiteral value: Int) {
		self.kg = Double(value)
	}
	
	init(stringLiteral value: String) {
		self.kg = Double(value) ?? 0
	}
	
	init(nilLiteral: ()) {
		self.kg = 0
	}
}

复制代码

如今就能够直接经过字面量初始化：app

var w1: Kilogram = nil
var w2: Kilogram = "1"
var w3: Kilogram = 2
var w4: Kilogram = 3

print(w1.kg, w2.kg, w3.kg, w4.kg) // 0.0 1.0 2.0 3.0
复制代码

运算符重载

已知两个Kilogram的实例，求他们的重量和，并得转换为lb是多少：函数式编程

var w1: Kilogram = 3
var w2: Kilogram = 4

var sum = w1.kg + w2.kg
var w3 = Kilogram(sum)
print(w3.kg, w3.lb)
复制代码

Swift支持运算符重载，为Kilogram结构体添加如下方法：函数

static func + (v1: Kilogram, v2: Kilogram) -> Kilogram {
		Kilogram(v1.kg + v2.kg)
	}
	
	static func - (v1: Kilogram, v2: Kilogram) -> Kilogram {
		Kilogram(v1.kg - v2.kg)
	}
	
	static func * (v1: Kilogram, v2: Kilogram) -> Kilogram {
		Kilogram(v1.kg * v2.kg)
	}
	
	static func / (v1: Kilogram, v2: Kilogram) -> Kilogram {
		Kilogram(v1.kg / v2.kg)
复制代码

下面计算两个Kilogram实例的和：ui

var w1: Kilogram = 3
var w2: Kilogram = 4

var w3 = w1 + w2
print(w3.kg, w3.lb) // 7.0 15.432358339999999
复制代码

配合字面量协议支持复杂的运算：

var w1: Kilogram = 3
var w2: Kilogram = 4
var w3: Kilogram = 2

var w4 = w1 + w2 * w3 - 8 // 3 + 4 * 2 - 8 = 3
print(w4.kg, w4.lb) // 3.0 6.613867859999999
复制代码

枚举的关联值

Swift的枚举相比Objective-C增长很是多的新特性，关联值就是其中之一，关键值能够将枚举的成员值和其余类型的值关联并存储在一块儿，一样枚举也支持范型、方法（包括初始化方法）、属性（计算实例属性、计算类型属性、存书类型属性）。

按照零售水果的开发需求，须要封装一个水果类，这个水果类须要如下基本信息：名称和单价，而因为平台称重单位有两种，因此单价便可能是kg也多是lb，这里假设一种水果有且只有一种重量单位的计价方式。那么这个类按照Objective-C的设计方式，起码须要两个属性来表示单价：

typedef NS_ENUM(NSInteger, FruitPriceType) {
	FruitPriceByKg,
	FruitPriceByLb
};

@interface Fruit: NSObject

@property (nonatomic, assign) double price;
@property (nonatomic, assign) FruitPriceType priceType;

@end
复制代码

经过Swift枚举类型关联值，只须要一个属性就能够实现：

class Fruit {
    enum Price<Double> {
        case kg(Double)
        case lb(Double)
    }
    
    var name: String
    var price: Price<Double>
    init(name: String, price: Price<Double>) {
        self.name = name
        self.price = price
    }
}
复制代码

在须要计算总价时，只须要判断枚举的类型，取出对应关联值便可：

var apple = Fruit(name: "🍎", price: .lb(3))
var appleWeight: Kilogram = 10

func originalPrice(_ fruit: Fruit, _ weight: Kilogram) -> Double{
    switch fruit.price {
    case let .kg(kg):
        return kg * weight.kg
    case let .lb(lb):
        return lb * weight.lb
    }
}

var price = originalPrice(apple, appleWeight)
print(price)  // 66.13867859999999
复制代码

函数式编程

下面开始实现水果的总价计算，当用户选择了必定重量的水果，须要根据重量计算出须要支付的总价，假如计算总价的规则以下：

单价 * 重量 * 折扣率 - 优惠金额

这里假设有以下几个拆分的计算总价的分步方法：

/// 原价 = 单价 * 重量
func originalPrice(_ weight: Kilogram, _ fruit: Fruit) -> Double{
    switch fruit.price {
    case let .kg(kg):
        return kg * weight.kg
    case let .lb(lb):
        return lb * weight.lb
    }
}

/// 折扣价 = 原价 * 折扣率
func discountPrice(_ originPrice: Double, _ rate: Double) -> Double {
    return originPrice * rate
}

/// 最终价 = 折扣价 - 优惠金额
func reductionPrice(_ discountPrice: Double, _ reduction: Double) -> Double {
    return discountPrice - reduction
}
复制代码

假如当前苹果的单价为3/lb，折扣为0.9，优惠金额固定为3，那么10kg苹果的价格计算以下：

var apple = Fruit(name: "🍎", price: .lb(3))
var appleWeight: Kilogram = 10

var price = reductionPrice(discountPrice(originalPrice(apple, appleWeight), 0.9), 3) // 56.52481073999999
复制代码

这样的方法调用会嵌套不少层，可读性差，而且很难体现出计算过程。

下面将上面三个分步计算方法分别重写为如下三个方法：

func originalPrice(_ fruit: Fruit) -> (_ weight: Kilogram) -> Double {
    {
        weight in
        switch fruit.price {
        case let .kg(kg):
            return kg * weight.kg
        case let .lb(lb):
            return lb * weight.lb
        }
    }
}

func discountPrice(_ rate: Double) -> (_ originPrice: Double) -> Double {
    {
        originPrice in
        rate * originPrice
    }
}

func reductionPrice(_ reduction: Double) -> (_ discountPrice : Double) -> Double {
    {
        discountPrice in
        discountPrice - reduction
    }
}
复制代码

将每个方法都重写为传入一个参数，返回一个须要传入一个参数而且有一个返回值的方法。

以originalPrice方法为例：

func originalPrice(_ weight: Kilogram, _ fruit: Fruit) -> Double{
    switch fruit.price {
    case let .kg(kg):
        return kg * weight.kg
    case let .lb(lb):
        return lb * weight.lb
    }
}

func originalPrice(_ fruit: Fruit) -> (_ weight: Kilogram) -> Double {
    {
        weight in
        switch fruit.price {
        case let .kg(kg):
            return kg * weight.kg
        case let .lb(lb):
            return lb * weight.lb
        }
    }
}
复制代码

原方法须要传入水果实例和重量两个参数，返回对应的原价。重写后方法改成：传入水果实例，返回一个函数，这个函数传入重量，而且返回原价。这样至关于将一个函数拆分为两步返回，第一步返回一个函数，由第一步返回的函数完成最终的函数功能：

var price = originalPrice(apple, appleWeight) // 66.13867859999999

var fn = originalPrice(apple)
price = fn(appleWeight) // 66.13867859999999
复制代码

接下来，在建立一个自定义运算符，功能就是将两个函数合并成一个函数：

infix operator >>> : AdditionPrecedence
func >>><A, B, C>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C {
    {
        a in
        f2(f1(a))
    }
}
复制代码

将上面三个函数的计算过程，合并成一个函数：

var applePriceFuction = originalPrice(apple) >>> discountPrice(0.9) >>> reductionPrice(3)
复制代码

接下来，计算10kg苹果的重量，只须要一行代码就能够完成：

var price = applePriceFuction(10) // 56.52481073999999
复制代码

柯里化

上面将三个函数分别重写后的形式，就是函数的柯里化。这里将上面三个函数和自定义运算符函数，分别作语法糖的代码简化：

func originalPrice(_ fruit: Fruit) -> (Kilogram) -> Double {
    {
        switch fruit.price {
        case let .kg(kg):
            return kg * $0.kg
        case let .lb(lb):
            return lb * $0.lb
        }
    }
}

func discountPrice(_ rate: Double) -> (Double) -> Double {{ rate * $0 }}

func reductionPrice(_ reduction: Double) -> (Double) -> Double {{ $0 - reduction }}

infix operator >>> : AdditionPrecedence
func >>><A, B, C>(_ f1: @escaping (A) -> B, _ f2: @escaping (B) -> C) -> (A) -> C { { f2(f1($0)) } }
复制代码

上面三个函数其实目的都是将一个传入两个参数的函数，柯里化成传入一个参数，返回一个须要一次参数的函数，而函数的实际过程自己就是原函数的执行步骤，惟一不一样的就是函数参数类型不一样而已。针对这个共性，能够将函数柯里化过程，封装为一个函数：

prefix func ~<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
    {
        b in
        {
            a in
            fn(a, b)
        }
    }
}
复制代码

该方法传入一个有两个参数和一个返回值的函数，A、B、C三个范型为传入参数的两个参数和一个返回值的类型。返回一个新的函数，新的函数有一个参数和一个返回值。新的函数参数类型为原函数第二个参数的类型。新的函数的返回值是一个须要传入一个参数的函数，该函数传入的参数类型为原函数第一个函数的类型，返回值类型为原函数的返回值类型。

这个函数的做用就是：将须要两个A类型、B类型参数，并返回C类型值的原函数Z，转变成另外一个函数X。X函数只有一个B类型参数，而且返回一个须要传入A类型参数，而且返回C类型值的函数Y。在函数Y中，将X函数的B类型参数b，和Y函数中的A类型参数a，做为原函数Z的两个参数，调用原函数Z，而且返回C类型的返回结果。

将原来的分步柯里化函数都删除或者注释掉，直接使用柯里化函数来柯里化对应的函数，并将返回的函数直接组合：

var applePriceFuction = (~originalPrice)(apple) >>> (~discountPrice)(0.9) >>> (~reductionPrice)(3)

print(applePriceFuction("5")) // 26.762405369999996
print(applePriceFuction(4.5)) // 23.786164832999997
print(applePriceFuction(10)) // 56.52481073999999
复制代码

项目源码

项目源码

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程