Scala函数式编程(第五章:函数基础、函数高级详解)

news2024/10/6 22:32:09

文章目录

  • 第 5 章 函数式编程
    • 5.1 函数基础
      • 5.1.1 函数基本语法
      • 5.1.2 函数和方法的区别
      • 5.1.3 函数定义
      • 5.1.4 函数参数
      • 5.1.5 函数至简原则（重点）
    • 5.2 函数高级
      • 5.2.1 高阶函数
      • 5.2.2 匿名函数
      • 5.2.3 高阶函数案例
      • 5.2.4 函数柯里化&闭包
      • 5.2.5 递归
      • 5.2.6 控制抽象
      • 5.2.7 惰性加载

第 5 章 函数式编程

1）面向对象编程

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

2）函数式编程

  • 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用 这些封装好的步骤，解决问题。
  • 例如：请求->用户名、密码->连接 JDBC->读取数据库
  • Scala 语言是一个完全函数式编程语言。万物皆函数。
  • 函数的本质：函数可以当做一个值进行传递

3）在 Scala 中函数式编程和面向对象编程完美融合在一起了。

5.1 函数基础

5.1.1 函数基本语法

1）基本语法
在这里插入图片描述
2）案例实操

需求：定义一个函数，实现将传入的名称打印出来。

object TestFunction {
def main(args: Array[String]): Unit = {
 // （1）函数定义
 def f(arg: String): Unit = {
 println(arg)
 }
 // （2）函数调用
 // 函数名（参数）
 f("hello world")
 }
}

5.1.2 函数和方法的区别

1）核心概念

  • （1）为完成某一功能的程序语句的集合，称为函数。
  • （2）类中的函数称之方法。

2）案例实操

  • （1）Scala 语言可以在任何的语法结构中声明任何的语法
  • （2）函数没有重载和重写的概念；方法可以进行重载和重写
  • （3）Scala 中函数可以嵌套定义
object TestFunction {
 // (2)方法可以进行重载和重写，程序可以执行
 def main(): Unit = {
 }
 def main(args: Array[String]): Unit = {
 // （1）Scala 语言可以在任何的语法结构中声明任何的语法
 import java.util.Date
 new Date()
 // (2)函数没有重载和重写的概念，程序报错
 def test(): Unit ={
 println("无参，无返回值")
 }
 test()
 def test(name:String):Unit={
 println()
 }
 //（3）Scala 中函数可以嵌套定义
 def test2(): Unit ={
 def test3(name:String):Unit={
 println("函数可以嵌套定义")
 }
 }
 }
}

5.1.3 函数定义

1）函数定义

  • （1）函数 1：无参，无返回值
  • （2）函数 2：无参，有返回值
  • （3）函数 3：有参，无返回值
  • （4）函数 4：有参，有返回值
  • （5）函数 5：多参，无返回值
  • （6）函数 6：多参，有返回值

2）案例实操

package com.atguigu.chapter05
object TestFunctionDeclare {
 def main(args: Array[String]): Unit = {
 // 函数 1：无参，无返回值
 def test1(): Unit ={
 println("无参，无返回值")
 }
 test1()
 // 函数 2：无参，有返回值
 def test2():String={
 return "无参，有返回值"
 }
 println(test2())
 // 函数 3：有参，无返回值
 def test3(s:String):Unit={
 println(s)
 }
 test3("jinlian")
 // 函数 4：有参，有返回值
 def test4(s:String):String={
 return s+"有参，有返回值"
 }
 println(test4("hello "))
 // 函数 5：多参，无返回值
 def test5(name:String, age:Int):Unit={
 println(s"$name, $age")
 }
 test5("dalang",40)
 }
}

5.1.4 函数参数

1）案例实操

  • （1）可变参数
  • （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
  • （3）参数默认值，一般将有默认值的参数放置在参数列表的后面
  • （4）带名参数
