❶ 如何調用scala里的val 值
條件表達式
Scala的if/else語法結構和Java或C++一樣。不過，在Scala中if/else表達式有值，這個值就是跟在if或else之後的表達式的值。例如：
if (x > 0) 1 else -1
上述表達式的值是1或−1，具體是哪一個取決於x的值。你可以將if/else表達式的值賦值給變數：
val s = if (x > 0) 1 else -1
這與如下語句的效果一樣：
if (x > 0) s = 1 else s = -1
不過，第一種寫法更好，因為它可以用來初始化一個val。而在第二種寫法當中，s必須是var。
（之前已經提過，Scala中的分號絕大多數情況下不是必需的。）
Java和C++有一個?:操作符用於同樣目的。如下表達式
x > 0 ? 1 : -1 // Java或C++
等同於Scala表達式 if (x > 0) 1 else −1。不過，你不能在?:表達式中插入語句。Scala的if/else將在Java和C++中分開的兩個語法結構if/else和?:結合在了一起。
在Scala中，每個表達式都有一個類型。舉例來說，表達式 if (x > 0) 1 else −1的類型是Int，因為兩個分支的類型都是Int。混合類型表達式，比如：
if (x > 0) "positive" else -1
上述表達式的類型是兩個分支類型的公共超類型。在本例中，其中一個分支是java.lang.String，而另一個分支是Int。它們的公共超類型叫做Any。（詳細內容參見8.11節。）
如果else部分缺失了，比如：
if (x > 0) 1
那麼有可能if語句沒有輸出值。但是在Scala中，每個表達式都應該有某種值。這個問題的解決方案是引入一個Unit類，寫做()。不帶else的這個if語句等同於
if (x > 0) 1 else ()
你可以把()當做是表示「無有用值」的佔位符，將Unit當做Java或C++中的void。（從技術上講，void沒有值但是Unit有一個表示「無值」的值。如果你一定要深究的話，這就好比空的錢包和裡面有一張寫著「沒錢」的無面值鈔票的錢包之間的區別。）
說明：Scala沒有switch語句，不過它有一個強大得多的模式匹配機制，我們將在第14章中看到。在現階段，用一系列的if語句就好。
注意：REPL比起編譯器來更加「近視」——它在同一時間只能看到一行代碼。
舉例來說，當你鍵入如下代碼時：
if (x > 0) 1
else if (x == 0) 0 else -1
REPL會執行 if (x > 0) 1，然後顯示結果。之後它看到接下來的else關鍵字就會不知所措。
如果你想在else前換行的話，用花括弧：
if (x > 0) { 1
} else if (x == 0) 0 else -1
只有在REPL中才會有這個顧慮。在被編譯的程序中，解析器會找到下一行的else。
提示：如果你想在REPL中粘貼成塊的代碼，而又不想擔心REPL的近視問題，可以使用粘貼模式。鍵入：
:paste
把代碼塊粘貼進去，然後按下Ctrl+D。這樣REPL就會把代碼塊當做一個整體來分析。
語句終止
在Java和C++中，每個語句都以分號結束。而在Scala中——與JavaScript和其他腳本語言類似——行尾的位置不需要分號。同樣，在}、else以及類似的位置也不必寫分號，只要能夠從上下文明確地判斷出這里是語句的終止即可。
不過，如果你想在單行中寫下多個語句，就需要將它們以分號隔開。例如：
if (n > 0) { r = r * n; n -= 1 }
我們需要用分號將 r = r * n 和 n -= 1 隔開。由於有}，在第二個語句之後並不需要寫分號。
如果你在寫較長的語句，需要分兩行來寫的話，就要確保第一行以一個不能用做語句結尾的符號結尾。通常來說一個比較好的選擇是操作符：
s = s0 + (v - v0) * t + // +告訴解析器這里不是語句的末尾
0.5 * (a - a0) * t * t
在實際編碼時，長表達式通常涉及函數或方法調用，如此一來你並不需要過分擔心——在左括弧（之後，編譯器直到看到匹配的）才會去推斷某處是否為語句結尾。
正因如此，Scala程序員們更傾向於使用Kernighan & Ritchie風格的花括弧：
if (n > 0) {
r = r * n
n -= 1
}
以{結束的行很清楚地表示了後面還有更多內容。
許多來自Java或C++的程序員一開始並不適應省去分號的做法。如果你傾向於使用分號，用就是了——它們沒啥壞處。
塊表達式和賦值
在Java或C++中，塊語句是一個包含於{ }中的語句序列。每當你需要在邏輯分支或循環中放置多個動作時，你都可以使用塊語句。
在Scala中，{ }塊包含一系列表達式，其結果也是一個表達式。塊中最後一個表達式的值就是塊的值。
這個特性對於那種對某個val的初始化需要分多步完成的情況很有用。例如，
val distance = { val dx = x - x0; val dy = y - y0; sqrt(dx * dx + dy * dy) }
{ }塊的值取其最後一個表達式，在此處以粗體標出。變數dx和dy僅作為計算所需要的中間值，很乾凈地對程序其他部分而言不可見了。
在Scala中，賦值動作本身是沒有值的——或者，更嚴格地說，它們的值是Unit類型的。你應該還記得，Unit類型等同於Java和C++中的void，而這個類型只有一個值，寫做()。
一個以賦值語句結束的塊，比如
{ r = r * n; n -= 1}
的值是Unit類型的。這沒有問題，只是當我們定義函數時需要意識到這一點。
由於賦值語句的值是Unit類型的，別把它們串接在一起。
x = y = 1 // 別這樣做
y = 1的值是()，你幾乎不太可能想把一個Unit類型的值賦值給x。（與此相對應，在Java和C++中，賦值語句的值是被賦的那個值。在這些語言中，將賦值語句串接在一起是有意義的。）
輸入和輸出
如果要列印一個值，我們用print或println函數。後者在列印完內容後會追加一個換行符。舉例來說，
print("Answer: ")
println(42)
與下面的代碼輸出的內容相同：
println("Answer: " + 42)
另外，還有一個帶有C風格格式化字元串的printf函數：
printf("Hello, %s! You are %d years old.\n", "Fred", 42)
你可以用readLine函數從控制台讀取一行輸入。如果要讀取數字、Boolean或者是字元，可以用readInt、readDouble、readByte、readShort、readLong、readFloat、readBoolean或者readChar。與其他方法不同，readLine帶一個參數作為提示字元串：
val name = readLine("Your name: ")
print("Your age: ")
val age = readInt()
printf("Hello, %s! Next year, your will be %d.\n", name, age + 1)
❷ Scala 適合作為腳本語言使用嗎
從語法和庫的角度來說，可以，寫的腳本行數和ruby差不多
但是運行時需要java虛擬機還要安裝scala，有點不方便
java虛擬機啟動還是有點慢，運行scala 腳本文件名.scala 時會有一下卡頓的感覺，不是太爽
❸ scala語言用什麼語言開發的
要問答你這個問題，就應該要去看看scala的源碼：
如果你跟我一樣想要找出cpp結尾的文件，或c編寫的文件，發現你找不到，你只能找到java或scala編寫的文件還有一些腳本文件
❹ Scala 是一門怎樣的語言，具有哪些優缺點
以前在這個版塊也答過關於Scala的問題，但那更多的是知識普及，而沒有談Scala是什麼，做什麼，以及有怎樣的特點。
Scala可怕的地方在於人人都能對它說上一二，但是不一定每個人都能明白。查看這個版塊的帖子，有人把它當做Java的延伸版（一個UPenn賓大的學生Justin Kim ——此人目前在沃頓混得風生水起，當著我的面說Scala是在JVM上的腳本語言），有人把它當做JVM上的C++，有人覺得這是面對對象語言和函數語言的簡單混合，有人覺得這就是Haskell，而且也還不如Haskell強。對Scala的偏見（或者是錯誤的見地）達到了很高的地步，Martin Odersky馬丁·奧德斯基（Scala的發明者，EPFL教授）在今年夏天的Scala Day舊金山大會上發出了這張著名的玩笑照片：
gt;
這個圖片上的翻譯是：「Scala唯一的作用是將人引向Haskell」（原諒我沒法完全直譯）。馬丁·奧德斯基以此作為一個笑話，說他該把Scala改一下名字，叫做Hascalator，還請人設計了一個Logo。
不同的語言有不同的特點，同時也帶來不同的優勢。如果不能理解Scala的特點，就不可能知道如何運用Scala，以及發揮其最大的優勢。一些語言有很顯而易見的優勢，也很容易理解，比如Python，Python的哲學（Zen of Python PEP 20 -- The Zen of Python），我很早的時候曾經覺得有道理，尤其是One way to do it（一種方法做一件事情），理由是對任何任務，雖然可以採用很多方法，但總有最好的一種方法，通過在語言或者哲學層面這樣定義後，能簡化程序員的任務，從而達到提高效率的方法。但經過一段時間的思考後，我突然發現Python其實並不是「一種方法做一件事」的哲學，而是「一種方法做一百萬件事情」的哲學：極其有限的數據結構（只有四個: List, Tuple, Dictionary, Sets），以及不能查看時間復雜度的訪問方法，比如鼓勵人們使用for x in list。
這種處理方式能達到Python最初的打算：發明一種每個人都能使用的簡易語言，但是對於追求速度和效率的程序員而言，這幾乎是略帶噩夢性質的。當然，這不是說Python很慢，通過各種優化（比如NumPy/SciPy中的），以及Cython這樣的將Python直接翻譯為C/C++語言又重新通過C_Mole方式讀回Python環境的編譯器，性能可以得到不少提升，但是仍舊，Python並不追求快。
再舉一個語言的例子：Java。Java的特性或者優勢何在？Java的第一個優勢在於它是第一個系統提供模塊化（mole）設計的語言（在此之前有Smalltalk存在，該貨是OOP的鼻祖）。在Java之前，炒程序員魷魚是很困難的事情，那些C/C++程序員，以及而且尤其是那些Lisp程序員，一旦炒掉他們，新來的人沒有十天半個月，甚至半年，是不可能搞懂前任人士的代碼的。每個人的代碼有自己的邏輯，自己的思路，寫上個數萬行任誰來看都頭疼。這也是為什麼Paul Graham保羅·格雷厄姆（寫了《黑客與畫家》）講他給雅虎做了一個用Lisp寫成的在線商店的案例，在他離開後，雅虎根本沒法維護他寫的代碼，因為數萬行Lisp沒人能弄得很清楚。
Java的模塊化，給企業、大公司帶來了第一道曙光，模塊化之後，這些公司不再給程序員一整個任務，而是一大塊任務的一小塊。介面一定義，虛擬類一定義，換誰上都可以，管你是保羅·格雷厄姆這樣的明星程序員，還是一個新來的大學生，程序員不聽話就直接開除，反正模塊化之後，開除程序員的成本大大降低，這也是為什麼谷歌、甲骨文（這貨最後收購了Java）一類的公司大規模的推崇Java，還一度提出了模塊化人事管理的理念（把人當模塊化的積木一樣隨時移進移出）。
過度企業化後，這延展出了Java的第二個特性，束縛手腳。保羅·格雷厄姆在《黑客與畫家》中寫道，Java屬於B&D（捆綁與束縛）類型的語言。為何束縛手腳？因為要讓新手和明星程序員寫出類似質量的代碼，盡可能的抹消人的才華對程序的影響。不同於C/C++，老手和新手寫出的Java代碼不會有上百倍的耗時差距。但同樣也導致了Java的一個弱點——不容易優化。很多優化Java代碼的程序員必須要對JVM（虛擬機）進行優化，實際上增大了很多任務難度。
通過Python和Java這兩個語言的優缺點，返回來看Scala，就能瞬間明白Scala的定位了。
首先，Scala不把程序員當傻子。當馬丁·奧德斯基宣布Scala 2.12將要簡化語法，推出Scala "Don Giovanni"項目的時候，在視頻中說的很清楚：「Scala現在是為聰明人創造的，以後也是為聰明人服務的。」所以不同於Python讓程序員用一種方法做所有事情，Scala提供一整套工具，讓程序員自由選擇，無論是mutable數據結構，immutable數據結構，並行（parallel）數據結構。然後在這些選擇中，Scala再針對他們進行演算法層面的特殊優化。Scala相信程序員的聰明才智，讓程序員自行選擇合適的結構，以針對變化萬千的任務需求，這點是Scala做得極好的地方。
再者，有人會說immutable數據結構佔用內存，或者速度很慢。這是真的，但這不是Scala的錯，而是這些結構就是這樣定義的。這里講的是Scala集合的運行速度，是一個來自Goldman Sachs的程序員講他們為Java寫的集合庫（GSCollection）速度和內存消耗，但同時比較了gs-collection（goldmansachs/gs-collections · GitHub），Java，和Scala庫的速度。最後Scala的可變集合mutable原生庫完爆Java，和gs-collection基本持平。
Scala的第二個優勢，相較於Java而言，則是相信程序員的優化能力。在Scala with Style講話中（），馬丁·奧德斯基說：「很多程序員會告訴我，他們一般會重構他們的Scala代碼兩三次，甚至三四次。」這聽起來似乎非常的沒有效率，但Scala就是這樣的語言，每一次重構，代碼的性能或者是可讀性都會有極高的提升。
之前就有人提到過，Scala新手和老手寫出來的代碼完全會呈現兩種不同的風格，甚至新人根本不能讀懂有經驗的Scala程序員所寫的代碼，有人於是戲稱：「太好了，這樣的話我們部門的實習生就不能亂碰我寫的代碼啦！」但其實不僅風格不同，執行效率差距也一定是巨大的。Scala提供一整套工具，但是要明白什麼時候用拿一種工具，哪些演算法能夠隨意調用，哪些演算法不能，這一定要依靠經驗、研究和學習以及對源代碼的理解才能得知。最簡單的例子，Scala的foreach()方法是高度優化過了的（尤其針對Range結構和Vector結構），但是fold()就不一定了。或者當受到誘惑想用zipWithIndex()的時候，一定要明白這是兩次循環，最好改用Vector(...).indices.foreach()的方法，或者用.view來推遲執行。
像這樣的地方還有很多。所以在這個層面上來講，簡直和C++非常的相似。從另外一個層面來講，不僅僅是要理解語言層面的優化，Scala作為一個社區而言，是非常追求運行速度的。Ruby社區就完全不同了，Ruby曾經是推特的主要語言。推特的團隊找到了Ruby團隊，說，你們能不能讓Ruby運行的快一點，我們有這個這個和這個建議。Ruby直接把這些建議拒絕了，因為它們會增加語言復雜度，讓Ruby不能繼續做一個「fun」（好玩）的語言。而Python直接就立志做一個「Simple」（簡單）的語言了。於是推特只好將後台換做Scala和Java的結合。有一位在推特工作的知乎友人在我的一個回答下留言說推特換用Scala後，TypeSafe（Scala的母公司）還送去了一個蛋糕。
為了追求速度，Scala社區是絕對不會管所謂的「簡單」或者是「好玩」，怎樣有效率就怎樣弄。與其專注於JVM的改進，Scala社區大部分在編譯器上下功夫，比如很著名的Miniboxing（Miniboxing），這是一個編譯器增進器。Miniboxing做的是什麼呢？只做一件事：防止auto-boxing和auto-unboxing。所有的泛型，尤其是原生類泛型（Primitive Types），諸如Int、Double等等，在進行各種操作的時候會自動取出和裝回它們所屬的類中去——這個我解釋的不太好，但是可以看這里（Java 自動裝箱與拆箱(Autoboxing and unboxing)）。
Miniboxing這樣的插件可以讓所有的原生類泛型再也不用自動裝拆箱，從而將Scala的運行速度提升1.5倍到22倍（）。當然這樣的東西可不是白來的，這是馬丁·奧德斯基的PhD博士學生做的一個研究項目，然後為OOPSLA寫了一篇論文（），所以怪不得這玩意Scala可以有，但其他語言想要有都沒有。
另一個Scala的很大優勢就是所謂的Macro——宏。宏本身作為元編程而言，其實和運行速度是沒有什麼太大關系的，反而，因為對反射（Reflect）的利用，可能會影響到速度。但Scala社區對宏的理解顯然和最初的設計理念有偏差。因為Scala本身是沒有傳統意義的循環的（for-loop），所以很多時候循環必須利用while或者foreach。但是部分追求效率的Scala程序員們利用宏為Scala寫了一個傳統循環，叫做cfor，被收錄在Spire（non/spire · GitHub）數學計算庫中。cfor的寫法如下：
import spire.syntax.cfor._// print numbers 1 through 10cfor(0)(_ < 10, _ + 1) { i =>
println(i)}
而這玩意運行效率如何呢？文章中做了一次測評，將cfor和zip寫的一個演算法作比較——在公布結果之前，我想說的是，zip並不是一個高度優化的方法，所以本身就慢很多，cfor用了26.1毫秒運行，zip方法用了7.4 秒運行，這幾乎是284倍的速度差距。
通過這兩點，Scala的一個優勢就很明顯了——多樣化。當需要寫簡單的代碼，像Python一樣當腳本語言使用時，Scala提供大量的原生方法和數據結構，可以很輕松的寫出比較復雜的操作。但當需要速度的時候，又可以通過重構來獲取數十倍或者上百倍的速度提升。通過Miniboxing一類的編譯器增強器，Scala在某些操作的速度是必定超過Java的。
Scala的第二個優勢就是——一幫勤勞勇敢的PhD博士生。二十一世紀的程序語言和二十世紀的程序語言已經不能比擬了。那個年代的普通人（甚至是學生）還能任意發明一下語言，稍微把編譯器優化幾次就能上得了廳堂（比如那一大堆Lisp方言），到了這個年代，編譯技術已經達到了很復雜的程度（虛擬機技術也是如此），優化和語義理解，程序語言的定義與延展，再也不是隨便任何人都能搞定的工作了。作為編程語言方面的教授，馬丁·奧德斯基不斷的將最前沿的學術界成果轉移到Scala這個語言中，還讓他的博士學生發展出新的，讓語言運行得更快的方法，這些都是其他語言，尤其是Python、Ruby、甚至是Go都沒有的優勢。
當然，說了這么多，總會有人說了，Scala如果像C++一樣難，又追求速度的話，為什麼不直接去學C++，原因很簡單——現在有很多在JVM上面寫成的軟體啊！大家又不是Haskell程序員，壓根不打算一切自己寫吶。
❺ 我怎麼能語法檢查Scala腳本，執行腳本，生成類文件
和C語言類似，在Shell中用if、then、elif、else、fi這幾條命令實現分支控制。這種流程式控制制語句本質上也是由若干條Shell命
令組成的，例如先前講過的
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
其實是三條命令，if [ -f ~/.bashrc ]是第一條，then . ~/.bashrc是第二條，fi是第三條。如果兩條命令寫在同一行則需要用;
號隔開，一行只寫一條命令就不需要寫;號了，另外，then後面有換行，但這條命令沒寫完，Shell會自動續行，把下一行接在then
後面當作一條命令處理。和[命令一樣，要注意命令和各參數之間必須用空格隔開。if命令的參數組成一條子命令，如果該子命令
的Exit Status為0（表示真），則執行then後面的子命令，如果Exit Status非0（表示假），則執行elif、else或者fi後面的子命
令。if後面的子命令通常是測試命令，但也可以是其它命令。Shell腳本沒有{}括弧，所以用fi表示if語句塊的結束。見下例：
#! /bin/sh
if [ -f /bin/bash ]
then echo "/bin/bash is a file"
else echo "/bin/bash is NOT a file"
fi
if :; then echo "always true"; fi
:是一個特殊的命令，稱為空命令，該命令不做任何事，但Exit Status總是真。此外，也可以執行/bin/true或/bin/false得到真
或假的Exit Status。再看一個例子：
#! /bin/sh
echo "Is it morning? Please answer yes or no."
read YES_OR_NO
if [ "$YES_OR_NO" = "yes" ]; then
echo "Good morning!"
elif [ "$YES_OR_NO" = "no" ]; then
echo "Good afternoon!"
else
echo "Sorry, $YES_OR_NO not recognized. Enter yes or no."
exit 1
fi
exit 0
上例中的read命令的作用是等待用戶輸入一行字元串，將該字元串存到一個Shell變數中。
此外，Shell還提供了&&和||語法，和C語言類似，具有Short-circuit特性，很多Shell腳本喜歡寫成這樣：
test "$(whoami)" != 'root' && (echo you are using a non-privileged account; exit 1)
&&相當於「if...then...」，而||相當於「if not...then...」。&&和||用於連接兩個命令，而上面講的-a和-o僅用於在測試表達
式中連接兩個測試條件，要注意它們的區別，例如，
test "$VAR" -gt 1 -a "$VAR" -lt 3
和以下寫法是等價的
test "$VAR" -gt 1 && test "$VAR" -lt 3
#!/bin/bash
echo "Enter your name: "
read A
if [ "$A" = "GS" ];then
echo "yes"
elif [ "$A" = "UC" ];then
echo "no"
else
echo "your are wrong"
fi
(注意：if、elif後要有空格，[]前後有空格，=前後有空格)
#!/bin/bash
read -p "Enter your name: " A
if [ "$A" = "GS" ];then
echo "yes"
elif [ "$A" = "UC" ];then
echo "no"
else
echo "your are wrong"
fi
❻ 如何讓Scala腳本快速運行
#!/bin/sh
exec scala "$0" "$@"
!#
println("Hello, iteblog!!")
args foreach println
我們將這段代碼保存到test.sh文件裡面，然後運行它：
[[email protected] iteblog]$ time sh test.sh
Hello, iteblog!!
real 0m1.070s
user 0m0.380s
sys 0m0.031s
我們可以看出，這么簡單的程序都花費了1.07s才輸出結果。這是因為每次運行的時候都會編譯裡面的內容，編譯完才會運行腳本。值得高興的是，我們可以將編譯的內容保存下來，然後以後運行的速度就會加快。Scala解析器提供了
-savecompiled參數，可以將編譯的內容保存。所以修改後的代碼如下：
#!/bin/sh
exec scala -savecompiled "$0" "$@"
!#
println("Hello, iteblog!!")
args foreach println
運行這個腳本，我們可以發現第一次運行的速度還是很慢，但是當程序運行完，我們可以在同一目錄下發現一個名為test.sh.jar的jar文件，這就是編譯之後的class文件。第二次運行的時候，Scala會檢查該腳本是否修改了，如果沒有修改，會直接使用之前編譯好的test.sh.jar文件，所以以後運行速度會很快：
[[email protected] iteblog]$ time sh test.sh
Hello, iteblog!!
real 0m0.298s
user 0m0.292s
sys 0m0.030s
我們來看看test.sh.jar裡面的內容：
[[email protected] iteblog]$ jar -tvf test.sh.jar
75 Wed Dec 16 19:17:32 CST 2015 META-INF/MANIFEST.MF
832 Wed Dec 16 19:17:32 CST 2015 Main$$anon$1.class
595 Wed Dec 16 19:17:32 CST 2015 Main.class
1097 Wed Dec 16 19:17:32 CST 2015 Main$$anon$1$$anonfun$1.class
547 Wed Dec 16 19:17:32 CST 2015 Main$.class
我們可以看出這些就是編譯後的class文件，我們可以通過scala命令去運行裡面的類：
[[email protected] iteblog]$ scala -cp test.sh.jar Main
Hello, iteblog!!
❼ Scala和java比較
1、 scala可以編寫腳本，編寫一個.scala的腳本代碼，直接用同scala x.scala進行執行。
但同時scala也可以類似java，通過scalac編譯為.class等形式，基於編譯執行。
2、 scala可以在互動式的命令中直接編碼運行。
3、 支持隱式變數定義，通過var關鍵詞定義一個變數，具體變數類型在賦值後，scala自行進行類型推斷。例如var a = List(1,2,3)
4、 常量定義用val 關鍵詞定義
5、 沒有靜態類型，通過object 定義單例類，main方法就是放在object類型中。
❽ scala是編程語言還是腳本語言
按傳統，程序語言分編譯語言和解釋語言。編譯語言要把源程序編譯成2進制可執行程序再運行。而解釋性語言，即所謂腳本語言，不需預先編譯，而可在解釋器的解釋下，直接解釋執行。
我不熟悉scala，看上去scala像似 是一種封裝式的東西，例如，封裝的 java 式的東西 要編譯成 bytecode 後執行。 類似 ruby, python 之類的東西也許可以解釋執行。scala 好像沒有自己的虛擬機，對 scala 的爭論 不少。
❾ 如何讓Scala腳本快速運行
可以加參數，編譯成jar，下次運行會加速