iOS 中的链式编程函数式编程入门

Posted 2021-04-12 昊卓集团

iOS 中的链式编程、函数式编程入门

对一个程序猿来说，从一开始接触编程后会逐渐经历好几个不同的编程思想。包括过程式编程、面向对象编程、响应式编程、函数式编程、链式编程等等。

过程式编程的特点是随着程序的编写逐步进行，写到哪儿运行到哪儿。

面向对象的特点是万物皆对象。很著名的例子：把大象放进冰箱。

响应式编程的特点是一方触发，多方响应。OC中的KVO、通知中心就是这种。触发者只负责触发，不理会结果。

函数式编程的特点是将函数作为一等公民，当作参数和返回值使用。典型的如OC和Swift 中的 map函数、fiflt函数、reduce函数等。每个函数的处理结果给到下一个函数，最后的结果由自身函数调出。

链式编程的特点是运用点语法将很多个函数串联起来。典型的例子是OC中的Masnary和Swift 中的Snpkit。

这篇文章主要介绍函数式编程和链式编程的实现

链式编程

链式编程的特点是使用点语法将对象的多个函数连起来调用。就像这样

    obj.func1(par).func2
    (par).func3(par)

以一个例子来实现。假设我需要做一个字符串处理的扩展，其中包涵拼接字符、删除最后一个字符、修改最后一个字符这三个功能。在OC和Swift 中，这些函数都有现成，但是我想它们能够联合起来调用。假设我已经给这三个函数分别去名字叫：addString,

removeLastString,


alterLastString.

而我想像下面这样调用：

 NSString *str = @
 "abcdefg"；
 NSString *newStr = str.
 addString(@"123").
 removeLastString().add
 (@"555"). alter 
 LastString
 ("*")  NSLog(@"%@",
 newStr )；

最后输出的结果是:abcdefg1255*.这个应该很容易理解了。
接下来我分别使用OC和Swift来实现。

在OC中（链式编程）

新建一个工具类StringManegeTool，这个类包涵了一个初始化的函数：initWithString以及一个启动函数doSomething.并且包含了若干个block做为属性，以便使用点语法。

////  StringManegeTool.h
//  funTest////  Created
 by JD on 2017/11/4.//  
 Copyright © 2017年 JD.
 All rights reserved.//
 #import <Foundation/
Foundation.h>@class 
StringManegeTool;typedef
StringManegeTool* (^
TESTBlock1)(NSString*);
typedef StringManegeTool*
(^TESTBlock2)(void);
@interface 
StringManegeTool: 
NSObject- (instancetype)
initWithString:(NSString*)
str; - (NSString*)doSomething:
(void (^)(StringManegeTool
*))maker;@property 
(nonatomic,copy) 
TESTBlock1
 addString;@property 
(nonatomic,copy) 
TESTBlock2
removeLastString;@property 
(nonatomic,copy) 
TESTBlock1
alertLastString;@end

.m文件中实现。在初始化方法中实现了block，并且在doSomthing中实现了调用block。

////  StringManegeTool.m
//  funTest////  Created 
by JD on 2017/11/4.//  
Copyright © 2017年 JD. 
All rights reserved.//
#import "StringManegeTool.
h"#import <Foundation/
Foundation.h>@interface 
StringManegeTool ()
@property(nonatomic,
strong) NSMutableString*
buffStr;@end@
implementation
StringManegeTool- 
(instancetype)
initWithString
:(NSString*)str{    self =
[super init];    if (self)
{        self.buffStr = 
[[NSMutableString alloc] 
initWithString:str];        __weak 
StringManegeTool *weakSelf
= self;   self.addString
= ^StringManegeTool *
(NSString *str) {            [weakSelf.
buffStr appendString:
str];            return
  weakSelf;        };                self.
  removeLastString =
   ^StringManegeTool *{            [weakSelf.
 buffStr 
 deleteCharactersInRange:
 NSMakeRange(weakSelf.
 buffStr.length-1, 1)];
       return  weakSelf;        };             self.alertLastString
     = ^StringManegeTool 
     *(NSString *str) {            [weakSelf.
 buffStr 
 replaceCharactersInRange
 :NSMakeRange(weakSelf.
 buffStr.length-1, 1) 
 withString:str];   
         return weakSelf;        };    }    return self; } - (NSString*)doSomething:
 (void (^)
 (StringManegeTool
 *))maker{        maker(self);   
  return self.buffStr; }@end

接下来我可以这样调用：

 StringManegeTool *tool
  = [[StringManegeTool 
  alloc] initWithString:
  @"abcdefg"];   NSString *newStr = 
  [tool doSomething:^
  (StringManegeTool 
  *make) {        make.addString(
  @"123").removeLastString
 ().addString(@"555").
 alertLastString(@"*");    }];     NSLog(@"%@",newStr); 打印结果//2017-11-04 
15:36:08.495 funTest[1661:
121049] abcdefg1255*

回忆一下Masnary。熟悉的味道！

再来看看Swift中如何实现链式编程

