文章转至点击进入原文章
最近刚碰到个好机会去用scala，所以从本章开始记录scala的学习笔记，更多是实验就形式来表述和记录。如需转载请附带文章地址

1、scala入门准备工作

学习环境我是这样搭建的

首先选择ubuntu linux 14.04

然后安装docker 安装docker教程点这里

安装好后docker后，下载scala环境镜像

sudo docker pull index.alauda.cn/ttch/scala

下载好后，然后执行如下命令

sudo docker run --rm    \
    -v 本地目录:/scala \
    -it index.alauda.cn/ttch/scala bash

可以看到进入了一个bash console下。然后尝试执行scala。这样就进入了控制台程序中。

2、scala学习之旅

scala文法结构参考如下地址点击

阅读了不少scala的书籍和文章，几乎没有一个系统结构性讲解scala的。所以这也是写本系列文章的目的

下面简单按照几个结构进行整理和学习：

• scala语法结构
• 函数式
• 算子
• 组合算子

争取能梳理一个系统的文章路径，提供快速学习scala（本身scala这个语言的学习曲线也十分陡峭)

2.1、 scala语法结构

下面我们从文法角度去逐个使用例子看scala的使用方式和方法。

2.1.1关键词

abstract    case        catch       class       def
do          else        extends     false       final
finally     for         forSome     if          implicit
import      lazy        macro       match       new
null        object      override    package     private
protected   return      sealed      super       this
throw       trait       try         true        type
val         var         while       with        yield
_    :    =    =>    <-    <:    <%     >:    #    @

以上是的关键词组成

2.1.2 变量和常量声明的文法结构

那么下面先通过scala的交互命令行来进行基本的实验和讲解。

首先先来实验基本的定义声明，那么看看她的文法是什么样的？

 Dcl               ::=  ‘val’ ValDcl
                      |  ‘var’ VarDcl
                      |  ‘def’ FunDcl
                      |  ‘type’ {nl} TypeDcl

定义声明分成4部分。

那么首先看下完成val定义文法

---

方法1：

plainid  ::=  upper idrest
            |  varid
            |  op
id       ::=  plainid
            |  ‘`’ stringLiteral ‘`’
ValDcl   ::=  ids ‘:’ Type
ids      ::=  id {‘,’ id}

方法2：

PatVarDef         ::=  ‘val’ PatDef
                   |  ‘var’ VarDef
PatDef            ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr

Pattern2          ::=  varid [‘@’ Pattern3]
                  |  Pattern3
Pattern3          ::=  SimplePattern
                  |  SimplePattern { id [nl] SimplePattern }
SimplePattern     ::=  ‘_’
                    |  varid
                    |  Literal
                    |  StableId
                    |  StableId ‘(’ [Patterns ‘)’
                    |  StableId ‘(’ [Patterns ‘,’] [varid ‘@’] ‘_’ ‘*’ ‘)’
                    |  ‘(’ [Patterns] ‘)’
                    |  XmlPattern

两种定义常量的方法可以看出，一个是需要提供类型

val valname : type = ...

另一种是直接定义常量，通过推导的方式得到常量的类型和初始化值。

val valname = ...

�假设()为可以存在或者不存在，按照语言的结构可以按照这样的理解

val valname (: type) = 推导公式

下面列举一些patVarDef中 val的定义方式有以下几种：

1.1

val (abc, bcd) = ("123","123")

结果为：

abc: String = 123
bcd: String = 123

1.2

val abc = (2,3)

结果为：

x: (Int, Int) = (2,3)

1.3

val array@Array(_,test) = Array("hello","hello")

结果为

array: Array[String] = Array(hello, hello)
test: String = hello

那么在上面的文法中可以看到可以跟指定 Type

val array@Array(test1:Any,test:String) = Array("hello","hello")

结果为：

array: Array[String] = Array(hello, hello)
test1: Any = hello
test: String = hello

1.4

val array@_,array2@_ =( Array("hello","hello"),Array("test","test"))

上面是一个多常量初始化赋值的文法，结果如下：

array: (Array[String], Array[String]) = (Array(hello, hello),Array(test, test))
array2: (Array[String], Array[String]) = (Array(hello, hello),Array(test, test))

那么左边加上括号是有上面区别呢？

 val (array@_,array2@_) =( Array("hello","hello"),Array("test","test"))

结果如下：

array: Array[String] = Array(hello, hello)
array2: Array[String] = Array(test, test)

2.1.3 StableId

如果需要了解更多可以点击官方参考，
那么上面文法多次提到了StableId,stableId的文法是有如下构成的。

 StableId          ::=  id
                  |  Path ‘.’ id
 id               ::=  plainid
             |  ‘`’ stringLiteral ‘`’
 plainid          ::=  upper idrest
             |  varid
             |  op
varid            ::=  lower idrest
upper            ::=  ‘A’ | … | ‘Z’ | ‘$’ | ‘_’  // and Unicode category Lu
lower            ::=  ‘a’ | … | ‘z’ // and Unicode category Ll
idrest           ::=  {letter | digit} [‘_’ op]

那么根据官方参考来看看如下模式如何使用

如下有3种模式：

SimplePattern     ::=  StableId
                    |  StableId ‘(’ [Patterns ‘)’
                    |  StableId ‘(’ [Patterns ‘,’] [varid ‘@’] ‘_’ ‘*’ ‘)’

根据上面文法树分支可以得到4种模式

• Stable Identifier Patterns

    SimplePattern   ::=  StableId
  

• Constructor Patterns

    SimplePattern   ::=   ‘(’ [Patterns ‘)’
  

• Extractor Patterns

    SimplePattern   ::=   ‘(’ [Patterns ‘)’
  

• Pattern Sequences

    SimplePattern ::= StableId ‘(’ [Patterns ‘,’] [varid ‘@’] ‘_’ ‘*’ ‘)’
  

下面一个个分析其中模式和代码方式，这里只从val和var的角度去看待，其他模式下的使用方式暂时不作实验记录。

2.1.4 Stable Identifier Patterns

假设有这样一个需求，需要声明一个常量a，常量A初始化为C，现在需要确定C变量是否和B变量值匹配，如果不一样则报错。

那么可以这样写
val B , C = "hello"

结果如下：

B: String = hello
C: String = hello

赋值代码如下：

val a@B = C

结果如下：

 a: String = hello

2.1.5 Constructor Patterns

例子1

val a@("hello",1) = ("hello",1)

结果如下 ：

a: (String, Int) = (hello,1)

例子2

val a@("hello","string") = ("hello",1)

结果如下：

<console>:8: error: type mismatch;
found   : String("string")
required: Int
   val a@("hello","string") = ("hello",1)
                  ^

从上面可以看出，构建常量的匹配初始化校验方式。

2.1.6 Extractor Patterns

官方例子:

val x = (1, 2)
val y = x match {
  case Pair(i, s) => Pair(s + i, i * i)
}

2.1.7 Pattern Sequences

val a@Seq('h','e','l',test @ _*) = Seq('h','e','l','l','o')


a: Seq[Char] = List(h, e, l, l, o)
test: Seq[Char] = List(l, o)

今天实验就到这了。