Scala - sintaxe básica

Se você tiver um bom conhecimento de Java, será muito fácil aprender Scala. A maior diferença sintática entre Scala e Java é que o ';' o caractere de fim de linha é opcional.

Quando consideramos um programa Scala, ele pode ser definido como uma coleção de objetos que se comunicam por meio da invocação dos métodos uns dos outros. Vamos agora dar uma olhada rápida no que significam classes, objetos, métodos e variáveis ​​de instância.

• Object- Os objetos têm estados e comportamentos. Um objeto é uma instância de uma classe. Exemplo - Um cão tem estados - cor, nome, raça e também comportamentos - abanar, latir e comer.

• Class - Uma classe pode ser definida como um template / blueprint que descreve os comportamentos / estados relacionados à classe.

• Methods- Um método é basicamente um comportamento. Uma classe pode conter muitos métodos. É nos métodos onde as lógicas são escritas, os dados são manipulados e todas as ações são executadas.

• Fields- Cada objeto tem seu conjunto único de variáveis ​​de instância, que são chamadas de campos. O estado de um objeto é criado pelos valores atribuídos a esses campos.

• Closure - A closure é uma função, cujo valor de retorno depende do valor de uma ou mais variáveis ​​declaradas fora desta função.

• Traits- Uma característica encapsula definições de método e campo, que podem ser reutilizadas misturando-as em classes. Traits são usados ​​para definir tipos de objetos especificando a assinatura dos métodos suportados.

Primeiro Programa Scala

Podemos executar um programa Scala em dois modos: um é interactive mode e outro é script mode.

Modo Interativo

Abra o prompt de comando e use o seguinte comando para abrir o Scala.

\>scala

Se Scala estiver instalado em seu sistema, a seguinte saída será exibida -

Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.

Digite o seguinte texto à direita do prompt do Scala e pressione a tecla Enter -

scala> println("Hello, Scala!");

Isso produzirá o seguinte resultado -

Hello, Scala!

Modo Script

Use as instruções a seguir para escrever um programa Scala no modo de script. Abra o bloco de notas e adicione o seguinte código a ele.

Exemplo

object HelloWorld {
   /* This is my first java program.  
   * This will print 'Hello World' as the output
   */
   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World
   }
}

Salve o arquivo como - HelloWorld.scala.

Abra a janela do prompt de comando e vá para o diretório onde o arquivo do programa foi salvo. O 'scalac'comando é usado para compilar o programa Scala e irá gerar alguns arquivos de classe no diretório atual. Um deles será chamadoHelloWorld.class. Este é um bytecode que será executado na Java Virtual Machine (JVM) usando 'scala'comando.

Use o seguinte comando para compilar e executar seu programa Scala.

\> scalac HelloWorld.scala
\> scala HelloWorld

Resultado

Hello, World!

Sintaxe Básica

A seguir estão as sintaxes básicas e convenções de codificação na programação Scala.

• Case Sensitivity - Scala diferencia maiúsculas de minúsculas, o que significa identificador Hello e hello teria um significado diferente em Scala.

• Class Names- Para todos os nomes de turmas, a primeira letra deve estar em maiúsculas. Se várias palavras forem usadas para formar o nome da classe, a primeira letra de cada palavra interna deve estar em maiúsculas.

  Example - classe MyFirstScalaClass.

• Method Names- Todos os nomes de métodos devem começar com uma letra minúscula. Se várias palavras forem usadas para formar o nome do método, a primeira letra de cada palavra interna deve estar em maiúsculas.

  Example - def myMethodName ()

• Program File Name- O nome do arquivo do programa deve corresponder exatamente ao nome do objeto. Ao salvar o arquivo, você deve salvá-lo usando o nome do objeto (Lembre-se de que Scala diferencia maiúsculas de minúsculas) e acrescente '.scala'ao final do nome. (Se o nome do arquivo e o nome do objeto não corresponderem, seu programa não será compilado).

  Example- Suponha que 'HelloWorld' seja o nome do objeto. Em seguida, o arquivo deve ser salvo como 'HelloWorld.scala'.

• def main(args: Array[String]) - O processamento do programa Scala começa a partir do método main (), que é uma parte obrigatória de todo Programa Scala.

Identificadores Scala

Todos os componentes do Scala requerem nomes. Os nomes usados ​​para objetos, classes, variáveis ​​e métodos são chamados de identificadores. Uma palavra-chave não pode ser usada como identificador e os identificadores diferenciam maiúsculas de minúsculas. Scala oferece suporte a quatro tipos de identificadores.

Identificadores Alfanuméricos

