$02[Scala(函数式编程)]

最新推荐文章于 2024-07-26 16:01:19 发布
最新推荐文章于 2024-07-26 16:01:19 发布
阅读量164 收藏
点赞数
分类专栏： # scala语法 文章标签： scala 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52210776/article/details/125706148
版权

第一章.函数式编程

面向对象编程:

  • 解决问题,分解对象,行为,属性,然后通过对象的关系以及行为的调用来解决问题
  • 对象: 用户
  • 行为: 登录,连接Jdbc,读取数据库
  • 属性: 用户名,密码
  • Scala语言是一个完全面向对象编程语言,万物皆对象

函数式编程:

  • 解决问题时,将问题分解成一个一个的步骤,将每个步骤进行封装(函数),通过调用这些封装好的步骤,解决问题
  • 例如: 请求->用户名,密码->连接jdbc->读取数据库

在Scala中函数式编程和面向对象编程融合在一起了

1.方法定义语法

package com.atguigu.chapter05

object $01_MethodDefined {
  /**
   * 方法定义语法: def 方法名(参数名:参数类型,....):返回值类型={方法体}
   */
  def main(args:Array[String]): Unit={
    println(add(10,20))
  }
  def add(x:Int,y:Int):Int={
    x+y
  }

}

2.方法简化的原则

package com.atguigu.chapter05

object $02_MethodSample {
  /**
   * 方法简化的原则:
   *    1.如果方法使用方法体的块表达式的结果值作为方法的返回值,此时定义方法的时候方法的返回值类型可以省略
   *      注意:如果方法体中有return关键字,方法的返回值类型必须定义
   *    2.如果方法体只有一行语句,那么方法体的{}可以忽略
   *    3.如果方法不需要返回值,那么定义方法的时候=可以忽略  [=与{}不能同时忽略]
   */
  def main(args:Array[String]):Unit={
    println(add2(10,20))
    println(add3(10,20))
    printMsg2("hello")
    //1.如果定义方法的时候没有(),那么在调用方法的时候()也不能带上
    hello2
    //2.如果定义方法的时候有(),那么在调用方法的时候()可有可无
    hello()
    hello
  }

  //标准定义形式
  def add(x:Int,y:Int):Int={
    return x + y
  }
  //1.如果方法使用方法体的块表达式的结果值作为方法的返回值,此时定义方法的时候,方法的返回值类型可以忽略
  def add2(x:Int,y:Int)={
    x + y
  }
  //2.如果方法体只有一行语句,那么方法体的{}可以忽略
  def add3(x:Int,y:Int) = x + y

  //标准形式
  def printMsg(msg:String):Unit={
    println(s"msg=${msg}")
  }
  //3.如果方法不需要返回值,那么定义方法的时候=可以忽略[=与{}不能同时忽略]
  def printMsg2(msg:String){
    println(s"msg=${msg}")
  }
  //标准形式
  def hello():Unit={
    println("hello...........")
  }
  //4.如果方法不需要参数,那么定义方法的时候()可以忽略
  def hello2{
    println("hello2...........")
  }

}

3.方法参数

object $03_MethodParam {
  /**
   * scala方法的参数
   *    1.默认值参数,在调用方法的时候有默认值的参数可以不用传参数[默认值参数一般放在参数列表最后面]
   *        语法: def 方法名(参数名:类型[默认值],.....):返回值类型 = {方法体}
   *    2.带名参数:在调用方法的时候指定将参数值传给哪个参数
   *    3.可变参数:在调用方法的时候传递的参数的个数不固定
   *        语法: def 方法名(参数名:类型,...,参数名:类型*):返回值类型={方法体}
   *        scala可变参数不能直接传递集合,如果想要将集合所有元素传递给可变参数,可以通过 集合名:_*的方式传递
   */
    def main(args:Array[String]):Unit ={
      println(add(10))
      //带名参数
      println(add(x=4,y=6))
      val arr = Array[Int](10,20,30,40)
      println(sum(10,20,arr:_*))
    }




  //默认值参数
  def add(x:Int,y:Int=30) = x + y
  //可变参数
  def sum(x:Int,y:Int,z:Int*) = x + y + z.sum

}

需求: 统计前七天的用户注册数

object demo{

  //需求:统计前七天的用户注册数
  def main(args: Array[String]): Unit = {
    val paths = getPaths(7, "/user/hive/warehouse/user_info")
    println(paths)

    println("----------------------------------")
    readPaths(paths)
  }

