2011-03-09 31 views

Respuesta

61

Una función literal es una sintaxis alternativa para definir una función. Es útil para cuando quiere pasar una función como argumento a un método (especialmente uno de orden superior como una operación de plegado o filtro) pero no quiere definir una función separada. Los literales de funciones son anónimos, no tienen un nombre por defecto, pero puede asignarles un nombre vinculándolos a una variable. Un literal de función se define de este modo:

(a:Int, b:Int) => a + b 

Usted puede unirse a las variables:

val add = (a:Int, b:Int) => a + b 
add(1, 2) // Result is 3 

Como he dicho antes, los literales de función son útiles para pasar como argumentos a funciones de orden superior. También son útiles para definir líneas únicas o funciones de ayuda anidadas dentro de otras funciones.

A Tour of Scala da una muy buena referencia para los literales de funciones (los llaman funciones anónimas).

+13

yo creo que puede ser útil señalar cómo un literal de función es sólo azúcar sobre FunctionN - lo que le daría un buen caso general para el literal vs. la versión "larga". Además, aunque tengo un +1, generalmente no es "sintaxis alternativa para definir una función [¿te refieres al método ????]" ya que las funciones *** no son métodos *** - los métodos son constructores que * solo * se aplica a las clases y mensajes que pueden ser enviados a ellos (las clases). * las funciones * son "valores de primera clase" (objetos que admiten 'aplicar' y algunos otros). –

+0

def add = (a: Int, b: Int) => a + b ¿No es lo mismo? Puedo usar este 'agregar' para pasar a otra función también – ses

+0

También puede crear un literal de función a partir de una función existente con el operador underscope: def addTwoNumbers (a: Int, b: Int) = a + b; def add2 = addTwoNumbers _ – Blitzkr1eg

12

Podría ser útil comparar literales de función a otros tipos de literales en Scala. Literals son notacionales de azúcar para que representan los valores de algunos tipos que el lenguaje considera particularmente importantes. Scala has literales enteros, literales de caracteres, literales de cadenas, etc. Scala trata las funciones como valores de primera clase representables en el código fuente por literales de funciones. Estos valores de función habitan en un function type especial. Por ejemplo,

  • 5 es un número entero literal que representa un valor en Int tipo
  • 'a' es un carácter literal que representa un valor en Char tipo
  • (x: Int) => x + 2 es una función literal que representa un valor en Int => Int función de tipo

Los literales a menudo se usan como valores anónimos, es decir, sin limitarlos primero a una variable con nombre. Esto ayuda a que el programa sea más conciso y es apropiado cuando el literal no está destinado a ser reutilizable. Por ejemplo:

List(1,2,3).filter((x: Int) => x > 2) 

vs

val one: Int = 1 
val two: Int = 2 
val three: Int = 3 
val greaterThan2: (Int => Int) = (x: Int) => x > two 
List(one,two,three).filter(greaterThan2) 
+1

¿Hay alguna manera de hacer que los tipos sean más explícitos? Esto funciona: 'List (1,2,3) .map (x => x + 10)' Esto no funciona: 'List (1,2,3) .map ((x: Int): Str = > x.toString) ' Esto funciona pero no es tan explícito:' List (1,2,3) .map ((x: Int) => x.toString) ' O si quisiera hacer esto, debería usar un nombre ¿función? – monteiro

+1

@monteiro 'List (1,2,3) .map ((x: Int) => {x.toString}: String)' –

+0

¡Muy apreciado! :) – monteiro

Cuestiones relacionadas