Um identificador alfanumérico começa com uma letra ou sublinhado, que pode ser seguido por outras letras, dígitos ou sublinhados. O caractere '$' é uma palavra-chave reservada no Scala e não deve ser usado em identificadores.

A seguir estão legal alphanumeric identifiers -

age, salary, _value,  __1_value

A seguir estão illegal identifiers -

$salary, 123abc, -salary

Identificadores de operador

Um identificador de operador consiste em um ou mais caracteres de operador. Os caracteres do operador são caracteres ASCII imprimíveis, como +,:,?, ~ Ou #.

A seguir estão os identificadores legais de operador -

+ ++ ::: <?> :>

O compilador Scala internamente "mutilará" identificadores de operador para transformá-los em identificadores Java legais com $ caracteres incorporados. Por exemplo, o identificador: -> seria representado internamente como $ dois pontos $ menos $ maior.

Identificadores mistos

Um identificador misto consiste em um identificador alfanumérico, que é seguido por um sublinhado e um identificador de operador.

A seguir estão os identificadores mistos legais -

unary_+,  myvar_=

Aqui, unário_ + usado como um nome de método define um operador unário + e myvar_ = usado como nome de método define um operador de atribuição (sobrecarga de operador).

Identificadores literais

Um identificador literal é uma string arbitrária encerrada em marcas de retorno (`...`).

A seguir estão os identificadores literais legais -

`x` `<clinit>` `yield`

Palavras-chave Scala

A lista a seguir mostra as palavras reservadas em Scala. Essas palavras reservadas não podem ser usadas como constantes ou variáveis ​​ou quaisquer outros nomes de identificador.

abstrato	caso	pegar	classe
def	Faz	outro	estende
falso	final	finalmente	para
forSome	E se	implícito	importar
preguiçoso	partida	Novo	Nulo
objeto	sobrepor	pacote	privado
protegido	Retorna	selado	super
esta	lançar	traço	Experimentar
verdadeiro	tipo	val	Var
enquanto	com	produção
-	:	=	=>
<-	<:	<%	>:
#	@

Comentários no Scala

Scala oferece suporte a comentários de uma e de várias linhas muito semelhantes ao Java. Os comentários de várias linhas podem ser aninhados, mas devem ser aninhados corretamente. Todos os caracteres disponíveis em qualquer comentário são ignorados pelo compilador Scala.

object HelloWorld {
   /* This is my first java program.  
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */
   def main(args: Array[String]) {
      // Prints Hello World
      // This is also an example of single line comment.
      println("Hello, world!") 
   }
}

Linhas em branco e espaços em branco

Uma linha contendo apenas espaços em branco, possivelmente com um comentário, é conhecida como linha em branco e o Scala a ignora totalmente. Os tokens podem ser separados por caracteres de espaço em branco e / ou comentários.

Caracteres de Newline

Scala é uma linguagem orientada por linha em que as instruções podem ser encerradas por ponto-e-vírgula (;) ou novas linhas. Um ponto-e-vírgula no final de uma instrução geralmente é opcional. Você pode digitar um se quiser, mas não precisa se a instrução aparecer sozinha em uma única linha. Por outro lado, um ponto-e-vírgula é necessário se você escrever várias instruções em uma única linha. A sintaxe abaixo é o uso de várias instruções.

val s = "hello"; println(s)

Pacotes Scala

Um pacote é um módulo de código nomeado. Por exemplo, o pacote do utilitário Lift é net.liftweb.util. A declaração do pacote é a primeira linha sem comentários no arquivo de origem da seguinte forma -

package com.liftcode.stuff

Os pacotes Scala podem ser importados para que possam ser referenciados no escopo de compilação atual. A instrução a seguir importa o conteúdo do pacote scala.xml -

import scala.xml._

Você pode importar uma única classe e objeto, por exemplo, HashMap do pacote scala.collection.mutable -

import scala.collection.mutable.HashMap

Você pode importar mais de uma classe ou objeto de um único pacote, por exemplo, TreeMap e TreeSet do pacote scala.collection.immutable -

import scala.collection.immutable.{TreeMap, TreeSet}

Aplicar Dinâmica

Um traço de marcador que permite invocações dinâmicas. As instâncias x desta característica permitem invocações de método x.meth (args) para nomes de métodos arbitrários meth e args de listas de argumentos, bem como acessos a campos x.field para campos de nomes de campos arbitrários. Este recurso é apresentado no Scala-2.10.

Se uma chamada não for nativamente suportada por x (ou seja, se a verificação de tipo falhar), ela será reescrita de acordo com as seguintes regras -

foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)