Busy. Please wait.
or

show password
Forgot Password?

Don't have an account?  Sign up 
or

Username is available taken
show password

why


Make sure to remember your password. If you forget it there is no way for StudyStack to send you a reset link. You would need to create a new account.
We do not share your email address with others. It is only used to allow you to reset your password. For details read our Privacy Policy and Terms of Service.


Already a StudyStack user? Log In

Reset Password
Enter the associated with your account, and we'll email you a link to reset your password.
Don't know
Know
remaining cards
Save
0:01
To flip the current card, click it or press the Spacebar key.  To move the current card to one of the three colored boxes, click on the box.  You may also press the UP ARROW key to move the card to the "Know" box, the DOWN ARROW key to move the card to the "Don't know" box, or the RIGHT ARROW key to move the card to the Remaining box.  You may also click on the card displayed in any of the three boxes to bring that card back to the center.

Pass complete!

"Know" box contains:
Time elapsed:
Retries:
restart all cards
share
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

Scala Flash Cards

Flash Cards to language Scala

TermDefinition
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