object TestFunction {
 def main(args: Array[String]): Unit = {
 // （1）可变参数
 def test( s : String* ): Unit = {
 println(s)
 }
 // 有输入参数：输出 Array
 test("Hello", "Scala")
 // 无输入参数：输出 List()
 test()
 // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
 def test2( name : String, s: String* ): Unit = {
 println(name + "," + s)
 }
 test2("jinlian", "dalang")
 // (3)参数默认值
 def test3( name : String, age : Int = 30 ): Unit = {
  println(s"$name, $age")
 }
 // 如果参数传递了值，那么会覆盖默认值
 test3("jinlian", 20)
 // 如果参数有默认值，在调用的时候，可以省略这个参数
 test3("dalang")
 // 一般情况下，将有默认值的参数放置在参数列表的后面
 def test4( sex : String = "男", name : String ): Unit = {
 println(s"$name, $sex")
 }
// Scala 函数中参数传递是，从左到右
 //test4("wusong") 
 //（4）带名参数
 test4(name="ximenqing")
 }
}

5.1.5 函数至简原则（重点）

函数至简原则：能省则省
1）至简原则细节

  • （1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
  • （2）如果函数体只有一行代码，可以省略花括号
  • （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
  • （4）如果有 return，则不能省略返回值类型，必须指定
  • （5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
  • （6）Scala 如果期望是无返回值类型，可以省略等号
  • （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
  • （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
  • （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

2）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （0）函数标准写法
 def f( s : String ): String = {
 return s + " jinlian"
 }
 println(f("Hello"))
 // 至简原则:能省则省
 //（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
 def f1( s : String ): String = {
 s + " jinlian"
 }
 println(f1("Hello"))
 //（2）如果函数体只有一行代码，可以省略花括号
 def f2(s:String):String = s + " jinlian"
 //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起
省略）
 def f3( s : String ) = s + " jinlian"
 println(f3("Hello3"))
 //（4）如果有 return，则不能省略返回值类型，必须指定。
 def f4() :String = {
 return "ximenqing4"
 }
 println(f4())
 //（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也
不起作用
 def f5(): Unit = {
 return "dalang5"
 }
 println(f5())
 //（6）Scala 如果期望是无返回值类型,可以省略等号
 // 将无返回值的函数称之为过程
 def f6() {
 "dalang6"
 }
 println(f6())
 //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可
不加
 def f7() = "dalang7"
 println(f7())
 println(f7)
 //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省
略
 def f8 = "dalang"
 //println(f8())
 println(f8)
 //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
 def f9 = (x:String)=>{println("wusong")}
 def f10(f:String=>Unit) = {
 f("")
 }
 f10(f9)
 println(f10((x:String)=>{println("wusong")}))
 }
}

5.2 函数高级

5.2.1 高阶函数

在 Scala 中，函数是一等公民。怎么体现的呢？
对于一个函数我们可以：定义函数、调用函数

object TestFunction {
 def main(args: Array[String]): Unit = {
 // 调用函数
foo()
 }
 // 定义函数
 def foo():Unit = {
 println("foo...")
 }
}

但是其实函数还有更高阶的用法
1）函数可以作为值进行传递

object TestFunction {
 def main(args: Array[String]): Unit = {
 //（1）调用 foo 函数，把返回值给变量 f
 //val f = foo()
 val f = foo
 println(f)
 //（2）在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体，
传递给变量 f1
 val f1 = foo _
 foo()
 f1()
//（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给
变量
var f2:()=>Int = foo 
 }
 def foo():Int = {
 println("foo...")
 1
 }
}

2）函数可以作为参数进行传递

 
 // （1）定义一个函数，函数参数还是一个函数签名；f 表示函数名称;(Int,Int)
表示输入两个 Int 参数；Int 表示函数返回值
 def f1(f: (Int, Int) => Int): Int = {
 f(2, 4)
 }
 
 // （2）定义一个函数，参数和返回值类型和 f1 的输入参数一致
 def add(a: Int, b: Int): Int = a + b
 
 // （3）将 add 函数作为参数传递给 f1 函数，如果能够推断出来不是调用，_
可以省略
 println(f1(add))
println(f1(add _))
//可以传递匿名函数
}