  def getPaths(n:Int,pathPrefix:String)={
    //获取当前日期
    val currentDate = LocalDateTime.now()
    for(i<-1 to n) yield{
      //日期加减法
      val time = currentDate.plusDays(-i)
      //格式化时间
      val timeStr = time.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
      s"${pathPrefix}/${timeStr}"
    }
  }

  def readPaths(paths:IndexedSeq[String]):Unit={
    for (path <- paths) {
      println(path)
    }
  }


}

4.函数定义语法

package com.atguigu.chapter05

object $04_FunctionDefiend {

  /**
   * 方法就是函数,函数也是对象
   * 函数的定义语法: val 函数名 = (参数名:参数类型,...) => {函数体}
   * 函数的简化:如果函数体中只有一行语句,那么函数体{}可以忽略
   * 函数是对象,函数的类型:(参数类型,....)=>返回值类型
   *
   */

  def main(args: Array[String]): Unit = {
    println(func(10,20))
    println(func.apply(10,20))
    val name2 = name
    val func3 = func
    hello()
    println(hello)
    println(func3(30,40))

  }

  val func=(x:Int,y:Int) => {x + y}
  val name:String = "zhangsan"
  val hello=()=>{
    println("...........")
  }
  
  val func2 = new Function2[Int,Int,Int]{
    override def apply(v1:Int,v2:Int):Int=v1+v2
    
  }


}

5.方法与函数的区别

package com.atguigu.chapter05

object $05_MethodAndFunction {
  /**
   * 方法与函数的区别
   *      1.方法定义在类中的时候可以重载,函数是对象,函数名就是对象的引用,所以不能重载
   *      2.方法存储在方法区中,函数是对象存储在堆中
   * 方法和函数的关系
   *      1.方法名可以转成函数,可以通过 方法名 _ 的方式转成函数
   *      2.方法如果定义在方法中就是函数,不能重载的
   */
  def main(args: Array[String]): Unit = {
     println(func(10,20))
    println(add(10,20,30))
    //方法转函数
    val func2 = add _
    println(func2(10,20,30))

  }

  val func = (x:Int,y:Int)=>x + y
  // func = (x:Int,y:Int,z:Int)=>x + y + z
  //def add(x:Int,y:Int)= x+y
  def add(x:Int,y:Int,z:Int) = x + y + z

}

6.高阶函数的定义

package com.atguigu.chapter05

object $06_HIghFunction {
  /**
   * 高阶函数:以函数作为参数或者返回值的方法/函数称之为高阶函数
   *
   */
  def main(args: Array[String]): Unit = {
    val func =(x:Int,y:Int)=>{
      x + y
    }
    println(add(10,20,func))
  }

  //高阶函数
  def add(x:Int,y:Int,func:(Int,Int)=>Int)={
    func(x,y)
  }

}

7.高阶函数的简化

package com.atguigu.chapter05

object $07_HightFunctionSample {
  /**
   * 高阶函数的简化:
   *    1.可以直接将函数的值传给参数
   *    2.函数的参数类型可以省略
   *    3.如果函数的参数在函数体中只使用了一次可以用_代替
   *          注意:以下情况下不能以_代替
   *          1.函数体中参数的使用顺序与定义顺序不一致的时候不能用_代替[第N个下划线代表函数第N个参数]<针对函数有多个参数的情况>
   *          2.如果函数只有一个参数,在函数体中没有做任何操作,直接返回参数本身,此时不能用_代替<针对函数只有一个参数的情况>
   *          3.如果函数的参数体中有嵌套,函数的参数在嵌套中以表达式存在,此时不能用_简化
   *    4.如果函数只有一个参数,函数的参数列表的()可以省略
   */
  def main(args: Array[String]): Unit = {
    val func = (x:Int,y:Int) => x * y
    println(add(10,20,func))
    //1.可以直接将函数的值传给参数
    println(add(10,20,(x:Int,y:Int)=>x * y))
    //2.函数的参数类型可以省略
    println(add(10,20,(x,y)=>x * y))
    //3.如果函数的参数在函数体中只使用了一次可以用_代替
    println(add(10,20,_ * _))
    //
    println(add(10,20,(x,y)=>y-x))
    //1.函数体中参数的使用顺序与定义顺序不一致时不能用_代替
    //println(add(10,20,_-_))
    //2.如果函数只有一个参数,在函数体中没有做任何操作,直接返回函数本身,此时不能用_代替
    println(add2(10,(x:Int)=>x))
    //println(add2(10,_))
    //3.如果函数体中有嵌套,函数的参数在嵌套中以表达式形式存在,此时不能用_代替
    println(add2(10,(x:Int)=>(x+1)*10))
    //println(add2(10,(_+1)*10))
    //4.如果函数只有一个参数,函数的参数列表的()可以省略
    println(add2(10,x=>(x+1)*10))
  }
  def add(x:Int,y:Int,func:(Int,Int)=>Int)={
    func(x,y)
  }
  def add2(x:Int,func:Int=>Int) =func(x)
}

