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
Scala Flash Cards
Flash Cards to language Scala
| Term | Definition |
|---|---|
| 1)Expressão: Qualquer pedaço de código Scala que produz um resultado. Você também pode dizer que uma expressão avalia para um resultado ou resultados em um valor. | scala> 87 + 145 unnamed0: Int = 232 scala> 5 + 2 * 3 unnamed1: Int = 11 scala> "hello" + " world!" unnamed2: java.lang.String = hello world! |
| 2)Aninhamento de funções: Construção de muitas pequenas funções auxiliares. | def sqrt(x: Double) = { def sqrtIter(guess: Double, x: Double): Double = if (isGoodEnough(guess, x)) guess else sqrtIter(improve(guess, x), x) def isGoodEnough(guess: Double, x: Double) = abs(square(guess) - x) < 0.001 sqrtIter(1.0, x)} |
| 3)Parâmetro: As funções podem ter de zero a muitos parâmetros. Cada parâmetro tem um nome e um tipo. . A distinção entre parâmetros e argumentos é que os argumentos se referem aos objetos reais passados quando uma função é chamada. | scala> def square(x: Double) = x * x square: (Double)Double scala> square(2) unnamed0: Double = 4.0 scala> square(5 + 3) unnamed1: Double = 64.0 scala> square(square(4)) |
| 4)Funções anônimas: É uma função que é avaliada para uma função; a função é definida sem receber um nome. | (x: Int) => x * x def sumInts(a: Int, b: Int): Int = sum((x: Int) => x, a, b) def sumSquares(a: Int, b: Int): Int = sum((x: Int) => x * x, a, b) |
| 5)Variável: A entidade nomeada que se refere a um objeto. Uma variável ou é um val ou uma var . Ambos val s e var s deve ser inicializado quando definido, mas só var s pode ser transferido mais tarde para se referir a um objeto diferente. | var r val s |
| 6)Classes abstratas: Classes abstratas podem ter membros protegidos (deferred) que são declarados, mas que não tem uma implementação. Uma classe abstrata pode ter membros não implementados, nenhum objeto daquela classe pode ser criado usando new. | abstract class IntSet { def incl(x: Int): IntSet def contains(x: Int): Boolean } |
| 7)Traits são classes abstratas que desejamos adicionar a alguma outra classe. Isso pode ser porque um trait adiciona alguns métodos ou campos para uma classe pai desconhecida. | trait IntSet { def incl(x: Int): IntSet def contains(x: Int): Boolean } |
| 8)Objeto: Entidade de uma classe, um objeto segue a sintaxe da definição de uma classe; tem uma cláusula opcional extends, bem como um corpo opcional. | object EmptySet extends IntSet { def contains(x: Int): Boolean = false def incl(x: Int): IntSet = new NonEmptySet(x, EmptySet, EmptySet) } |
| 9)Casamento de Padrão: O casamento de padrões é uma generalização do comando switch do C ou Java para hierarquias de classes. | def eval(e: Expr): Int = e match { case Number(n) => n case Sum(l, r) => eval(l) + eval(r) } |
| 10)Tuplas: São classes case. Função que precisa retornar mais de um resultado. Tuplas são tão convenientes que Scala define uma sintaxe especial para elas. | def divmod(x: Int, y: Int): (Int, Int) = (x / y, x % y) divmod(x, y) match { case (n, d) => println("quotient: " + n + ", rest: " + d) |
| 11A função pode ser invocada com uma lista de argumentos para produzir um resultado.Uma função tem uma lista de parâmetros,um corpo, e um tipo de resultado. Funções que são membros de uma classe, característica ou um objeto singleton são chamados métodos. | package scala trait Function1[-A, +B] { def apply(x: A): B } |
| 12)Listas: São similares a vetores em linguagens tais como C ou Java, mas há também três importantes diferenças. Primeiro, listas são imutáveis.Listas tem uma estrutura recursiva e suportam um conjunto muito mais rico de operações que vetores. | val fruit: List[String] = List("apples", "oranges", "pears") val nums : List[Int] = List(1, 2, 3, 4) val diag3: List[List[Int]] = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1)) val empty: List[Int] = List() |
| 13)Mensagem: Atores se comunicar uns com os outros através do envio de cada outras mensagens . O envio de uma mensagem não interromper o que o receptor está fazendo. | import scala.actors.Actor abstract class AuctionMessage case class Offer(bid: Int, client: Actor) extends AuctionMessage case class Inquire(client: Actor) extends AuctionMessage |
| 14)Classes são tuplas, e podem tanto conter metodos quanto parâmetros, em Scala as classes são praticamente idênticas a classes Java. Herança funciona da mesma forma, e classes Scala podem estender classes Java | class Carro(modelo: String, ano: Int, cor: String) { var corAtual = cor def pintar(novaCor: String){ corAtual = novaCor } } |
| 15)App: É uma Trait que permite a execução de qualquer objeto Scala com a passagem de parâmetros de linha de comando. Ela já define o método main. Útil quando não precisamos manipular os parâmetros de linha de comando. | object CarroApplication extends App { val carro = new Carro("307", 2008, "prata") val carro2 = new Carro(2010) println("Carro: " + carro) carro.pintar("preto") println("Carro: " + carro) println("Carro2: " + carro2) } |
| 16)Expressões regulares: É um meio de se fazer buscar de determinadas porções de textos, ou seja, um método simples de manipulação e combinação avançadas de strings. | import scala.util.matching.Regex object Test { def main(args: Array[String]) { val pattern = "Scala".r val str = "A Linguagem Scala é legal" println(pattern findFirstIn str) } } |
| 17)Recursividade: Uma função é recursiva se ela chama a si mesma. | def deleteFiles(file: File): Boolean = { if (file.isDirectory) { for(f <- file.listFiles){ deleteFiles(f) } } file.delete } |
| 18)Recursividade de cauda: Uma função é recursiva de cauda se o único 18)lugar onde a função chama a si mesmo é a última operação da função. | def fatorial(num: Int):Int = { if(num == 0) 1 else num * fatorial(num - 1) } |
| 19)Herança: É um tipo de extensão da classe, pode se pegar uma classe já implementada 19)anteriormente e criar uma classe derivada com atributos e métodos distintos da classe Pai. | abstract class IntStack { def push(x: Int): IntStack = new IntNonEmptyStack(x, this) def isEmpty: Boolean def pop: IntStack } class IntEmptyStack extends IntStack { def pop = error("EmptyStack.pop") } |
| 20)Currying: E 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 add(x:Int, y:Int) = x + y add(1, 2) // 3 add(7, 3) // 10 |
Created by:
1370642565
Popular Engineering sets