资讯专栏INFORMATION COLUMN

浅谈函数式编程

greatwhole / 2501人阅读

摘要:本文首发于泊浮目的简书前言一个风和日丽的下午我看着日常看代码做重构迁移看到这么段代码突然我看到了这样的代码看了这段代码我整个人都不好了首先是那火箭式的三个嵌套循环再者就是那些变量声明语句为了迭代他们我们不得不声明它一遍使用这样看起来似

本文首发于泊浮目的简书:https://www.jianshu.com/u/204...
1. 前言

一个风和日丽的下午,我看着日常看代码做重构迁移,看到这么段代码:

突然,我看到了这样的代码:

    private void getTopicsDiskSizeForSomeBroker(int brokerID, AdminClient admin, Map topicsSizeMap) throws ExecutionException, InterruptedException {
        DescribeLogDirsResult ret = admin.describeLogDirs(Collections.singletonList(brokerID));
        Map> tmp = ret.all().get();
        for (Map.Entry> entry : tmp.entrySet()) {
            Map tmp1 = entry.getValue();
            for (Map.Entry entry1 : tmp1.entrySet()) {
                DescribeLogDirsResponse.LogDirInfo info = entry1.getValue();
                Map replicaInfoMap = info.replicaInfos;
                for (Map.Entry replicas : replicaInfoMap.entrySet()) {
                    String topic = replicas.getKey().topic();
                    Long topicSize = topicsSizeMap.get(topic);
                    if (topicSize == null) {
                        topicsSizeMap.put(topic, replicas.getValue().size);
                    } else {
                        topicsSizeMap.put(topic, replicas.getValue().size + topicSize);
                    }
                }
            }
        }
    }

看了这段代码我整个人都不好了!

首先是那火箭式的三个嵌套for循环,再者就是那些变量声明语句.为了迭代他们,我们不得不声明它一遍...

2. 使用Stream
    public List getTopicDiskSize() {
        return getTopicPartitionReplicaInfo().entrySet().stream()
                .map(e -> new KafkaTopicInfoBO(e.getKey().topic(), e.getValue().size))
                .collect(Collectors.toList());

    }

    protected Map getTopicPartitionReplicaInfo() {
        Properties globalConf = zkConfigService.getProperties(ZkPathUtils.GLOBAL_CONFIG);
        Properties adminConfig = new Properties();
        adminConfig.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, globalConf.getProperty((ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG)));
        AdminClient adminClient = AdminClient.create(adminConfig);
        List brokerIds = zkConfigService.getChildByPath(kafkaIdsPath);
        return  brokerIds.stream()
                .map(Integer::valueOf)
                .map(Collections::singletonList)
                .map(adminClient::describeLogDirs)
                .map(DescribeLogDirsResult::all)
                .map(mapKafkaFuture -> {
                    try {
                        return mapKafkaFuture.get();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                })
                .map(Map::values)
                .flatMap(Collection::stream)
                .map(Map::values)
                .flatMap(Collection::stream)
                .map(e -> e.replicaInfos)
                .map(Map::entrySet)
                .flatMap(Collection::stream)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

这样看起来似乎好了一点.但是对于不熟悉函数式编程的同学来说,理解以上代码还是有点困难的.

接下来,先来简单讲一讲函数式编程.

3. 什么是函数式编程 3.1 一句话搞懂

就像来自数学中的代数

f(x)=5x^2+4x+3
g(x)=2f(x)+5=10x^2+8x+11
h(x)=f(x)+g(x)=15x^2+12x+14

函数式编程定义输入数据和输出数据相关的关系——数学表达式里面其实是在做一种映射(Mapping),输入的数据和输出的数据关系是什么样的,就是用来函数定义的.

3.2 直观感受:用代码举例
public class Quint{
    public static void main (String args[]){
        for (int i=0; i<25; i++){
            System.out.println(i*i);
        }
    }
}
(println (take 25 (map (fn [x] (*x x) (range)))))

简单解释一下上段Lisp代码:

range函数回返回一个从0开始的整数无穷列表

然后该列表会被传入map,针对列表中的每个元素,调用平方值的匿名函数,产生了一个无穷多的,包含平方值的列表

将列表传入take函数,仅仅返回前25个

println将接入的参数输出

4. 使用对函数式编程支持更好的Kotlin
    protected fun getTopicPartitionReplicaInfo(): Map {
        val globalConf = zkConfigService.getProperties(ZkPathUtils.GLOBAL_CONFIG)
        val adminConfig = Properties()
        adminConfig.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, globalConf.getProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG))
        val adminClient = AdminClient.create(adminConfig)
        val brokerIds = zkConfigService.getChildByPath(kafkaIdsPath)
        return brokerIds.stream()
                .mapToInt {
                    Integer.valueOf(it)
                }.let { intStream ->
                    adminClient.describeLogDirs(intStream.boxed().collect(Collectors.toList()))
                }.let { describeLogDirsResult ->
                    describeLogDirsResult.all()
                }.let { mapKafkaFutrue ->
                    mapKafkaFutrue.get()
                }.let { mapStream ->
                    mapStream.values
                }.let {
                    it.stream().map { e -> e.values }.flatMap { e -> e.stream() }.collect(Collectors.toList())
                }.flatMap {
                    it.replicaInfos.entries.toList()
                }.let { it ->
                    it.associateBy({ it.key }, { it.value })
                }
    }