////StringManegeTool-
InSwift.swift//  
funTest////  Created
 by JD on 2017/11/4.//
   Copyright © 2017年 JD.
    All rights reserved.
    //import UIKitclass
 StringManegeToolInSwift: 
 NSObject {    var bufStr:String = 
 String()        convenience init(_
  withString:String){   
       self.init();   
 self.bufStr = withString    }     func doSomething(_ make:
(StringManegeToolInSwift)
  ->())->String{        make(self)        
  return self.bufStr    }        func addString(_ 
  string:String)->
  StringManegeToolInSwift
  {  self.bufStr.append
  (string)   return self    }      func remoLastString()->
 StringManegeToolInSwift{        let end  = self.
bufStr.endIndex        let start = self.
bufStr.index(before: end)                self.bufStr.
removeSubrange
(start..<end)
 return self    }     func alertLastString(_ 
 string:String) -> 
 StringManegeToolInSwift{  let end  = self.bufStr.
 endIndex  let start = self.bufStr.
 index(before: end)      
self.bufStr.
replaceSubrange
(start..<end, with: 
string)
        return self    }        /// 调用 class func actionDo(){        let tool = 
StringManegeToolInSwift.
init("abcdefg")                let newString =
 tool.doSomething { 
 (maker) in    maker.addString("123")
 .remoLastString()
 .addString
 ("555").alertLastString
 ("*")}                print(newString)    }//打印：         abcdefg1255* }

说实话，Swift写起来要简单太多了。

总结一下：ios中，链式编程的特点是调用返回值为自身的函数或者Block。再结合map等函数的映射转换，这样可以使得代码变的非常灵活。

函数式编程

我之前一直把函数式编程理解为高阶函数，其实这就是高阶函数。先看一个很典型的例子，照样，我们从CO开始。

    NSArray<NSString*>
 *arr = @[@"252",@"55541",
 @"2295",@"21"];      arr = [arr 
sortedArrayUsingComparator
:^NSComparisonResult(
NSString*  _Nonnull obj1,
 NSString*   _Nonnull obj2
 ) {        return obj1.
 length < obj2.length;    }];    NSLog(@"%@",arr); 打印：2017-11-04 16:41:
22.846
  funTest[2478:150288] (   
   252,    55541,    2295, 
      21)

这是一个数组排序的函数。我们经常把在函数中使用函数作为参数称作高阶函数（这实际上就是函数式编程的一种特质）。上面的排序函数中，我们将两个数组内的元素比较的结果拿来使用给我本体函数，实现排序的目的。下面这个函数可能回更加复杂一点：

 NSString *result = 
[self testWithStr:@"adcf" 
One:^BOOL(NSString *str)
{return [str 
isEqualToString
:@"111"]; } two:^NSString *(BOOL
 abool) {  return abool?
 @"相等":@"不相等";    }];    NSLog
 (@"%@",result);    //打印：    2017-11-08 09:24:49.
 011487+0800 funTest[7487
 :1779986] 不相等

它是一个字符判断函数，在第一个参数中，我们输入想要比较的字符，在第一个block中进行比较并返回一个bool值，这个bool值将使用在第二个block的参数中，第二个block是根据bool值返回需要比较的两个字符是否相等的描述。
那具体是怎么实现的呢？  根据这个函数的特点，第一个block的调用结果将被用在第二个block上，对于第二个block来讲，他的参数本身就不是固定的，而是由第一个block决定，由此我们应该能想到，第二个block的参数其实就是第一个block才对。实现如下：

- (NSString *)testWithStr
:(NSString *)str  One: 
(BOOL(^)(NSString* str))
one two:(NSString*(^)
(BOOL abool))Two{    
return Two(one(str)); }

如果是Swift，其实是及其相似的：

func testWith(Str:String,
 one:(String)->Bool,two:
 (Bool)->String) -> String
  {        return two(one
  (Str))    }//调用self.testWith
  (Str: "abc", one: { (str
  ) -> Bool in            return str ==
   "123"        }) { (abool) -> 
   String in            return abool?
   "相等":"不相等"        }

这里的确是函数式编程， 但是我们发现其中多了东西：虽然这里将一些函数作为另一函数的参数，但是，这些函数的返回值和参数都具有一定的关联，没错，上面的函数中，block one的返回值的类型恰恰是block two的参数类型。他们有一些必然的联系。这就涉及到了响应式编程的范畴，这里其实算是响应式函数编程，不在本文的范畴之内，有兴趣的可以自行了解，本文不做介绍.
但是无可厚非的是，这里我们可以看到函数式编程的特点：将函数做为参数来使用，这就使得函数本身具备更大的灵活性，通过参数函数适应不同的应用场景。
将函数配合泛型，又能继续扩大函数的灵活性。下面修改一下上面的例子看看泛型中的函数式编程：

func testWith<T:Comparable
>(_ obj:T, one:(T)->Bool,
two:(Bool)->String) -> 
String {        return 
two(one(obj))    }

调用

 let result = tool.
testWith("abc", one: 
{ (str) -> Bool in            return str
 == "123"        }) { (abool) -
 > String in            guard abool
  else{               
  return "不相等"            }           
   return "相等"        }                print(result)                let result2 =
    tool.testWith(5, 
    one: { (int) ->
     Bool in            return int
      == 5        }) { (abool) 
      -> String in            guard abool
       else{           
       return "不相等"            }           
        return "相等"        }                print(result2)

以上就是函数式编程结合泛型。

提一下我们经常听到的RAC，这是一个响应式函数编程，同时也会使用到泛型。 关于响应式编程， 我会在以后的文章中写出，同时将包含RAC的知识。