2. 程式人生 > >restapi（6）- do it the functional way, 重溫函數語言程式設計

restapi（6）- do it the functional way, 重溫函數語言程式設計

阿新 • • 發佈：2019-08-24

  再次看了看上篇部落格的原始碼，發現連自己都看不懂了。想是為了趕時間交貨不知不覺又回到OOP行令模式了，看看下面這段程式碼：

       (post &  parameters('pid,'desc.?,'width.as[Int].?,'heigth.as[Int].?)) { (pid, optDesc, optWid, optHgh) =>
          val futCount: Future[Int] = repository.count(pid).value.value.runToFuture.map {
            eoi =>
              eoi match {
                case Right(oi) => oi match {
                  case Some(i) => i
                  case None => -1
                }
                case Left(err) => -1
              }
          }
          val count: Int = Await.result(futCount, 2 seconds)
          var doc = Document(
            "pid" -> pid,
            "seqno" -> count
          )
          if (optDesc != None)
            doc = doc + ("desc" -> optDesc.get)
          if (optWid != None)
            doc = doc + ("desc" -> optWid.get)
          if (optHgh != None)
            doc = doc + ("desc" -> optHgh.get)

          withoutSizeLimit {
            decodeRequest {
              extractDataBytes { bytes =>
                val fut = bytes.runFold(ByteString()) { case (hd, bs) =>
                  hd ++ bs
                }
                onComplete(fut) {
                  case Success(b) =>
                    doc = doc + ("pic" -> b.toArray)
                    val futmsg: Future[String] = repository.insert(doc).value.value.runToFuture.map {
                      eoc =>
                        eoc match {
                          case Right(oc) => oc match {
                            case Some(c) => count.toString //   c.toString()
                            case None => "insert may not complete!"
                          }
                          case Left(err) => err.getMessage
                        }
                    }
                    complete(futmsg)
                  case Failure(err) => complete(err)
                }
              }
            }
          }

有人能從這段程式碼裡理解它的功能嗎？本來作者的目的很簡單：前端通過httprequest提交了一張圖片及產品編號pid、系統讀取MongoDB查詢相同pid的數量count，然後將圖片和描述包括count寫入資料庫並在reponse裡返回count。把一個簡單功能的實現搞的這麼複雜都是我的錯，可能受OOP荼毒太深。這次希望靜下心來用函數語言程式設計模式把這段程式碼從新實現一次，示範一下函數語言程式設計的程式碼精煉和高雅特點。首先介紹一下DBResult[A]這個型別：這是一個Monad，為了應付Future[Either[Option[R]]]這樣的型別而設計的，是一個表現資料庫操作比較全面的型別，但同時它又是造成上面這段程式碼混亂的元凶。現在我們可以用隱式轉換implicit conversion方式進行程式碼簡化重用：

  import monix.execution.Scheduler.Implicits.global
  implicit class DBResultToFuture(dbr: DBOResult[_]){
      def toFuture[R] = {
        dbr.value.value.runToFuture.map {
          eor =>
            eor match {
              case Right(or) => or match {
                case Some(r) => r.asInstanceOf[R]
                case None => throw new RuntimeException("Operation produced None result!")
              }
              case Left(err) => throw new RuntimeException(err)
            }
        }
      }
  }

 用這個隱式轉換型別為任何DBOResult[R]增加一個函式toFuture[R]。現在整個futCount算式可以簡化成下面這樣：

          val futCount: Future[Int] = repository.count(pid).value.value.runToFuture.map {
            eoi =>
              eoi match {
                case Right(oi) => oi match {
                  case Some(i) => i
                  case None => -1
                }
                case Left(err) => -1
              }
          }


futCount:Future[Int]=repository.count(pid).toFuture

真正的簡單易明。

不知怎麼搞的，我盡然在這段程式碼中間使用了Await.result。從OOP角度分析這很容易理解，下一段程式需要上一段程式的結果來繼續執行。在上面的例子裡我們需要先獲取count然後把count塞進Document再把Document存入資料庫。邏輯思路上沒問題，不過這樣的做法是典型的行令式程式設計模式。在函數語言程式設計模式裡，階段性的運算結果是在包嵌在Monad中的。Monad本身只是一個運算計劃，只有真正運算時才能獲取結果。Monad本身是函式元件，可以實現多個Monad的函式組合。在這裡可以形象的把Monad函式組合描述為資料庫操作步驟：先count、再insert，這兩個步驟產生的結果還是留在Monad裡的，直到所謂的世界末日，即實際運算完成後才取出，所以Monad是一種典型的程式運算流程管道。假如我們再把insert這段程式寫成addPicture(...): DBOResult[_], 如下：

   def addPicuture(pid: String,seqno: Int, optDesc: Option[String]
                         ,optWid:Option[Int],optHgh:Option[Int],
                         bytes: Array[Byte]):DBOResult[Completed] ={
      var doc = Document(
        "pid" -> pid,
        "seqno" -> seqno,
        "pic" -> bytes
      )
      if (optDesc != None)
        doc = doc + ("desc" -> optDesc.get)
      if (optWid != None)
        doc = doc + ("desc" -> optWid.get)
      if (optHgh != None)
        doc = doc + ("desc" -> optHgh.get)
      repository.insert(doc)
    }

好了，現在整篇程式碼變成了下面這樣：

       (post &  parameters('pid,'desc.?,'width.as[Int].?,'heigth.as[Int].?)) { (pid, optDesc, optWid, optHgh) =>
          withoutSizeLimit {
            decodeRequest {
              extractDataBytes { bytes =>
                val futBytes = bytes.runFold(ByteString()) { case (hd, bs) =>
                  hd ++ bs
                }
                val futSeqno = for {
                  cnt <- repository.count(pid).toFuture
                  barr <- futBytes
                  _ <- addPicuture(pid, cnt, optDesc, optWid, optHgh, barr.toArray).toFuture
                } yield cnt
                complete(futSeqno.map(_.toString))
              }
            }

現在是不是變得簡單易明瞭？如果你覺著這樣看起來更加容易理解，那麼我建議你現在開始多點接觸瞭解函數語言程式設計。

接著用同樣方式把整個專案重新實現一次。修改後的原始碼如下：

MongoRepo.scala

package com.datatech.rest.mongo
import org.mongodb.scala._
import org.bson.conversions.Bson
import org.mongodb.scala.result._
import com.datatech.sdp.mongo.engine._
import MGOClasses._
import MGOEngine._
import MGOCommands._
import com.datatech.sdp.result.DBOResult.DBOResult

object MongoRepo {

  class MongoRepo[R](db:String, coll: String, converter: Option[Document => R])(implicit client: MongoClient) {
    def getAll[R](next:Option[String],sort:Option[String],fields:Option[String],top:Option[Int]): DBOResult[Seq[R]] = {
      var res = Seq[ResultOptions]()
      next.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_FILTER,Some(Document(b)))}
      sort.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_SORT,Some(Document(b)))}
      fields.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_PROJECTION,Some(Document(b)))}
      top.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_LIMIT,None,b)}

      val ctxFind = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_QUERY)
        .setCommand(Find(andThen = res))
      mgoQuery[Seq[R]](ctxFind,converter)
    }

    def query[R](filtr: Bson, next:Option[String]=None,sort:Option[String]=None,fields:Option[String]=None,top:Option[Int]=None): DBOResult[Seq[R]] = {
      var res = Seq[ResultOptions]()
      next.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_FILTER,Some(Document(b)))}
      sort.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_SORT,Some(Document(b)))}
      fields.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_PROJECTION,Some(Document(b)))}
      top.foreach {b => res = res :+ ResultOptions(FOD_TYPE.FOD_LIMIT,None,b)}
      val ctxFind = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_QUERY)
        .setCommand(Find(filter = Some(filtr),andThen = res))
      mgoQuery[Seq[R]](ctxFind,converter)
    }

    import org.mongodb.scala.model.Filters._
    def count(pid: String):DBOResult[Int] = {
      val ctxCount = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_QUERY)
        .setCommand(Count(filter=Some(equal("pid",pid))))
      mgoQuery[Int](ctxCount,None)
    }

    def getOneDocument(filtr: Bson): DBOResult[Document] = {
      val ctxFind = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_QUERY)
        .setCommand(Find(filter = Some(filtr),firstOnly = true))
      mgoQuery[Document](ctxFind,None)
    }
    def getOnePicture[R](pid: String, seqno: Int): DBOResult[R] = {
      val ctxFind = MGOContext(dbName = db, collName = coll)
        .setActionType(MGO_ACTION_TYPE.MGO_QUERY)
        .setCommand(Find(filter = Some(and(equal("pid",pid),equal("seqno",seqno))), firstOnly = true))
      mgoQuery[R](ctxFind, converter)
    }
    def insert(doc: Document): DBOResult[Completed] = {
      val ctxInsert = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_UPDATE)
        .setCommand(Insert(Seq(doc)))
      mgoUpdate[Completed](ctxInsert)
    }

    def delete(filter: Bson): DBOResult[DeleteResult] = {
      val ctxDelete = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_UPDATE)
        .setCommand(Delete(filter))
      mgoUpdate[DeleteResult](ctxDelete)
    }

    def update(filter: Bson, update: Bson, many: Boolean): DBOResult[UpdateResult] = {
      val ctxUpdate = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_UPDATE)
        .setCommand(Update(filter,update,None,!many))
      mgoUpdate[UpdateResult](ctxUpdate)
    }

    def replace(filter: Bson, row: Document): DBOResult[UpdateResult] = {
      val ctxUpdate = MGOContext(dbName = db,collName=coll)
        .setActionType(MGO_ACTION_TYPE.MGO_UPDATE)
        .setCommand(Replace(filter,row))
      mgoUpdate[UpdateResult](ctxUpdate)
    }

  }
  import monix.execution.Scheduler.Implicits.global
  implicit class DBResultToFuture(dbr: DBOResult[_]){
      def toFuture[R] = {
        dbr.value.value.runToFuture.map {
          eor =>
            eor match {
              case Right(or) => or match {
                case Some(r) => r.asInstanceOf[R]
                case None => throw new RuntimeException("Operation produced None result!")
              }
              case Left(err) => throw new RuntimeException(err)
            }
        }
      }
  }

}

