阅读 601

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

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

假设现在有一个零售水果的在线商店,需要频繁的用到不同的重量单位,但是最终服务器都是以kg来计算和存储,所以需要频繁的将其他的重量单位转为kg来做为数据的存储,又需要频繁的将kg转换成其他的重量单位来作为显示。

存储属性和计算属性

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


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为基础单位的存储功能,同时实现其他单位的换算。

字面量协议

现在结构体可以通过初始化方法初始化:

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
	}
}

复制代码

现在就可以直接通过字面量初始化:

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实例的和:

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
复制代码

项目源码

项目源码

关注下面的标签,发现更多相似文章
评论