弁言

js的形式婚配不壮大,然则也有一些运用,近来在应用业余周末时候断续体系性的学scala,我进修scala目标就是邃晓和控制它的函数式编程，团体还没学完。在这篇文章中会js连系scala的体式格局一同对照剖析总结下,不申明默许是js写法。

Destructure

Object

let name;
let {people:{age=Infinity,name}} = {people:{name:"JSDT"}}
// name "JSDT"

Array

let [a=1,b=2,c]=['a',]
// a 'a' 、 b 2 、c 'undefined'

Function

function JSDT([first,...rest]) {
    console.log(first,rest)
}
JSDT([1,2,3,4]);
//1,[2,3,4]

ADT(Algebraic Data Type)

上述实质来讲基于位置match,基本且经常使用,scala中也有,比较基本,我不想反复枚举了。在js中不支持自定义范例婚配,然则在形式婚配中这是重要一环,由于近来在学scala,所以自创一下内里的头脑和完成体式格局,由于其原生供应ADT体式格局的match。

原生范例(Scala)

  def acceptAny(x:Any):String={
    x  match {
      case s:String =>"a string"
      case i:Int if(i<20) => s"an int less than 20: $i"
      case  _ => "don`t know"
    }
  }
   def main(args: Array[String]): Unit = {
      println(acceptAny(10));  //an int less than 20: 10
   }

自定义数据范例(scala)

case object Nil extends List[Nothing]

case class Cons[+A](head: A, tail: List[A]) extends List[A]
<!------------------------------->
def sum(ints: List[Int]): Int = ints match {
  case Nil => 0 // 空list 返回0
  case Cons(x,xs) => x + sum(xs) // recursive 乞降
}

  val x = List(1,2,3,4,5) match {
    case Cons(x, Cons(2, Cons(4, _))) => x
    case Nil => 42
    case Cons(x, Cons(y, Cons(3, Cons(4, _)))) => x + y  
    case Cons(h, t) => h + sum(t)
    case _ => 101
  }

  def main(args: Array[String]): Unit = {
   println( sum(List(1,2,3)))  //6
   println( x)  //3

  }

申明 为了搞邃晓和运转这个例子研讨了有好一会儿,书上(scala函数式编程Page:25)写的没问题,然则写的不完整,我做了部份补充。
sum示例中形式婚配空构造范例Nil和非空构造范例Cons(由head和tail{tail由List组成}组成), 乞降是经由过程递归的体式格局;
x match虽然case3、4、5都婚配,然则第一次婚配上的才会见效。
总的来讲ADT这类体式格局长处是天真,借助这类壮大的自定义范例婚配体系,能够简化代码构造,使代码更易读和保护。

自定义数据范例

const ListOf = T => {
    var List = Type({
        Nil:[],
        Cons:[T,List]
    });
    return List;
}
const LoN = ListOf(Number);
let list= LoN.Cons(1,LoN.Cons(2,LoN.Cons(3,LoN.Nil)));
// let list= LoN.Cons(1);

const sum = LoN.case({
    Cons:(head,tail) => head + sum(tail),
    Nil:(x) => 0
});
console.log(sum(list));  //6

申明 js自身不支持adt的体式格局婚配,借助第三方东西union-type能够完成,上述我写了一个和scala sum形式婚配功用雷同的match例子,由于黑白原生,所以写法上冗余,但其头脑上和scala一样,只是形式上不一样。