MongoRoute.scala

package com.datatech.rest.mongo
import akka.http.scaladsl.server.Directives
import com.datatech.sdp.file._

import scala.util._
import org.mongodb.scala._
import com.datatech.sdp.file.Streaming._
import org.mongodb.scala.result._
import MongoRepo._
import akka.stream.ActorMaterializer
import com.datatech.sdp.result.DBOResult._
import org.mongodb.scala.model.Filters._
import com.datatech.sdp.mongo.engine.MGOClasses._
import monix.execution.CancelableFuture
import akka.util._
import akka.http.scaladsl.model._
import akka.http.scaladsl.coding.Gzip
import akka.stream.scaladsl._
import MongoModels.WebPic

import scala.concurrent._
import scala.concurrent.duration._
object MongoRoute {
  class MongoRoute[M <: ModelBase[Document]](val pathName: String)(repository: MongoRepo[M])(
    implicit c: MongoClient, m: Manifest[M], mat: ActorMaterializer) extends Directives with JsonConverter {
    import monix.execution.Scheduler.Implicits.global
    var dbor: DBOResult[Seq[M]] = _
    var dbou: DBOResult[UpdateResult] = _
    val route = pathPrefix(pathName) {
      pathPrefix("pictures") {
        (post &  parameters('pid,'desc.?,'width.as[Int].?,'heigth.as[Int].?)) { (pid, optDesc, optWid, optHgh) =>
          withoutSizeLimit {
            decodeRequest {
              extractDataBytes { bytes =>
                val futBytes = bytes.runFold(ByteString()) { case (hd, bs) =>
                  hd ++ bs
                }
                val futSeqno = for {
                  cnt <- repository.count(pid).toFuture[Int]
                  barr <- futBytes
                  _ <- addPicuture(pid, cnt, optDesc, optWid, optHgh, barr.toArray).toFuture[Completed]
                } yield cnt
                complete(futSeqno.map(_.toString))
              }
            }
          } ~
            (get & parameters('pid, 'seqno.as[Int].?, 'width.as[Int].?, 'height.as[Int].?)) {
              (pid, optSeq, optWid, optHght) =>
                if (optSeq == None) {
                  val futRows = repository.query(equal("pid", pid)).toFuture
                  complete(futureToJson(futRows))
                } else {
                  val futPicRow = repository.getOnePicture(pid, optSeq.get).toFuture[WebPic]
                  onComplete(futPicRow) {
                    case Success(row) =>
                      val width = if (optWid == None) row.width.getOrElse(128) else optWid.getOrElse(128)
                      val height = if (optHght == None) row.heigth.getOrElse(128) else optHght.getOrElse(128)
                      if (row.pic != None) {
                        withoutSizeLimit {
                          encodeResponseWith(Gzip) {
                            complete(
                              HttpEntity(
                                ContentTypes.`application/octet-stream`,
                                ByteArrayToSource(Imaging.setImageSize(row.pic.get.getData, width, height)
                                ))
                            )
                          }
                        }
                      } else complete(StatusCodes.NotFound)
                    case Failure(err) => complete(err)
                  }
                }
            }
        }
      } ~
        pathPrefix("blob") {
          (get & parameter('filter)) { filter =>
            val filtr = Document(filter)
            val futOptPic: CancelableFuture[Option[MGOBlob]] = repository.getOneDocument(filtr).toFuture
            onComplete(futOptPic) {
              case Success(optBlob) => optBlob match {
                case Some(blob) =>
                  withoutSizeLimit {
                    encodeResponseWith(Gzip) {
                      complete(
                        HttpEntity(
                          ContentTypes.`application/octet-stream`,
                          ByteArrayToSource(blob.getData)
                        )
                      )
                    }
                  }
                case None => complete(StatusCodes.NotFound)
              }
              case Failure(err) => complete(err)
            }
          } ~
            (post &  parameter('bson)) { bson =>
              val bdoc = Document(bson)
              withoutSizeLimit {
                decodeRequest {
                  extractDataBytes { bytes =>
                    val futbytes = bytes.runFold(ByteString()) { case (hd, bs) =>
                      hd ++ bs
                    }
                    val futmsg:Future[Completed] = for {
                      bytes <- futbytes
                      doc = Document(bson) + ("photo" -> bytes.toArray)
                      c <- repository.insert(doc).toFuture[Completed]
                    } yield c
                    complete(futmsg.map(_.toString))
                  }
                }
              }
            }
        } ~
        (get & parameters('filter.?,'fields.?,'sort.?,'top.as[Int].?,'next.?)) {
          (filter,fields,sort,top,next) => {
            dbor = {
              filter match {
                case Some(fltr) => repository.query(Document(fltr),next,sort,fields,top)
                case None => repository.getAll(next,sort,fields,top)
              }
            }
            val futRows:Future[Seq[WebPic]] = dbor.toFuture[Seq[WebPic]]
            complete(futureToJson(futRows))
          }
        } ~ post {
        entity(as[String]) { json =>
          val extractedEntity: M = fromJson[M](json)
          val doc: Document = extractedEntity.to
          val futmsg = repository.insert(doc).toFuture[Completed]
          complete(futmsg.map(_.toString))
        }
      } ~ (put & parameter('filter,'set.?, 'many.as[Boolean].?)) { (filter, set, many) =>
        val bson = Document(filter)
        if (set == None) {
          entity(as[String]) { json =>
            val extractedEntity: M = fromJson[M](json)
            val doc: Document = extractedEntity.to
            val futmsg = repository.replace(bson, doc).toFuture
            complete(futureToJson(futmsg))
          }
        } else {
          set match {
            case Some(u) =>
              val ubson = Document(u)
              dbou = repository.update(bson, ubson, many.getOrElse(true))
            case None =>
              dbou = Left(new IllegalArgumentException("missing set statement for update!"))
          }
          val futmsg:Future[UpdateResult] = dbou.toFuture[UpdateResult]
          complete(futureToJson(futmsg.map(_.toString)))
        }
      } ~ (delete & parameters('filter, 'many.as[Boolean].?)) { (filter,many) =>
        val bson = Document(filter)
        val futmsg:Future[DeleteResult] = repository.delete(bson).toFuture[DeleteResult]
        complete(futureToJson(futmsg.map(_.toString)))
      }
    }

    def addPicuture(pid: String,seqno: Int, optDesc: Option[String]
                         ,optWid:Option[Int],optHgh:Option[Int],
                         bytes: Array[Byte]):DBOResult[Completed] ={
      var doc = Document(
        "pid" -> pid,
        "seqno" -> seqno,
        "pic" -> bytes
      )
      if (optDesc != None)
        doc = doc + ("desc" -> optDesc.get)
      if (optWid != None)
        doc = doc + ("desc" -> optWid.get)
      if (optHgh != None)
        doc = doc + ("desc" -> optHgh.get)
      repository.insert(doc)
    }

  }

}

&n

相關推薦

restapi（6）- do it the functional way, 重溫函數語言程式設計

  再次看了看上篇部落格的原始碼，發現連自己都看不懂了。想是為了趕時間交貨不知不覺又回到OOP行令模式了，看看下面這段程式碼： (post & parameters('pid,'desc.?,'width.as[Int].?,'heigth.as[Int].?)) { (p

Python從菜鳥到高手（6）：獲取用戶輸入、函數與註釋

依次 都是 正弦 .cn 應該 asc pri 控制臺 html 1. 獲取用戶輸入   要編寫一個有實際價值的程序，就需要與用戶交互。當然，與用戶交互有很多方法，例如，GUI（圖形用戶接口）就是一種非常好的與用戶交互的方式，不過我們先不討論GUI的交互

restapi（7）- 談談函數語言程式設計的思維模式和習慣

  國慶前，參與了一個c# .net 專案，真正重新體驗了一把搬磚感覺：在一個多月時間好像不加任何思考，不斷敲鍵盤加程式碼。我想，這也許是行業內大部分中小型公司程式猿的真實寫照：都是坐在電腦前的搬磚工人。不過也不是沒有任何收穫，在搬磚的過程中我似乎發現了一些現象和造成這些現象背後的原因及OOP思維、

面向對象編程（2）self的含義，析構函數，數據庫類練習

一行代碼 pan host port @property sel hal toc dict 1.類的聯系使用 class Baby(): country = ‘China‘ #類變量，公共的變量,每個實例都可以用 對於公共的東西可以定義節省內存 def my

從零開始學 Web 之 BOM（三）offset，scroll，變速動畫函數

樣式 清理 java mar dde sof mov har width 大家好，這裏是「 從零開始學 Web 系列教程 」，並在下列地址同步更新...... github：https://github.com/Daotin/Web 微信公眾號：Web前端之巔 博客園：

前端（十三）—— JavaScript高級：回調函數、閉包、循環綁定、面向對象、定時器

set 執行 使用 一次 name屬性 解決案例 就會 請求 事件 回調函數、閉包、循環綁定、面向對象、定時器 一、函數高級 1、函數回調 // 回調函數 function callback(data) {} // 邏輯函數 function func(callback)

Java-函數語言程式設計（三）流（Stream）

流使程式猿可以在抽象層上對集合進行操作。 從外部迭代到內部迭代 什麼是外部迭代和內部迭代呢？ 個人認為，外和內是相對集合程式碼而言。 如果迭代的業務執行在應用程式碼中，稱之為外部迭代。 反之，迭代的業務執行在集合程式碼中，稱為內部迭代（函數語言程式設計）。 語言描述可能有點抽象，下面看例項。

scala筆記-函數語言程式設計（13）

將函式賦值給變數 // Scala中的函式是一等公民，可以獨立定義，獨立存在，而且可以直接將函式作為值賦值給變數 // Scala的語法規定，將函式賦值給變數時，必須在函式後面加上空格和下劃線 def sayHello(name: String) { println("Hel

Java-函數語言程式設計（一）初識篇

原文連結：https://www.javazhiyin.com/20249.html 開發者使用Java8編寫複雜的集合處理演算法，只需要簡單的程式碼就能在多喝cpu上高效執行，這就是Lambda表示式的初衷。 提示：函數語言程式設計和語言無關，它是一種思想，任何語言都可以實現

Java-函數語言程式設計（三）流（掃雷原始碼出售）

什麼是掃雷原始碼出售QQ2952777280【話仙原始碼論壇】hxforum.com外部迭代和內部迭代呢？ 個人認為，外和內是相對集合程式碼而言。 如果迭代的業務執行在應用程式碼中，稱之為外部迭代。 反之，迭代的業務執行在集合程式碼中，稱為內部迭代（函數語言程式設計）。 語言

【Spark】SparkRDD開發手冊（JavaAPI函數語言程式設計）

文章目錄 前言 遇到的大坑！ 裝備 Core Github 總結 前言 不用怕，問題不大~ github已更新 scala版過段時間會再更新 自誇一下… 老實說,相比那些抄襲來抄襲去的

Python函數語言程式設計（一）：高階函式

首先有一個高階函式的知識。 一個函式可以接收另一個函式作為引數，這種函式就稱之為高階函式。 def add(x, y, f): return f(x) + f(y) 當我們呼叫add(-5, 6, abs)時，引數x，y和f分別接收-5，6和abs，根據函式定義，我們可以推導計算過程為：

Python學習（4）——函數語言程式設計

函數語言程式設計的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許返回一個函式！ Python對函數語言程式設計提供部分支援。由於Python允許使用變數，因此，Python不是純函數語言程式設計語言。 1、高階函式 （1）map      

Scala函數語言程式設計（一）

package PXL.basics import sun.security.util.Length /*** * 使用Alt + /可以自動補全 * def 後面就可以看成函式 * 函式是一等公民，可以像變數一樣被傳遞，被賦值；並且函式和變數之間可以賦值傳遞，可以把函式當成一個變

Python(九)語法 函數語言程式設計（函式作為返回值,lambda）

函式作為返回值 高階函式除了可以接受函式作為引數外，還可以把函式作為結果值返回。 我們來實現一個可變引數的求和。通常情況下，求和的函式是這樣定義的： >>> def sum(*args): ... s=0 ... for x in args: ... s=s+x

Python(八)語法 函數語言程式設計（map/reduce/filter/sorted）

map map()函式接收兩個引數，一個是函式，一個是Iterable，map將傳入的函式依次作用到序列的每個元素，並把結果作為新的Iterator返回。，簡單點說就是讓每個元素執行函式，如下對L中每個元素求平方 >>> def f(x): ... return x*x

函數語言程式設計 - 有趣的Monoid（單位半群）

前言 Monoid（中文：單位半群，又名：么半群），一個來源於數學的概念；得益於它的抽象特性，Monoid在函數語言程式設計中起著較為重大的作用。 本篇文章將會以工程的角度去介紹Monoid的相關概念，並結合幾個有趣的資料結構（如Middleware、Writer）來展現Monoid自身強大的能力及其實用

Streams filter 例子 （函數語言程式設計 ） Java 8

在本教程中，我們將向你展示一些java 8個例子來演示的流filter()，collect()使用，findany()和orelse(). 1. Streams filter() and collect()   1.1 Java 8之前, 過濾一 List 

什麼是函數語言程式設計（副作用、純函式、引用透明）

　　　　副作用的概念：一個帶有副作用的函式不僅只是簡單的返回一個值，還幹了一些其他的事情，比如: 修改一個變數 直接修改資料結構 設定一個物件的成員 丟擲一個異常或以一個錯誤終止 列印到終端或讀取使用者的輸入

scala的函數語言程式設計（二）

  引數型別推導 scala會盡可能地推匯出函式的型別，使得scala程式碼非常簡潔 //引數型別推斷 Array(1,2,3,4).map((x : Int) => x * 3) //map方法會推斷出要出入一個 Int => Int 型別的函式，因此可以省略函式