3）函数可以作为函数返回值返回

def main(args: Array[String]): Unit = {
 def f1() = {
 def f2() = {
}
f2 _
}
val f = f1()
// 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用
f()
// 上面的代码可以简化为
f1()()
}

5.2.2 匿名函数

1）说明

  • 没有名字的函数就是匿名函数。
  • (x:Int)=>{函数体}
  • x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

2）案例实操

  • 需求 1：传递的函数有一个参数

传递匿名函数至简原则：

  • （1）参数的类型可以省略，会根据形参进行自动的推导
  • （2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参 数超过 1 的永远不能省略圆括号。
  • （3）匿名函数如果只有一行，则大括号也可以省略
  • （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 def main(args: Array[String]): Unit = {
 // （1）定义一个函数：参数包含数据和逻辑函数
 def operation(arr: Array[Int], op: Int => Int) = {
 for (elem <- arr) yield op(elem)
 }
 // （2）定义逻辑函数
 def op(ele: Int): Int = {
 ele + 1
 }
 // （3）标准函数调用
 val arr = operation(Array(1, 2, 3, 4), op)
 println(arr.mkString(","))
 // （4）采用匿名函数
 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
 ele + 1
 })
 println(arr1.mkString(","))
 // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
 val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
 ele + 1
 })
 println(arr2.mkString(","))
 // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情
况：没有参数和参数超过 1 的永远不能省略圆括号。
 val arr3 = operation(Array(1, 2, 3, 4), ele => {
 ele + 1
 })
 println(arr3.mkString(","))
 // (4.3) 匿名函数如果只有一行，则大括号也可以省略
 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
 println(arr4.mkString(","))
 //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
 println(arr5.mkString(","))
 }
}

需求 2：传递的函数有两个参数

object TestFunction {
 def main(args: Array[String]): Unit = {
 def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int 
= {
 op(a, b)
 }
 // （1）标准版
 println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
 // （2）如果只有一行，则大括号也可以省略
 println(calculator(2, 3, (x: Int, y: Int) => x + y))
 // （3）参数的类型可以省略，会根据形参进行自动的推导;
 println(calculator(2, 3, (x , y) => x + y))
 // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 println(calculator(2, 3, _ + _))
 }
}

扩展练习
练习 1：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。
要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。
练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。
它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接
收一个 Char 类型的参数，返回一个 Boolean 的值。
要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。

5.2.3 高阶函数案例

需求：模拟 Map 映射、Filter 过滤、Reduce 聚合

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （1）map 映射
 def map(arr: Array[Int], op: Int => Int) = {
 for (elem <- arr) yield op(elem)
 }
 val arr = map(Array(1, 2, 3, 4), (x: Int) => {
 x * x
 })
 println(arr.mkString(","))
 // （2）filter 过滤。有参数，且参数再后面只使用一次，则参数省略且
后面参数用_表示
 def filter(arr:Array[Int],op:Int =>Boolean) ={
 var arr1:ArrayBuffer[Int] = ArrayBuffer[Int]()
 for(elem <- arr if op(elem)){
 arr1.append(elem)
 }
 arr1.toArray
 }
 var arr1 = filter(Array(1, 2, 3, 4), _ % 2 == 1)
 println(arr1.mkString(","))
 // （3）reduce 聚合。有多个参数，且每个参数再后面只使用一次，则参
数省略且后面参数用_表示，第 n 个_代表第 n 个参数
 def reduce(arr: Array[Int], op: (Int, Int) => Int) = {
 var init: Int = arr(0)
 for (elem <- 1 until arr.length) {
 init = op(init, elem)
 }
 init
 }
 //val arr2 = reduce(Array(1, 2, 3, 4), (x, y) => x * y)
 val arr2 = reduce(Array(1, 2, 3, 4), _ * _)
 println(arr2)
 }
}

5.2.4 函数柯里化&闭包

闭包：函数式编程的标配
1）说明

  • 闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的 环境，称为闭包
  • 函数柯里化：把一个参数列表的多个参数，变成多个参数列表。