8.匿名函数

package com.atguigu.chapter05

object $08_NoNameFunction {
  /**
   * 匿名函数:没有函数名的函数称之为匿名函数
   * 匿名函数一般不单独使用,一般作为高阶函数的参数值传递
   *
   */
  def main(args: Array[String]): Unit = {
      val func = (x:Int) => x+10
    println(func(20))
    println(add(100,func))
    //匿名函数一般不单独使用,一般作为高阶函数的参数值传递
    println(add(100,_+10))

  }
  def add(x:Int,func:Int=>Int)=func(x)

}

9.递归

package com.atguigu.chapter05

object $09_Recursion {
  /**
   * 递归:自己调用自己
   * 递归必须满足两个条件:
   *     1.必须要有退出条件
   *     2.必须定义返回值类型
   */
  def main(args: Array[String]): Unit = {
    println(func(5))
    println(m1(5))

  }
  val func:Int =>Int=(n:Int)=>{
    if(n==1) 1
    else n * func(n-1)
  }
  /*val func=(n:Int) =>{
    if(n==1) 1
    else n * func(n-1)
  }*/
  def m1(n:Int):Int={
    //必须有退出条件
    if(n==1) 1
    else n * m1(n-1)
  }
}

10.柯里化

package com.atguigu.chapter05

object $10_Currying {
  /**
   * 柯里化:有多个参数列表的方法称之为柯里化
   */
  def main(args: Array[String]): Unit = {
    println(m1(10,20)(30)(40))
    println(m2(10,20,30,40))

  }


  /**
   * 柯里化
   */
  def m1(x:Int,y:Int)(z:Int)(a:Int)=x+y+z+a

  def m2(x:Int,y:Int,z:Int,a:Int)=x+y+z+a
}

11.闭包

package com.atguigu.chapter05

object $11_ClosePackage {
  /**
   * 闭包:函数体中使用了外部变量的函数称之为闭包
   */

  def main(args: Array[String]): Unit = {
    println(func(10))
  }
  val y =20
  //闭包函数
  val func =(x:Int)=>{
    x + y
  }

}

12.惰性求值

package com.atguigu.chapter05

object $12_Lazy {
  /**
   * 惰性求值:只有变量在真正使用的时候才会初始化
   * 语法:lazy val 变量名:类型 = 值
   */
  def main(args: Array[String]): Unit = {
    val name = "zhangsan"
    println(s"name=${name}")
    lazy val age =20
    println(s"age=${age}")
  }
}

13.控制抽象

package com.atguigu.chapter05

object $18_ControlAbstract {
  /**
   * 控制抽象:
   * 语法:  => 返回值类型
   * 控制抽象不能单独使用,只能作为方法的参数类型存在
   * 控制抽象其实就是一个块表达式,后续可以当做函数调用,只是在调用控制抽象时不能带上()
   */
  def main(args: Array[String]): Unit = {
     val a ={
       println("---------------")
       10+20
     }
    m1(a)
    m1(a)
    m1(a)
      val func=()=>{
        println("=====================")
        10+20
      }
    m2(func)
    m2(func)
    m2(func)

    m3({
      println("***************")
      10+20
    })
  }
  def m1(x:Int) =x * x
  def m2(func:()=>Int)= func() * func()
  def m3(func: =>Int)={
    func
    func
    func
  }

}

第二章.练习

1.练习一

需求:根据指定规则对数组中的每个元素操作
数据: Array[String]("hello","spark","java","hadoop")
规则: 获取每个元素的长度 [可变]
结果: Array[Int](5,5,4,6)

