Flash Cards to language Scala
Help!
|
|
||||
|---|---|---|---|---|---|
| 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
🗑
|
Review the information in the table. When you are ready to quiz yourself you can hide individual columns or the entire table. Then you can click on the empty cells to reveal the answer. Try to recall what will be displayed before clicking the empty cell.
To hide a column, click on the column name.
To hide the entire table, click on the "Hide All" button.
You may also shuffle the rows of the table by clicking on the "Shuffle" button.
Or sort by any of the columns using the down arrow next to any column heading.
If you know all the data on any row, you can temporarily remove it by tapping the trash can to the right of the row.
To hide a column, click on the column name.
To hide the entire table, click on the "Hide All" button.
You may also shuffle the rows of the table by clicking on the "Shuffle" button.
Or sort by any of the columns using the down arrow next to any column heading.
If you know all the data on any row, you can temporarily remove it by tapping the trash can to the right of the row.
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
Created by:
1370642565
Popular Engineering sets