Help
Options
Didn't know it?
click below
click below
Knew it?
click below
click below
Don't Know
Remaining cards (0)
Know
retry
shuffle
restart
0:00
Embed Code - If you would like this activity on your web page, copy the script below and paste it into your web page.
Normal Size Small Size show me how
Normal Size Small Size show me how
Linguagem Scala
Trabalho de LP - Linguagem Scala
| Conceito | Exemplo |
|---|---|
| A função timeFlies é definida apenas para ser passada como parâmetro para a função oncePerSecond. Funções anônimas, são exatamente o que parecem: funções sem nome. | object TimerAnonymous { def oncePerSecond(callback: () => unit) { while (true) { callback(); Thread sleep 1000 } } def main(args: Array[String]) { oncePerSecond(() => println("o tempo corre como um raio...")) } } |
| Fazer chamadas seguidas de nossa função somaEntreComF para intervalo de números diferentes, porém com o mesma função a ser aplicada entre os números. | scala> somaEntreComF(5, 15, x => x) res13: Int = 110 scala> somaEntreComF(10, 20, x => x) res14: Int = 165 |
| Devolve uma função, que ao ser executada com os parâmetros que você precise no momento, lhe dê o resultado. | scala> def somaEntre(f: Int => Int): (Int, Int) => Int = { def retFunc(a: Int, b: Int): Int = if (a > b) 0 else f(a) + retFunc(a+1, b); retFunc } somaEntre: (f: (Int) => Int)(Int, Int) => Int |
| Declaração de Campo Simples: Um campo é uma variável que é acessível dentro de todo o objeto. Isto é contrário às variáveis locais, os quais são acessíveis apenas dentro do método em que são declarados | class MyClass { var myField : int = 0; } |
| Uma vez que 0 é por defeito assumido como sendo um Int , o compilador Scala, pode-se inferir o tipo de myField 0 com base no que lhe é atribuído . | class MyClass { var myField : int = 0; def este (value: Int) = { este (); this.myField = valor ; } } |
| Scala é uma linguagem funcional, não é puramente funcional, mas permite programação funcional. | def prime(x : Int) : Boolean = 2.to(x-1).filter(x % _ == 0).isEmpty println(prime(1)) println(prime(5)) println(prime(9)) println(prime(11)) |
| Expressão If: Ele testa uma condição e executa um dos dois ramos do código dependendo se a condição é verdadeira | var filename = "default.txt" if (!args.isEmpty) filename = args(0) |
| Currying é a técnica de transformar uma função que recebe vários argumentos em uma função que recebe um único argumento (os outros argumentos tendo sido especificado pelo curry). | def complemento (x: Int, y: int) = x + y adicionar (1, 2) / / 3 adicionar (7, 3) / / 10 |
| Em Scala existe a palavra-chave return. No entanto, como todas as expressões da linguagem possuem um valor de retorno, muitas vezes o uso explícito deste termo é redundante | val dez = 10 def vinte = dez * 2 |
| Currying: a idéia é avisar o compilador que podemos passar parte dos parâmetros, e que isto deve gerar uma outra função, com os parâmetros que faltam, já na declaração | def multiply2(x : Int)(y : Int) = x * y def doIt(a : Int, f : (v : Int)=> Int) : Int = f(a) println(doIt(3,multiply2(5))) |
| Como não existe diferenciação entre valores primitivos, conseguimos criar listas com diferentes tipos | var a = {2, “Casa”} var b = { 1, {5, “Texto”, true }, false } |
| Scala é uma linguagem orientada a objetos, e dessa forma possui o conceito de classes. | object Classes { def main(args: Array[String]) { val pt = new Point(1, 2) println(pt) pt.move(10, 10) println(pt) } } |
| Para facilitar nossa vida, e para evitar a definição de funções que serão pequenas e para casos específicos, existe um açucar sintático em Scala chamado de funções anônimas. Como o próprio nome diz, nada mais são do que funções sem um nome definido | scala> somaEntreComF(1, 10, (x: Int) => x) res6: Int = 55 |
| Classes, em Scala, são declaradas usando uma sintaxe muito parecida com a do Java. Uma das diferenças mais marcantes é que classes em Scala podem ter parâmetros. | class Complex(real: Double, imaginary: Double) { def re() = real def im() = imaginary } |
| List: Em Scala, listas são definidas em uma estrutura de dados de maneira recursiva. | var listaInt = List(3, 4, 2, 7) |
| List: Existe uma outra forma de se construir listas: com o operador :: . | var lista = 1 :: 4 :: 5 :: 8 :: Nil |
| Iterators em Scala são bem parecidos com os iterators de Java, e podemos também utilizá-los em for-comprehensions como listas. | val it = Iterator.from(7) println(it.next); // Saida: 7 println(it.next); // Saida 8 |
| Operações com Listas: Listas disponibilizam alguns métodos básicos para operar sobre listas. | var lista = 1 :: 4 :: 5 :: 8 :: Nil lista.isEmpty // Saida: false lista.head // Saida: 1 lista.tail // Saida: (4, 5, 8) lista.tail.head // Saida: 4 |
| No foreach apenas executamos a função passada, sem que seja devolvida uma lista com o resultado da operação | var lista = 1 :: 4 :: 5 :: 8 :: Nil lista foreach ((x: Int) => print(x + ", ")) // Saida: 1, 4, 5, 8, |
| Classe Abstrata: Tipos abstratos são tipos cuja identidade não é conhecida com precisão. | abstract class Buffer { type T val element: T } |
| Um pacote é um objeto especial que define um conjunto de classes de membros, objetos e pacotes. Ao contrário de outros objetos, os pacotes não são introduzidos por uma definição. | package p1 { object test extends Application { println("p1.test") } } package p2 { object test extends Application { println("p2.test") } } |
| Métodos em Scala podem ser parametrizados com ambos os valores e tipos. Como no nível de classe, o valor dos parâmetros estão alojados em um par de parênteses, enquanto que o tipo dos parâmetros são declaradas dentro de um par de parênteses | object PolyTest extends Application { def dup[T](x: T, n: Int): List[T] = if (n == 0) Nil else x :: dup(x, n - 1) println(dup[Int](3, 4)) println(dup("three", 3)) } |
Created by:
grupoKarem
Popular Math sets