package com.atguigu.chapter05

object $13_HomeWork01 {
  /*
  * 需求: 根据指定规则对数组中的每个元素操作

- 数据: Array[String]("hello","spark","java","hadoop")
- 规则: 获取每个元素的长度 [可变]
- 结果: Array[Int](5,5,4,6)
  * */
  def main(args: Array[String]): Unit = {
    val data = Array[String]("hello","spark","java","hadoop")
    val func = (x:String) =>x.length
    val arr = map(data,func)
    println(arr.toList)

  }

  def map(data:Array[String],func:String => Any)={
    for(element<-data) yield{
      func(element)
    }
  }

}

2.练习二

根据指定规则对数组进行过滤
数据: Array[Int](1,4,3,7,6,10,9)
规则: 保留偶数数据 [可变]
结果: Array[Int](4,6,10)

package com.atguigu.chapter05

object $14_HomeWork02 {
  /**
   * 根据指定规则对数组进行过滤
     数据: Array[Int](1,4,3,7,6,10,9)
     规则: 保留偶数数据 [可变]
     结果: Array[Int](4,6,10)
   */
  def main(args: Array[String]): Unit = {
    val data = Array[Int](1, 4, 3, 7, 6, 10, 9)
    
    val func = (data:Array[Int]) => {
      val arr = data.filter(x => x%2==0)
       arr.toList
      

    }
    val result = map(data,func)

    println(result)
  }

  def map(data:Array[Int],func:Array[Int]=>Any)={
    func(data)
  }
  

}

3.练习三

根据指定规则对数组所有元素进行聚合
数据: Array[Int](1,4,3,7,6,10,9)
规则： 求和 [可变]
结果: 40

package com.atguigu.chapter05

object $15_HomeWork03 {
  /**
   * 根据指定规则对数组所有元素进行聚合
     数据: Array[Int](1,4,3,7,6,10,9)
     规则： 求和 [可变]
     结果: 40
   */
  def main(args: Array[String]): Unit = {
       val sum =0
       val data= Array[Int](1,4,3,7,6,10,9)
       val func=(data:Array[Int])=>data.sum
       val result = map(data,func)
       println(result)

  }
     def map(data:Array[Int],func:Array[Int]=>Int)={
          func(data)
     }

}

4.练习四

根据指定规则对数组中的元素进行分组
数据: Array[String]("zhangsan man shenzhen","lisi woman beijing","zhaoliu man beijing")
规则: 按照性别分组 [可变]
结果: Map( man-> List( "zhangsan man shenzhen", "zhaoliu man beijing") , woman -> List( "lisi woman beijing" ) )

package com.atguigu.chapter05

import java.util

object $16_HomeWork04 {

  /**
   * 根据指定规则对数组中的元素进行分组
    数据: Array[String]("zhangsan man shenzhen","lisi woman beijing","zhaoliu man beijing")
    规则: 按照性别分组 [可变]
    结果: Map( man-> List( "zhangsan man shenzhen", "zhaoliu man beijing") , woman -> List( "lisi woman beijing" ) )
   */
  def main(args: Array[String]): Unit = {
      val data = Array[String]( "zhangsan man shenzhen","lisi woman beijing","zhaoliu man beijing")
      val func =(x:String)=>x.split(" ")(1)
      println(groupBy(data, func))

  }
    def groupBy(data:Array[String],func:String=>Any)={
        //定义一个容器装载分组的结果
        val map = new util.HashMap[Any,util.List[String]]()
        //遍历
        for(element<-data){
            //得到分组的key
            val key = func(element)
            //判断key是否存在,如果存在则直接将当前元素添加到key对应的list中
            if(map.containsKey(key)){
                val list = map.get(key)
                list.add(element)
            }
            if(!map.containsKey(key)){
                val list = new util.ArrayList[String]()
                list.add(element)
                map.put(key,list)
            }
        }
        map
    }

}

5.练习五

根据指定规则获取数组中的最大值的信息
数据: Array[String]("zhangsan 20 1500","lisi 35 2000","zhaoliu 18 4500")
规则: 获取年龄最大的人的信息 [可变]
结果: "lisi 35 2000"

package com.atguigu.chapter05

