The difference between scala script and applicatio

问题:

What is the difference between a scala script and scala application? Please provide an example

The book I am reading says that a script must always end in a result expression whereas the application ends in a definition. Unfortunately no clear example is shown.

Please help clarify this for me

回答1:

I think that what the author means is that a regular scala file needs to define a class or an object in order to work/be useful, you can't use top-level expressions (because the entry-points to a compiled file are pre-defined). For example:

println("foo")

object Bar {
    // Some code
}

The println statement is invalid in the top-level of a .scala file, because the only logical interpretation would be to run it at compile time, which doesn't really make sense.

Scala scripts in contrast can contain expressions on the top-level, because those are executed when the script is run, which makes sense again. If a Scala script file only contains definitions on the other hand, it would be useless as well, because the script wouldn't know what to do with the definitions. If you'd use the definitions in some way, however, that'd be okay again, e.g.:

object Foo {
    def bar = "test"
}

println(Foo.bar)

The latter is valid as a scala script, because the last statement is an expression using the previous definition, but not a definition itself.

回答2:

Comparison

Features of scripts:

• Like applications, scripts get compiled before running. Actually, the compiler translates scripts to applications before compiling, as shown below.
• No need to run the compiler yourself - scala does it for you when you run your script.
• Feeling is very similar to script languages like bash, python, or ruby - you directly see the results of your edits, and get a very quick debug cycle.
• You don't need to provide a main method, as the compiler will add one for you.

Scala scripts tend to be useful for smaller tasks that can be implemented in a single file.

Scala applications on the other hand, are much better suited when your projects start to grow more complex. They allow to split tasks into different files and namespaces, which is important for maintaining clarity.

Example

If you write the following script:

#!/usr/bin/env scala

println("foo")

Scala 2.11.1 compiler will pretend (source on github) you had written:

object Main {
  def main(args: Array[String]): Unit =
    new AnyRef {
      println("foo")
    }
}

回答3:

Well, I always thought this is a Scala script:

$ cat script

#!/usr/bin/scala
!#

println("Hello, World!")

Running with simple:

$ ./script

An application on the other hand has to be compiled to .class and executed explicitly using java runtime.