代码看起来大差不差.但Kotlin的这些关键字写起来更方便.我们看下Java中map函数和Kotlin中let函数的签名:

     * Returns a stream consisting of the results of applying the given
     * function to the elements of this stream.
     *
     * 

This is an intermediate * operation. * * @param The element type of the new stream * @param mapper a non-interfering, * stateless * function to apply to each element * @return the new stream */ Stream map(Function mapper);

/**
 * Calls the specified function [block] with `this` value as its argument and returns its result.
 *
 * For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#let).
 */
@kotlin.internal.InlineOnly
public inline fun  T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

我们可以看到Java中的map是被限制在Stream API中的,而Kotlin的let并没有这种限制.

同时,我们也可以感受到,对于函数式编程的支持,明显是Kotlin更好一些——在Kotlin中,我们用一个()就可以表示函数,而Java则需要Interface来表示(在Java中,对象是一等公民).

如果读者有兴趣的话,可以尝试一下HaskellLisp(JVM上叫Clojure).这些都是纯函数式语言.

类似,Kotlin还有很多这种函数,被称为作用域函数,在这里罗列一下常用的函数:

let

run

also

apply

takeIf

takeUnless

repeat

5. 小结

在《架构整洁之道》中,有这么一个总结:

结构化编程是对程序控制权的直接转移的限制

面向对象编程是对程序控制权的间接转移的限制

函数式编程是对程序赋值操作的限制

如果说面向对象编程是对数据进行抽象,那么函数式编程则是对行为进行抽象.

5.2 函数式编程的三件套:

Map

Reduce

Filter

举个例子,面包和蔬菜map到切碎的操作上,再reduce成汉堡.

我们可以看到map和reduce不关心输入数据,它们只控制,并不是业务.控制是描述怎么干,而业务描述要干什么.

在本文中,我们只看到了map的身影——上面提到了,map对流中的每一个元素进行操作.

可能会有读者问let是啥,在本文的代码例子中,let针对整个流进行操作.

简单来说, Map && Reduce 对应了我们日常中用的循环,而Filter对应了If

5.3 优势 && 劣势

优势

无状态

并发无伤害

函数执行没有顺序上的问题

劣势

数据复制严重

5.4 应用场景

Python的装饰器模式

事件溯源:不记录最终状态,而是记录每一个事件.需要时,通过追溯(重新计算)事件来得出当前的状态.如:

数据库事务日志

版本控制器

比特币

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/76055.html

相关文章

  • 浅谈JavaScript的面向对象和它的封装、继承、多态

    摘要:会造成内存浪费的问题构造函数继承声明父类声明子类生成实例组合式继承组合式继承是汲取了两者的优点,既避免了内存浪费,又使得每个实例化的子类互不影响。 写在前面 既然是浅谈,就不会从原理上深度分析,只是帮助我们更好地理解... 面向对象与面向过程 面向对象和面向过程是两种不同的编程思想,刚开始接触编程的时候,我们大都是从面向过程起步的,毕竟像我一样,大家接触的第一门计算机语言大概率都是C语...

    MAX_zuo 评论0 收藏0
  • 浅谈Redux(之一):Middleware原理

    摘要:作为目前最火的模式实现之一,它有很多的点值得研究。这个函数既然要用于,也就是说它接收一个形式为的函数,对其一层层嵌套形式为。这个会在开始时发起一个,并在这个时发起另一个成功或失败的。为了方便起见,会返回这个让调用者可以等待。 Redux作为目前最火的Flux模式实现之一,它有很多的点值得研究。今天我们首先来看看它的Middleware。 熟悉Express或者koa的朋友对Middle...

    cocopeak 评论0 收藏0
  • SegmentFault 技术周刊 Vol.16 - 浅入浅出 JavaScript 函数编程

    摘要:函数式编程,一看这个词,简直就是学院派的典范。所以这期周刊,我们就重点引入的函数式编程,浅入浅出,一窥函数式编程的思想,可能让你对编程语言的理解更加融会贯通一些。但从根本上来说,函数式编程就是关于如使用通用的可复用函数进行组合编程。 showImg(https://segmentfault.com/img/bVGQuc); 函数式编程(Functional Programming),一...

    csRyan 评论0 收藏0
  • 浅谈 JavaScript 原型链

    摘要:数组的构造函数是原型链的指向与其他除以外的构造函数相同,的也指向顶级原型对象,每一个数组都是的实例,都指向。实例对象查找构造函数原型对象的方法一般会把对象共有的属性和方法都放在构造函数的原型对象上。 showImg(https://segmentfault.com/img/remote/1460000018998704?w=900&h=506); 阅读原文 概述 在 JavaScr...

    explorer_ddf 评论0 收藏0
  • 【前端早读会】每天记录前端学习的过程

    摘要:在这里使用学而思网校的录像设备,记录前端工程师每天学习的内容商城小程序分享人王聪视频插件开发分享人魏媛视频原理分享人李佳晓视频讲座优化实战分享人江芊视频文件操作分享人张凯视频一次性学会正则表达式分享人贺杰视频浅谈 在这里使用学而思网校的录像设备,记录前端工程师每天学习的内容: 2019-8-22 商城小程序codereview 分享人:王聪 视频:https://lecture.xue...

    tylin 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<