2）案例实操
（

  • 1）闭包
object TestFunction {
 def main(args: Array[String]): Unit = {
 def f1()={
var a:Int = 10
 def f2(b:Int)={
 a + b
 }
 f2 _
 }
 // 在调用时，f1 函数执行完毕后，局部变量 a 应该随着栈空间释放掉
 val f = f1()
 // 但是在此处，变量 a 其实并没有释放，而是包含在了 f2 函数的内部，形
成了闭合的效果
 println(f(3))
 
 println(f1()(3))
 // 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存
在闭包
 def f3()(b:Int)={
 a + b
 }
 println(f3()(3))
 }
}

5.2.5 递归

1）说明
一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用
2）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // 阶乘
 // 递归算法
 // 1) 方法调用自身
 // 2) 方法必须要有跳出的逻辑
 // 3) 方法调用自身时，传递的参数应该有规律
 // 4) scala 中的递归必须声明函数返回值类型
 println(test(5))
 }
 def test(i : Int) : Int = {
 if (i == 1) {
 1
 } else {
 i * test(I - 1)
 }
 }
}

5.2.6 控制抽象

1）值调用：把计算后的值传递过去

object TestControl {
 def main(args: Array[String]): Unit = {
 def f = ()=>{
 println("f...")
  10
 }
 foo(f())
 }
 def foo(a: Int):Unit = {
 println(a)
 println(a)
 }
}
  • 2）名调用：把代码传递过去
object TestControl {
 def main(args: Array[String]): Unit = {
 def f = ()=>{
 println("f...")
 10
 }
 foo(f())
 }
//def foo(a: Int):Unit = {
 def foo(a: =>Int):Unit = {//注意这里变量 a 没有小括号了
 println(a)
 println(a)
 }
}
输出结果：
f...
10
f...
10

注意：Java 只有值调用；Scala 既有值调用，又有名调用。
3）案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // （1）传递代码块
 foo({
 println("aaa")
 })
 // （2）小括号可以省略
 foo{
 println("aaa")
 }
 }
  def foo(a: =>Unit):Unit = {
 println(a)
 println(a)
 }
}

自定义一个 While 循环

object TestFunction {
 def main(args: Array[String]): Unit = {
 var i:Int = 1
 myWhile(i <= 10){
 println(i)
 i +=1
 }
 }
 def myWhile(condition: =>Boolean)(op: =>Unit):Unit={
 if (condition){
 op
 myWhile(condition)(op)
 }
 }
}

5.2.7 惰性加载

1）说明

当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函
数才会执行。这种函数我们称之为惰性函数。

2）案例实操

def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("----------------")
 println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("sum 被执行。。。")
 return n1 + n2
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/363084.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

GooglePlay SSL Error Handler

GooglePlay SSL Error Handler

应用上架GooglePlay 收到邮件提示 出现这个原因是因为我在app中使用webview加载Https的H5界面&#xff0c;在onReceivedSslError()中处理SslErrorHandler时&#xff0c;出现白屏现象&#xff0c;原因是webview默认在加载有证书验证的url时&#xff0c;会默认使用handler.cancel…
阅读更多...
SPDK vhost target

SPDK vhost target

SPDK vhost target主流的I/O设备虚拟化的方案1.virtio2.vhost加速1&#xff09;QEMU virtio-scsiQemu 架构2&#xff09;Kernel vhost-scsi3&#xff09;SPDK vhost-user-scsi3.SPDK vhost-scsi加速4.SPDK vhost-NVMe加速主流的I/O设备虚拟化的方案 纯软件模拟&#xff1a;完全…
阅读更多...
vTESTstudio - VT System CAPL Functions - VT7001（续1）

vTESTstudio - VT System CAPL Functions - VT7001（续1）

vtsSetInterconnectionMode - 设置VT7001的电源输出模式功能&#xff1a;设置电源模块VT7001的三个可能电源和两个电源输出的互连模式。注意&#xff1a;此函数不能在任何CAPL处理程序例程或ECU节点中调用。它只能在测试模块的MainTest方法上下文中调用&#xff1b;使用在测量开…
阅读更多...
企业为什么需要数据可视化报表

