精华内容
下载资源
问答
  • 命令式编程与函数式编程

    千次阅读 2017-11-09 23:05:26
    命令式编程命令式编程(英语:Imperative programming),是一种描述电脑所需作出的行为的编程典范。几乎所有电脑的硬件工作都是指令式的;几乎所有电脑的硬件都是设计来运行机器码,使用指令式的风格来写的。较高级...

    命令式编程

    命令式编程(英语:Imperative programming),是一种描述电脑所需作出的行为的编程典范。几乎所有电脑的硬件工作都是指令式的;几乎所有电脑的硬件都是设计来运行机器码,使用指令式的风格来写的。较高级的指令式编程语言使用变量和更复杂的语句,但仍依从相同的典范。食谱和行动清单,虽非计算机程序,但与命令式编程有相似的风格:每步都是指令,有形的世界控制情况。因为命令式编程的基础观念,不但概念上比较熟悉,而且较容易具体表现于硬件,所以大部分的编程语言都是指令式的。

    大部分的高级语言都支持四种基本的语句:

    运算语句:一般来说都表现了在内存内的数据进行运算的行为,然后将结果存入内存中以便日后使用。高级命令式编程语言更能处理复杂的表达式,可能会产生四则运算和函数计算的结合。

    循环语句容许一些语句反复运行数次。循环可依据一个默认的数目来决定运行这些语句的次数;或反复运行它们,直至某些条件改变。

    条件分支语句容许仅当某些条件成立时才运行某个区块。否则,这个区块中的语句会略去,然后按区块后的语句继续运行。

    无条件分支语句容许运行顺序转移到程序的其他部分之中。包括跳跃(在很多语言中称为Goto)、副程序和Procedure等。

    循环、条件分支和无条件分支都是控制流程。

    说白了,命令式编程就是让机器按照规定的命令执行下去。

    函数式编程

    函数式编程(英语:functional programming)或称函数程序设计,又称泛函编程,是一种编程典范,它将电脑运算视为数学上的函数计算,并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算(lambda calculus)。而且λ演算的函数可以接受函数当作输入(引数)和输出(传出值)。

    它属于”结构化编程”的一种,主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说,现在有这样一个数学表达式:

      (1 + 2) * 3 - 4
    

    传统的过程式编程,可能这样写:

      var a = 1 + 2;
    
      var b = a * 3;
    
      var c = b - 4;
    

    函数式编程要求使用函数,我们可以把运算过程定义为不同的函数,然后写成下面这样:

      var result = subtract(multiply(add(1,2), 3), 4);
    

    这就是函数式编程。

    函数式编程中的函数这个术语不是指计算机中的函数(实际上是Subroutine),而是指数学中的函数,即自变量的映射。也就是说一个函数的值仅决定于函数参数的值,不依赖其他状态。比如sqrt(x)函数计算x的平方根,只要x不变,不论什么时候调用,调用几次,值都是不变的。

    比起命令式编程,函数式编程更加强调程序执行的结果而非执行的过程,倡导利用若干简单的执行单元让计算结果不断渐进,逐层推导复杂的运算,而不是设计一个复杂的执行过程。

    函数式编程的特点

    函数式编程近些年异军突起,又重新回到了人们的视线,并得到蓬勃发展。总结起来,无外乎如下好处:

    1.减少了可变量(Immutable Variable)的声明,程序更为安全。
    2.相比命令式编程,少了非常多的状态变量的声明与维护,天然适合高并发多现成并行计算等任务,这也是函数是编程近年又大热的重要原因。
    3.代码更为简洁,可读性更强,对强迫症的同学来说是个重大福音。

    展开全文
  • 命令式编程vs声明式编程

    千次阅读 2016-07-13 15:08:32
     先统一一下概念,我们有两种编程方式:命令式和声明式。  我们可以像下面这样定义它们之间的不同: 命令式编程:命令“机器”如何去做事情(how),这样不管你想要的是什么(what),它都会按照你的命令实现。 声明...

     英文原文:Imperative vs Declarative
      先统一一下概念,我们有两种编程方式:命令式和声明式。
      我们可以像下面这样定义它们之间的不同:

    • 命令式编程:命令“机器”如何去做事情(how),这样不管你想要的是什么(what),它都会按照你的命令实现。
    • 声明式编程:告诉“机器”你想要的是什么(what),让机器想出如何去做(how)。

    声明式编程和命令式编程的代码例子举个简单的例子,假设我们想让一个数组里的数值翻倍。

    1.我们用命令式编程风格实现,像下面这样:

    var numbers = [1,2,3,4,5]
    var doubled = []
    for(var i = 0; i < numbers.length; i++) {
      var newNumber = numbers[i] * 2
      doubled.push (newNumber)
    }
    console.log (doubled) //=> [2,4,6,8,10]

      我们直接遍历整个数组,取出每个元素,乘以二,然后把翻倍后的值放入新数组,每次都要操作这个双倍数组,直到计算完所有元素。

    2.而使用声明式编程方法,我们可以用 Array.map 函数,像下面这样:

    var numbers = [1,2,3,4,5]
    var doubled = numbers.map (function (n) {
      return n * 2
    })
    console.log (doubled) //=> [2,4,6,8,10]

      map利用当前的数组创建了一个新数组,新数组里的每个元素都是经过了传入map的函数(这里是function (n) { return n*2 })的处理。
      

      在一些具有函数式编程特征的语言里,对于 list 数据类型的操作,还有一些其他常用的声明式的函数方法。例如,求一个list里所有值的和,命令式编程会这样做:

    var numbers = [1,2,3,4,5]
    var total = 0 
    for(var i = 0; i < numbers.length; i++) {
      total += numbers[i]
    }
    console.log (total) //=> 15
    //而在声明式编程方式里,我们使用reduce函数:
    var numbers = [1,2,3,4,5]
    var total = numbers.reduce (function (sum, n) {
      return sum + n
    });
    console.log (total) //=> 15

      reduce函数利用传入的函数把一个list运算成一个值。它以这个函数为参数,数组里的每个元素都要经过它的处理。每一次调用,第一个参数(这里是sum)都是这个函数处理前一个值时返回的结果,而第二个参数(n)就是当前元素。这样下来,每此处理的新元素都会合计到sum中,最终我们得到的是整个数组的和。
      同样,reduce函数归纳抽离了我们如何遍历数组和状态管理部分的实现,提供给我们一个通用的方式来把一个list合并成一个值。我们需要做的只是指明我们想要的是什么?
      
     3.声明式编程很奇怪吗?
      
      如果你之前没有听说过map和reduce函数,你的第一感觉,我相信,就会是这样。作为程序员,我们非常习惯去指出事情应该如何运行。“去遍历这个list”,“if 这种情况 then 那样做”,“把这个新值赋给这个变量”。当我们已经知道了如何告诉机器该如何做事时,为什么我们需要去学习这种看起来有些怪异的归纳抽离出来的函数工具?
      在很多情况中,命令式编程很好用。当我们写业务逻辑,我们通常必须要写命令式代码,没有可能在我们的专项业务里也存在一个可以归纳抽离的实现。

     声明式编程语言:SQL
     
      也许你还不能明白,但有一个地方,你也许已经用到了声明式编程,那就是SQL。
      你可以把 SQL 当做一个处理数据的声明式查询语言。完全用SQL写一个应用程序?这不可能。但如果是处理相互关联的数据集,它就显的无比强大了。
      像下面这样的查询语句:

    SELECT * from dogs
    INNER JOIN owners
    WHERE dogs.owner_id = owners.id
      如果我们用命令式编程方式实现这段逻辑:
    //dogs = [{name: 'Fido', owner_id: 1}, {...}, ... ]
    //owners = [{id: 1, name: 'Bob'}, {...}, ...] var dogsWithOwners = []
    var dog, owner
    for(var di=0; di < dogs.length; di++) {
      dog = dogs[di]
      for(var oi=0; oi < owners.length; oi++) {
        owner = owners[oi]
        if (owner && dog.owner_id == owner.id) {
          dogsWithOwners.push ({
            dog: dog,
            owner: owner
          })
        }
      }}
    }

      我可没说SQL是一种很容易懂的语言,也没说一眼就能把它们看明白,但基本上还是很整洁的。
      SQL代码不仅很短,不不仅容易读懂,它还有更大的优势。因为我们归纳抽离了how,我们就可以专注于what,让数据库来帮我们优化how。
      我们的命令式编程代码会运行的很慢,因为需要遍历所有list里的每个狗的主人。
      而SQL例子里我们可以让数据库来处理how,来替我们去找我们想要的数据。如果需要用到索引(假设我们建了索引),数据库知道如何使用索引,这样性能又有了大的提升。如果在此不久之前它执行过相同的查询,它也许会从缓存里立即找到。通过放手how,让机器来做这些有难度的事,我们不需要掌握数据库原理就能轻松的完成任务.
      
    声明式编程:d3.js
      另外一个能体现出声明式编程的真正强大之处地方是用户界面、图形、动画编程。
      开发用户界面是有难度的事。因为有用户交互,我们希望能创建漂亮的动态用户交互方式,通常我们会用到大量的状态声明和很多相同作用的代码,这些代码实际上是可以归纳提炼出来的。
      d3.js 里面一个非常好的声明时归纳提炼的例子就是它的一个工具包,能够帮助我们使用JavaScript和SVG来开发交互的和动画的数据可视化模型。
      第一次(或第5次,甚至第10 =次)你开发d3程序时可能会头大。跟SQL一样,d3是一种可视化数据操作的强大通用工具,它能提供你所有how方法,让你只需要说出你想要什么。
      下面是一个例子(我建议你看一下这个演示)。这是一个d3可视化实现,它为data数组里的每个对象画一个圆。为了演示这个过程,我们每秒增加一个圆。
      里面最有趣的一段代码是:

    //var data = [{x: 5, y: 10}, {x: 20, y: 5}]
    var circles = svg.selectAll('circle')
                        .data(data)
    circles.enter().append('circle')
               .attr('cx', function(d) { return d.x })
               .attr('cy', function(d) { return d.y })
               .attr('r', 0)
            .transition().duration(500)
              .attr('r', 5)

      没有必要完全理解这段代码都干了什么(你需要一段时间去领会),但关键点是:
      首先我们收集了svg里所有的圆,然后把data数组数据绑定到对象里。
      D3对每个圆都绑定了那些点数据有一个关系表。最初我们只有两个点,没有圆,我们使用.enter()方法获取数据点。这里,我们的意图是画一个圆,中心是x和y,初始值是0 ,半秒后变换成半径为5。
      为什么我说这很有意思?
      从头再看一遍代码,想一想,我们是在声明我们想要的图案是什么样子,还是在说如何作图。你会发现这里根本没有关于how的代码。我们只是在一个相当高的层面描述我们想要的是什么:
    我要画圆,圆心在 data 数据里,当增加新圆时,用动画表示半径的增加。
      这太神奇了,我们没有写任何循环,这里没有状态管理。画图操作通常是很难写,很麻烦,很让人讨厌,但这里,d3归纳提取了一些常用的操作,让我们专注于描述我们想要的是什么。
      现在再看,d3.js很容易理解吗?不是,它绝对需要你花一段时间去学习。而学习的过程基本上需要你放弃去指明如何做事的习惯,而去学会如何描述我想要的是什么。
      最初,这可能是很困难的事,但经过一些时间的学习后,一些神奇的事情发生了——你变得非常非常有效率了。通过归纳提取how,d3.js能让你真正的专注说明你想要看到的是什么,让你在一个个更高的层面解决问题,解放你的创作力。
      
    声明式编程的总结
      
      声明式编程让我们去描述我们想要的是什么,让底层的软件/计算机/等去解决如何去实现它们。
      在很多情况中,就像我们看到的一样,声明式编程能给我们的编程带来真正的提升,通过站在更高层面写代码,我们可以更多的专注于what,而这正是我们开发软件真正的目标。
      问题是,程序员习惯了去描述how,这让我们感觉很好很舒服——强力——能够控制事情的发生发展,不放走任何我们不能看见不能理解的处理过程。
      有时候这种紧盯着how不放的做法是没问题的。如果我需要对代码进行更高性能的优化,我需要对what进行更深一步的描述来指导how。有时候对于某个业务逻辑没有任何可以归纳提取的通用实现,我们只能写命令式编程代码。
      但大多数时候,我们可以、而且应该寻求声明式的写代码方式,如果没有发现现成的归纳提取好的实现,我们应该自己去创建。起初这会很难,必定的,但就像我们使用SQL和D3.js, 我们会长期从中获得巨大的回报!
      
    转自:http://kb.cnblogs.com/page/181030/

    展开全文
  • 声明式和命令式编程

    千次阅读 2018-06-29 09:50:09
    Aspect Oriented Programming...Declarative Programming(声明式编程)是和Imperative Programming(命令式编程)相对的概念。我们平时使用的编程语言,比如C++、Java、Ruby、Python等,都属于Imperative Programm...
    Aspect Oriented Programming(面向方面编程,简称AOP)是一种Declarative Programming(声明式编程)。Declarative Programming(声明式编程)是和Imperative Programming(命令式编程)相对的概念。我们平时使用的编程语言,比如C++、Java、Ruby、Python等,都属于Imperative Programming(命令式编程)。Imperative Programming(命令式编程)的意思是,程序员需要一步步写清楚程序需要如何做什么(How to do What)。Declarative Programming(声明式编程)的意思是,程序员不需要一步步告诉程序如何做,只需要告诉程序在哪些地方做什么(Where to do What)。比起Imperative Programming(命令式编程)来,Declarative Programming(声明式编程)是在一个更高的层次上编程。Declarative Programming编程语言是更高级的语言。Declarative Programming通常处理一些总结性、总览性的工作,不适合做顺序相关的细节相关的底层工作。
    




    如果说Imperative Programming是拼杀在第一线的基层工作人员,Declarative Programming就是总设计师、规则制定者。Declarative Programming Language的概念,和Domain Specific Language(领域专用语言,简称DSL)的概念有相通之处。DSL主要是指一些对应专门领域的高层编程语言,和通用编程语言的概念相对。DSL对应的专门领域(Domain)一般比较狭窄,或者对应于某个行业,或者对应于某一类具体应用程序,比如数据库等。


    最常见的DSL就是关系数据库的结构化数据查询语言SQL。同时,SQL也是一门Declarative Programming Language。SQL只需要告诉数据库,处理符合一定条件的数据,而不需要自己一步步判断每一条数据是否符合条件。SQL的形式一般是 select … where …,update … where …,delete … where …。当然,这样一来,很多基层工作,SQL做不了。因此,大部分数据库都提供了另外的Imperative Programming Language,用来编写Stored Procedure(存储过程)等,以便处理一些更加细节的工作。


    常见的DSL还有Rule Engine(规则引擎)语言、Workflow(工作流)语言等。Rule Engine和Workflow同时带有Imperative Programming和Declarative Programming的特点。Rule Engine允许用户按照优先级定义一系列条件组合,并定义对满足条件的数据的处理过程。Workflow也大致类似。Workflow把最基本的条件判断和循环语句的常见组合,定义为更加高级复杂的常用程序流程逻辑块。用户可以用这些高级流程块组合更加复杂的流程块,从而定义更加复杂的流程跳转条件。用户也可以定义当程序运行上下文满足一定条件的时候,应该做什么样的处理工作。Rule Engine和Workflow的语言形式有可能是XML格式,也有可能是Ruby、Python、Javascript等脚本格式。我个人比较倾向于脚本格式,因为XML适合表达结构化数据,而不擅长表达逻辑流程。当然,XML格式的好处也是显而易见的。解析器可以很容易分析XML文件的结构,XML定义的条件或者程序流程都可以很方便地作为数据来处理。


    介绍了Declarative Programming和DSL之后,我们来看本章题目表达的内容——AOP。AOP是Declarative Programming,AOP语言也可以看作是DSL。AOP语言对应的专门领域(Domain)就是程序结构的方方面面(Aspect),比如程序的类、方法、成员变量等结构,以及针对这些程序结构的通用工作处理,比如日志管理、权限管理、事务管理等。


    AOP处理的工作内容一般都是这样的一些总结性工作:“我想让所有的数据库类都自动进行数据库映射”、“我想打印出所有业务类的工作流程日志”、“我想给所有关键业务方法都加上事务管理功能”、“我想给所有敏感数据处理方法都加上安全管理授权机制”等等。
    下面我们介绍AOP的实现原理和使用方法。


    AOP实现原理


    AOP的实现原理可以看作是Proxy/Decorator设计模式的泛化。
    我们先来看Proxy模式的简单例子。
    Proxy {
        innerObject; // 真正的对象
        f1() {
            // 做一些额外的事情


            innerObject.f1(); // 调用真正的对象的对应方法


              // 做一些额外的事情
        }
    }


    在Python、Ruby等动态类型语言中,只要实现了f1()方法的类,都可以被Proxy包装。在Java等静态类型语言中,则要求Proxy和被包装对象实现相同的接口。动态语言实现Proxy模式要比静态语言容易得多,动态语言实现AOP也要比静态语言容易得多。假设我们用Proxy包装了10个类,我们通过调用Proxy的f1()方法来调用这10个类的f1()方法,这样,所有的f1()调用都会执行同样的一段“额外的工作”,从而实现了“所有被Proxy包装的类,都执行一段同样的额外工作”的任务。这段“额外的工作”可能是进行日志记录,权限检查,事务管理等常见工作。


    Proxy模式是可以叠加的。我们可以定义多种完成特定方面任务(Aspect),比如,我们可以定义LogProxy、SecurityProxy、TransactionProxy,分别进行日志管理、权限管理、事务管理。
    LogProxy {
          f1(){
                // 记录方法进入信息


                innerObject.f1();// 调用真正的对象的对应方法


              // 记录方法退出信息
        }
    }


    SecurityProxy {
          f1(){
              // 进行权限验证


              innerObject.f1();// 调用真正的对象的对应方法
          }
    }


    TransactonProxy {
          f1(){
              Open Transaction


              innerObject.f1();// 调用真正的对象的对应方法


              Close Transaction
          }
    }


    根据AOP的惯用叫法,上述的这些Proxy也叫做Advice。这些Proxy(or Advice)可以按照一定的内外顺序套起来,最外面的Proxy会最先执行。包装f1()方法,也叫做截获(Intercept)f1()方法。Proxy/Advice有时候也叫做Interceptor。


    看到这里,读者可能会产生两个问题。
    问题一:上述代码采用的Proxy模式只是面向对象的特性,怎么会扯上一个新概念“面向方面(AOP)”呢?
    问题二:Proxy模式虽然避免了重复“额外工作”代码的问题,但是,每个相关类都要被Proxy包装,这个工作也是很烦人。AOP Proxy如何能在应用程序中大规模使用呢?
    下面我们来解答着两个问题。


    对于问题一,我们来看一个复杂一点的例子。
    假设被包装对象有f1()和f2()两个方法都要被包装。
    RealObject{
          f1() {…}
          f2() {…}
    }


    这个时候,我们应该如何做?难道让Proxy也定义f1()和f2()两个方法?就象下面代码这样?
    Proxy {
        innerObject; // 真正的对象
        f1() {
            // 做一些额外的事情


            innerObject.f1(); // 调用真正的对象的对应方法


            // 做一些额外的事情
        }


        f2() {
            // 做一些额外的事情
           
            innerObject.f2(); // 调用真正的对象的对应方法
           
            // 做一些额外的事情
        }


    }


    这样做有几个不利之处。一是会造成代码重复,Proxy的f1()和f2()里面的“做一些额外的事情”代码重复。二是难以扩展,被包装对象可能有多个不同的方法,不同的被包装对象需要被包装的方法也可能不同。现在的问题就变成,“Proxy如何才能包装截获任何类的任何方法?”
    答案呼之欲出。对,就是Reflection。Java、Python、Ruby都支持Reflection,都支持Method(方法)对象。那么我们就利用Method Reflection编写一个能够解惑任何类的任何方法的Proxy/Advice/Interceptor。


    MethodInterceptor{


        around( method ){
            // 做些额外的工作
           
            method.invoke(…); // 调用真正的对象方法
           
            // 做些额外的工作
        }
    }


    上述的MethodInterceptor就可以分别包装和截获f1()和f2()两个方法。
    这里的method参数就是方法对象,在Java、Ruby等面向对象语言中,需要用Reflection获取方法对象。这个方法对象就相当于函数式编程的函数对象。在函数式编程中,函数对象属于“一等公民”,函数对象的获取不需要经过Reflection机制。所以,函数式编程对AOP的支持,比面向对象编程更好。由此我们看到,AOP对应的问题领域确实超出了OOP的力所能及的范围。OOP只能处理同一个类体系内的同一个方法签名的截获和包装工作,一旦涉及到一个类的多个不同方法,或者多个不同类体系的不同方法,OOP就黔驴技穷,无能为力了。
    使用Method Reflection的方式截获任何方法对象,是AOP的常用实现手段之一。另一个常见手段就是自动代码生成了。这也回答了前面提出的问题二——如何在应用系统中大规模使用AOP。


    Proxy Pattern + Method Reflection + 自动代码生成这样一个三元组合,就是AOP的基本实现原理。Proxy Pattern 和 Method Reflection,前面已经做了阐述,下面我们来讲解自动代码生成。


    首先,AOP需要定义一种Aspect描述的DSL。Aspect DSL主要用来描述这样的内容:“用TransactionProxy包装截获business目录下的所有类的公共业务方法”、“ 用SecurityProxy包装截获所有Login/Logout开头的类的所有公共方法”、“用LogProxy包装截获所有文件的所有方法”等等。Aspect DSL的形式有多种多样。有的是一种类似Java的语法,比如AspectJ;有的是XML格式或者各种脚本语言,比如,Spring AOP等。


    有了Aspect DSL,AOP处理程序就可以生成代码了。AOP生成代码有三种可能方式:
    (1)静态编译时期,源代码生成。为每个符合条件的类方法产生对应的Proxy对象。AspectJ以前就是这种方式。
    (2)静态编译时期,处理编译后的字节码。Java、Python之类的虚拟机语言都有一种中间代码(Java的中间代码叫做字节码),AOP处理程序可以分析字节码,并直接产生字节码形式的Proxy。这种方式也叫做静态字节码增强。AspectJ也支持这种方式。Java有一些开源项目,比如 ASM、Cglib等,可以分析并生成Java字节码。这些开源项目不仅可以静态分析增强字节码,还可以在程序运行期动态分析增强字节码。很多AOP项目,比如Spring AOP,都采用ASM/Cglib处理字节码。
    (3)动态运行时期,即时处理装载到虚拟机内部的类结构字节码。这也叫做动态增强。比如,Spring AOP。如前所述,Spring AOP使用ASM/Cglib之类的处理字节码的开源项目。Java运行库本身也提供了类似于ASM/Cglib的简单的动态处理字节码的API,叫做 Dynamic Proxy。


    以上就是AOP的实现原理:Proxy Pattern + Method Reflection + Aspect DSL + 自动代码生成。


    总体来说,实现AOP的便利程度,函数式编程语言 > 动态类型语言 > 静态类型语言。当然,这个不等式并不是绝对的。有些动态类型语言提供了丰富强大的语法特性,实现AOP的便利程度,可能要超过函数式编程语言。
    展开全文
  • 命令式和声明式开发的区别

    千次阅读 2018-07-13 19:23:49
    命令式开发:是关注计算机的执行步骤,告诉计算机一步一步怎么做然后计算机再一步步做声明式开发:是告诉计算机做什么,但不告诉计算机怎么命令式: js操作dom就是命令式,需要告诉计算机一步一步的怎么做 var dom...

    命令式开发:是关注计算机的执行步骤,告诉计算机一步一步怎么做然后计算机再一步步做

    声明式开发:是告诉计算机做什么,但不告诉计算机怎么

    命令式:

            js操作dom就是命令式,需要告诉计算机一步一步的怎么做

           

    var dom1 = document.querySelector('div');
    var input = document.querySelector('input');
    input.onChange = function () {
      var value = input.value;
      dom1.innerHTML = value;
    }
    

    声明式:

         vue就是属于声明式

        

      <div id="app">
      <p>{{ message }}</p>
    <input type="text" v-model="message">
      </div>
      <script>
    var app = new Vue({
      el: '#app',
      data: {
        message: 'hello world!'
      }
    })
    

    展开全文
  • 本来自以为已经了解了函数式编程,但当看到这篇文章时,才发现自己之前的见解有多么肤浅,因此决定重新整理有关声明式编程、命令式编程以及函数式编程相关的概念、以及知识点,方便未来某一时刻快速回忆以及使用。...
  • 命令式和声明式,哪个才是你的菜

    千次阅读 2017-06-01 16:13:57
    今天的主题是讨论一下“命令式”思想和“声明式”思想在分布式系统和微服务架构运维中的应用。主要大纲:1. “命令式”和“声明式”的概念 2. 命令式思想在分布式系统和微服务架构中遇到的困境 3. 以Kubernetes的...
  • 2.相比命令式编程,少了非常多的状态变量的声明与维护,天然适合高并发多现成并行计算等任务,这也是函数是编程近年又大热的重要原因。 3.代码更为简洁,可读性更强,对强迫症的同学来说是个重大福音。2.函
  • 命令式编程(imperative):喜欢大量使用可变对象和指令,我们总是习惯于创建对象或者变量,并且修改它们的状态或者值,或者喜欢提供一系列指令,要求程序执行。 声明式编程(Declarative):对于声明式的编程范式...
  • 函数式编程和命令式编程

    万次阅读 2011-05-16 23:28:00
    <br />所谓命令式编程,是以命令为主的,给机器提供一条又一条的命令序列让其原封不动的执行。程序执行的效率取决于执行命令的数量。因此才会出现大O表示法等等表示时间空间复杂度的符号。 <br />而函数...
  • 命令式编程和函数式编程的区别

    千次阅读 2012-11-07 20:23:45
    命令式编程和函数式编程的区别 第一次尝试翻译外国的技术文章,很担心自己的语言不够准确。尝试尝试,总要迈出这一步的!   你是否有过这样的沮丧经历?我要开车去一个我从来没去过的地方,于是我网上查看关于...
  • 命令式至函數式隨記(一)

    千次阅读 2012-10-19 07:33:25
    這一陣子練習函數式,隱隱約約發現從命令式過渡到函數式有一些模式可循,但還沒很能抓得住,在這邊略作筆記一下,另一方面,最近在看 MapReduce,也是隱隱約約感覺,這種模式,有助於使用 MapReduce 時對資料的分析...
  • 命令式编程 vs 符号式编程

    千次阅读 2018-07-01 13:14:32
    命令/符号编程的定义并不明确,CXXNet/Caffe因为依赖于配置文件,配置文件看作计算图的定义,也可以被当作符号编程 源 源网址 什么是symblic/imperative style编程 使用过python或C++对imperative ...
  • 命令式编程(Imperative programming),即利用命令式语言进行编程的方式,是一种描述计算机所需作出的行为的编程范型。命令式编程语言使用变量和更复杂的语句,但仍依从相同的范型。食谱和行动清单,虽非计算机程序,...
  • (翻译:常见的编程语言类型包括允许有副作用的命令式编程,不允许副作用的函数式编程和不描述操作执行顺序的声明式编程) A programming paradigm is a fundamental style of computer programming. There are ...
  • 然后要用命令把你正在运行的billing-v0.1-201904251734.jar 结束杀掉 命令: kill 16594  16594 为进程ID; 之后用命令执行你新上传上来的.jar包  java -jar billing-v0.1-201904251734.jar  这是运行.jar...
  • 作者 | Sunil Sandhu译者 | 弯月,责编 | 屠敏头图 | CSDN 下载自东方 IC出品 | CSDN(ID:CSDNnews)以下为译文:最初我想写一篇文章详细介绍命令...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 591,148
精华内容 236,459
关键字:

命令式