Scala学习-函数柯里化、闭包、递归

闭包

函数式编程的标配

如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包

object Test{
    def main(args: Array[String]): Unit = {
        def add(a: Int, b: Int): Int = {
            a + b
        }

        //1.固定一个考虑加数场景
        def addByFour(b: Int): Int = {
            4 + b
        }

        //2.扩展固定加数改变的情况
        def addByFive(b: Int): Int = {
            5 + b
        }

        //3.将固定加数作为另一个参数传入，但是作为“第一层参数“传入””-
        def addByA(a: Int): Int => Int = a + _


        println(addByA(10)(10)
    }
}

函数柯里化

把一个参数列表的多个参数，变成多个参数列表

def addByA(a: Int): Int => Int = a + _
//柯里化：
    def addCurrying(a: Int)(b: Int): Int = {
        a + b
   }
    println(addCurrying(32)(21))

递归(更消耗计算机资源)

递归算法

1.方法调用自身

2.方法必须要有跳出的逻辑

3.方法调用自身时，传递的参数应该有规律

4.Scala中的递归必须声明函数返回值

object TestFunction{
    def main(args: Array[String]): Unit = {

        //递归阶乘
        def fact(n: Int): Int = {
            if(n == 0) return 1
            fact(n - 1) * n
         }
        //尾递归:让loop栈每次被自己所覆盖
        def tailFact(n: Int): Int = {
            @tailrec //注解,判断是否写正确
            def loop(n: Int, currRes: Int): Int = {
                if(n == 0) return currRes
                loop(n - 1,currRes * n)
            }
            loop(n, 1)
        }
    }
}