企业为什么需要数据可视化报表

数据可视化报表是在商业环境、市场环境已经改变之后&#xff0c;发展出来为当前企业提供替代解决办法的重要方案。而且信息化、数字化时代&#xff0c;很多企业已经进行了初步的信息化建设&#xff0c;沉淀了大量业务数据&#xff0c;这些数据作为企业的资产&#xff0c;是需要…
阅读更多...
Logstash：在 Logstash 管道中的定制的 Elasticsearch update by query

Logstash：在 Logstash 管道中的定制的 Elasticsearch update by query

我们知道 Elasticsearch output plugin 为我们在 Logstash 的 pipeline 中向 Elasticsearch 的写入提供了可能。我们可以使用如下的格式向 Elasticsearch 写入数据&#xff1a; elasticsearch {hosts > ["https://localhost:9200"]index > "data-%{YYYY.M…
阅读更多...
ROS2手写自定义点云(PointCloud2)数据并发布

ROS2手写自定义点云(PointCloud2)数据并发布

目录前言实现前言 继续学习ROS2&#xff0c;最近把navigation2的路径规划部分学习了一遍&#xff0c;但是还没有进行测试&#xff0c;于是先把这个部分先空出来后面再总结。先写一个与避障有关系的如何自己发点云数据。 在nav2里面有一个非常重要的部分就是costmap部分&#…
阅读更多...
Python是未来的编程语言？学Python前景如何？薪资高吗？

Python是未来的编程语言？学Python前景如何？薪资高吗？

Python是一种强大的语言&#xff0c;为世界各地的开发人员提供了多种用途。根据TIOBE指数&#xff0c;Python的排名还在继续攀升。开发人员和技术专业人员也不断发现Python的新用途&#xff0c;包括数据分析和机器学习等。 Python现在有着庞大的用户基础&#xff0c;并且它深深…
阅读更多...
经纬度坐标点和距离之间的转换

经纬度坐标点和距离之间的转换

1.纬度相同&#xff0c;经度不同 在纬度相同的情况下&#xff1a; 经度每隔0.00001度&#xff0c;距离相差约1米&#xff1b; 每隔0.0001度&#xff0c;距离相差约10米&#xff1b; 每隔0.001度&#xff0c;距离相差约100米&#xff1b; 每隔0.01度&#xff0c;距离相差约1000米…
阅读更多...
Linux 远程登录

Linux 远程登录

Linux 一般作为服务器使用&#xff0c;而服务器一般放在机房&#xff0c;你不可能在机房操作你的 Linux 服务器。 这时我们就需要远程登录到Linux服务器来管理维护系统。 Linux 系统中是通过 ssh 服务实现的远程登录功能&#xff0c;默认 ssh 服务端口号为 22。 Window 系统…
阅读更多...
SpringCloud+Dubbo3 = 王炸 ！

SpringCloud+Dubbo3 = 王炸 ！

前言 全链路异步化的大趋势来了 随着业务的发展&#xff0c;微服务应用的流量越来越大&#xff0c;使用到的资源也越来越多。 在微服务架构下&#xff0c;大量的应用都是 SpringCloud 分布式架构&#xff0c;这种架构总体上是全链路同步模式。 全链路同步模式不仅造成了资源…
阅读更多...
第二章 runtime-core初始化核心流程和runtime-core更新核心流程

第二章 runtime-core初始化核心流程和runtime-core更新核心流程

runtime-core初始化核心流程 1 创建app 2 进行初始化 2.1 基于组件生成虚拟节点 2.2 进行render 调用patch 根据不同的vnode类型进行不同类型的组件处理 组件 2.2.1 创建component instance对象 2.2.2 setup component 初始化props slots 各种 2.2.3 setupRenderEffect…
阅读更多...
通过Docker部署rancher

通过Docker部署rancher