object $17_HomeWork05 {
  /*根据指定规则获取数组中的最大值的信息
  数据: Array[String]("zhangsan 20 1500","lisi 35 2000","zhaoliu 18 4500")
  规则: 获取年龄最大的人的信息 [可变]
  结果: "lisi 35 2000"*/
  def main(args: Array[String]): Unit = {
    val data = Array[String]("zhangsan 20 1500", "lisi 35 2000", "zhaoliu 18 4500")
    val func = (x: String) => {
      x.split(" ")(1).toInt

    }
    println(maxBy(data, func))


  }

  def maxBy(data:Array[String],func:String=>Int)={
    //定义中间变量
    var tmp = func(data(0))
    var result:String = null
    for (elem <- data) {
      val key = func(elem)
      if(key >= tmp){
        tmp = key
        result =elem
      }
    }
    result
  }
}
ly的学习笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
scala复习（3）
郭首志的博客
06-08 435
1.面向对象 类： class 关键字修饰的 对象: object 关键字修饰的 类的实例：new 类（） 类的实例对象 Scala的类与Java、C++的类比起来更简洁，学完之后你会更爱Scala！！！ 对象： 用object关键字修饰的结构 类： 用class 关键字修饰的 类的实例（对象）： new class 1.1.对象 1.1.1.单例对象 Scala中没有静态方法和静态字段，没有...
Scala高阶函数练习题
2301_81170993的博客
03-21 260
比如: Array(“hh”,“red”,“java”,“hadoop”)比如: Array(1,4,7,9,10,6,8,99,88,66)1、定义一个高阶函数，按照指定的规则对集合里面的每个元素进行操作。2、定义一个高阶函数，对数据中的元素按照指定的规则进行过滤。规则: 对集合中每个元素进行操作，得到集合每个元素的长度。比如:Array(10,4,6,10,2)3、对数据中的元素按照指定规则进行分组。4、根据指定规则对数组所有元素聚合。规则: 按照地址进行分组。规则: 只保留偶数数据。
scala高阶函数练习题10题
desperado0726的博客
04-14 1784
1、定义一个高阶函数，按照指定的规则对集合里面的每个元素进行操作 比如: Array(“spark”,“hello”,“java”,“hadoop”) 规则: 对集合中每个元素进行操作，得到集合每个元素的长度 object Test01 { def main(args: Array[String]): Unit = { val list = Array("spark", "hello", "java", "hadoop") //完整写法 val fun = (s: String
Spark-Scala语言实战（5）
2401_84182665的博客
04-12 762
按照指定的规则对集合里面的每个元素进行操作 比如: Array(“hh”,“red”,“java”,“hadoop”) 规则: 对集合中每个元素进行操作，得到集合每个元素的长度val p = lengths.toList // 将数组转换为列表println(p) // 输出: List(2, 3, 4, 6)对数据中的元素按照指定的规则进行过滤 比如: Array(1,4,7,9,10,6,8,99,88,66) 规则: 只保留偶数数据val p1 = ppp.toList // 将数组转换为列表。
java中对list集合中的数据按照某一个属性进行分组
热门推荐
赶路人儿
06-16 4万+
java list分组。 list里面封装的都是实体对象或Map，现要按照对象的某个属性进行分组。
Scala入门（四）类
鬼火修罗的博客
04-20 826
scala作为一门多范式语言，对面向对象也有很好的支持，下边我们熟悉下这部分内容： 1.最简单的类 class Counter{ //这里定义类的字段和方法 } 定义了类以后，就可以正常new对象了。 2.定义字段和方法 类中的函数被称为方法，使用def定义： class Counter{ private var value = 0 def increment(): U...
Scala函数式编程
03-18
　这本书所讲授的，正是基于 Scala 的函数式编程基础。基于 Scheme、Haskell 等老牌函数式语言的传统教材的问题在于，相关语言的语法和思维方式与读者现有的知识体系迥异，容易造成较为陡峭的入门门槛。此外，由于...
Scala函数式编程.pdf
05-18
函数式编程（FP）是一种...《Scala函数式编程》是针对希望学习FP并将它应用于日常编码中的程序员而写的，内容包括：函数式编程的概念；函数式编程相关的各种“为什么”和“怎么做”；如何编写多核程序；练习和检测。
Scala函数式编程专题--scala集合和函数
08-18
Scala函数式编程专题--scala集合和函数 以下是关于Scala函数式编程专题--scala集合和函数的知识点： 1. Scala 集合介绍 Scala 集合是指 Scala 语言中的数据结构，包括 List、Tuple、Map 等。这些集合类型都有其...
Scala基本语法（一）
糊里糊涂走进大数据的小菜鸡
12-24 589
Scala是一门以Java虚拟机（JVM）为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言（静态语言需要提前编译的如：Java、c、c++等，动态语言如：js）。
scala模拟编写用户登录
qing__long的博客
03-27 1838
scala模拟编写用户登录 题目 验证登录信息的合法性。使用的是指定用户名与密码正常，并且验证码正常后，允许程序登录，否则将用户拒之门外。如果是用户名不正确，提醒用户名不正常，密码不正确提醒密码不正确，验证码不正常提醒验证码不正确。验证码要求为随机数，例如:10X2=?，乘集结果为验证号最终答案，...
Scala函数式编程(基础与高级)
m0_51691291的博客
12-25 283
Scala函数式编程1、函数基础1.1、函数基本语法1.2、函数参数1.2.1、可变参数1.2.2、默认参数与带名参数1.3、函数至简原则2、函数高级2.1、高阶函数2.2、匿名函数2.2.1、匿名函数的至简原则2.2.1.1、传递一个参数2.2.1.2、传递两个参数2.3、闭包2.4、柯里化 1、函数基础 Scala 语言是一个完全函数式编程语言。万物皆函数。 函数的本质：函数可以当做一个值进行传递 1.1、函数基本语法 1.2、函数参数 1.2.1、可变参数 语法：在所定义的参数类型后面加上一个*即可
二, Scala 函数式编程详解
菜菜的大数据开发の路
01-06 1225
五, 函数式编程 面向对象编程(OOP) 面向对象思想: 使用对象来映射现实中的事物, 使用对象的关系来描述事事物之间的联系 面向对象编程: 把要解决的问题按照一定的规则划分为多个独立的对象, 这些对象拥有各自的属性和方法, 通过调用对象的方法来解决问题; [举个栗子] 用户通过JDBC连接和读取数据库 对象: 用户; 属性: 用户名, 密码; 行为(方法): 登录, 连接JDBC, 读取数据库; 对象的本质: 对数据和行为的一个封装 函数式编程(FP) 面向过程编程: 分析解
scala编写：用户登录账号密码的程序，只有3次机会
博樽
10-28 2046
用户登录账号密码的程序，只有3次机会
Scala学习笔记20: Future 和Promise
最新发布
Taerge0110的博客
07-26 276
在 Scala 中, `Future` 和 `Promise` 是用于处理异步操作的强大工具 ; 它们就像一对搭档, 协同工作, 优雅地管理着那些需要花费时间的任务 .
探索Perl的图形用户界面开发：工具、技巧与实践
2402_85762143的博客
07-23 1126
Perl的GUI开发提供了多种工具和方法，允许开发者根据项目需求和个人偏好选择合适的工具包。通过遵循最佳实践和利用Perl的强大功能，开发者可以创建出既美观又实用的GUI应用程序。随着技术的不断发展，Perl社区也在不断推出新的工具和库，以支持更高效、更现代的GUI开发。本文只是一个入门指南，深入学习Perl GUI开发还需要阅读更多的文档、参与社区讨论和实践项目。希望本文能为你的Perl GUI开发之旅提供一些帮助和启发。
Spark实时（三）：Structured Streaming入门案例
Lansonli（蓝深李）的博客
07-24 652
我们使用Structured Streaming来监控socket数据统计WordCount。
探索Perl的奇妙世界：入门学习与实战指南
sinner小屋
07-25 1411
《探索Perl的奇妙世界：入门学习与实战指南》为大家提供了一个全面的Perl编程学习路径，从基础知识到高级技巧，涵盖了Perl在Web开发、数据库操作和生物信息学中的实际应用。通过详实的代码案例和实战演练，本书帮助大家深入理解Perl的强大功能和灵活性。同时，文中还探讨了Perl的优势与局限，以及其在未来的发展潜力，适合所有希望提升Perl编程技能的读者。
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1274
主流开发语言和开发环境介绍
Scala函数式编程模式实战
1. 了解函数式编程的基本理念，以及Scala函数式编程特性如何提升代码的健壮性、安全性和简洁性。 2. 应用函数式编程模式解决实际编程挑战，减少模板代码，以更简洁优雅的方式表达设计模式。 3. 减少系统复杂性，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值