先创建k8s集群 https://blog.csdn.net/weixin_44371237/article/details/123974335 环境准备 一台linux主机&#xff0c;4G内存 通过Docker部署rancher 启动rancher docker run --privileged -d --restartunless-stopped -p 80:80 -p 443:443 rancher/rancher查看本地镜像…
阅读更多...
python基础：简单实现从网页中获取小说名单列表并存入文件中

python基础：简单实现从网页中获取小说名单列表并存入文件中

python基础&#xff1a;简单实现从网页中获取小说名单列表并存入文件中1.技术储备 requests&#xff1a;requests是使用Apache2 licensed 许可证的HTTP库&#xff0c;可以用于网页数据请求 requests.get():发起网络请求的一种方式&#xff0c;类似的还有post、 put、 delete、…
阅读更多...
[MySQL]基本数据类型及表的基本操作

[MySQL]基本数据类型及表的基本操作

哈喽&#xff0c;大家好&#xff01;我是保护小周ღ&#xff0c;本期为大家带来的是 MySQL 数据库常用的数据类型&#xff0c;数据表的基本操作&#xff1a;创建、删除、修改表&#xff0c;针对修改表的结构进行了讲解&#xff0c;随后是如何向数据表中添加数据&#xff0c;浅浅…
阅读更多...
Vulnhub_Venom

Vulnhub_Venom

目录 一 测试 &#xff08;一&#xff09;信息收集 1 端口服务探测 2 目录扫描 3 前端源码信息收集 &#xff08;二&#xff09;漏洞发现 1 前端注释敏感信息泄露 2 CVE-2018-19422-Subrion CMS v 4.2.1任意文件上传 &#xff08;三&#xff09;提权 1 sudo…
阅读更多...
4万字c++讲解+区分c和c++，不来可惜了（含代码+解析）

4万字c++讲解+区分c和c++，不来可惜了（含代码+解析）

目录 1 C简介 1.1 起源 1.2 应用范围 1.3 C和C 2开发工具 3 基本语法 3.1 注释 3.2关键字 3.3标识符 4 数据类型 4.1基本数据类型 4.2 数据类型在不同系统中所占空间大小 4.3 typedef声明 4.4 枚举类型 5 变量 5.1 变量的声明和定义 5.2 变量的作用域 6 运算符…
阅读更多...
面试之设计模式（简单工厂模式）

面试之设计模式（简单工厂模式）

案例 在面试时&#xff0c;面试官让你通过面对对象语言&#xff0c;用Java实现计算器控制台程序&#xff0c;要求输入两个数和运算符号&#xff0c;得出结果。大家可能想到是如下&#xff1a; public static void main(String[] args) {Scanner scanner new Scanner(System.…
阅读更多...
一文让你了解SpringCloud五大核心组件

一文让你了解SpringCloud五大核心组件

&#x1f3c6;今日学习目标&#xff1a; &#x1f340;SpringCloud五大核心组件 ✅创作者&#xff1a;林在闪闪发光 ⏰预计时间&#xff1a;30分钟 &#x1f389;个人主页&#xff1a;林在闪闪发光的个人主页 &#x1f341;林在闪闪发光的个人社区&#xff0c;欢迎你的加入: 林…
阅读更多...
2021-08-29

2021-08-29

服务器 主&#xff1a;172.17.0.2 master 备:172.17.0.3 slave1 lvs虚拟IP:172.17.0.100 #nginx下载地址 http://nginx.org/download/ 本地文件路径 1.dockerfile构建nginx FROM centos:7 ADD nginx-1.6.0.tar.gz /usr/local COPY nginx_install.sh /usr/local RUN sh …
阅读更多...
毕业设计（1）-AFLGO的安装

毕业设计（1）-AFLGO的安装

AFLGO是一个模糊测试工具&#xff0c;在CSDN上的安装教程不多&#xff0c;自己在安装过程中也出现了很多教程之外的错误&#xff0c;最后反复安装了2天终于安装成功这里记录一下安装工程中的错误 使用的平台&#xff1a;Ubuntu18.04 配置&#xff1a; 内存&#xff1a;6G&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023