Una función es un bloque de sentencias modular y reutilizable que se usa para realizar tareas relacionadas, como calcular y mostrar un valor basado en argumentos proporcionados a la función. Al igual que con todos los valores no primitivos, las funciones son objetos. Son objetos únicos en los que se pueden llamar ejecutar el código, pasar datos en forma de argumentos y devuelve un valor.
Las funciones se consideran "primera clase" objetos, lo que significa que, a pesar de su comportamiento único, se pueden usar en todos los los mismos contextos que cualquier otro objeto JavaScript. Por ejemplo, una función puede ser asignado a una variable, pasado como argumento a otras funciones y devueltos por otras funciones.
function myFunction() {
console.log( "This is my function." );
};
Una función definida como una propiedad de un objeto es
generalmente se denomina "método". Al igual que con las variables declaradas con var
,
las declaraciones de función realizadas fuera de una función contenedora se agregan al
objeto global como métodos.
Declaraciones de funciones
Una declaración de función (también llamada “declaración de función” o “definición de función”)
Crea una función con nombre que puede invocarse en otro lugar del alcance que la contiene.
Las declaraciones de función consisten en la palabra clave function
seguida de un
identificador, una lista de parámetros separados por comas encerrados entre paréntesis y un
instrucción de bloque llamada
“cuerpo de la función”. A menudo encontrarás declaraciones de funciones que no
terminar con punto y coma; ya que una declaración de función es una instrucción
y punto y coma se puede inferir por medio de ASI.
function myFunction() {
console.log( "This is my function." );
};
myFunction();
> "This is my function."
Como un obstáculo de las primeras decisiones de diseño de JavaScript, las declaraciones de funciones
están sujetas a la misma elevación heredada
como variables declaradas con var
, lo que significa que una declaración de función
se eleva a la parte superior de su alcance y puede llamarse antes de la declaración como
resultado, ya sea que ese alcance esté regido por el modo estricto o no:
"use strict";
{
myFunction();
function myFunction() {
console.log( "This is my function." );
};
}
> "This is my function."
Fuera del modo estricto, función las declaraciones usan el alcance heredado de JavaScript comportamiento, lo que significa que el alcance de una declaración de función se define con su alcance más cercano función:
function myFunction() {
function myNestedFunction() {
console.log( "This is my nested function." );
}
myNestedFunction();
};
myFunction();
> "This is my nested function."
myNestedFunction();
>Uncaught ReferenceError: myNestedFunction is not defined
En el modo estricto, las declaraciones de funciones
el alcance se establece en su bloque de contenedor más cercano, como sucede con las variables declaradas mediante
let
o const
:
"use strict";
{
function myFunction() {
console.log( "This is my function." );
};
}
myFunction();
> Uncaught ReferenceError: myFunction is not defined
Llamada a función
Al igual que con las variables, el identificador que se usa cuando se declara una función actúa como un un nombre simbólico para un valor. Hacer referencia a una función solo con el identificador muestra solo el objeto de la función y no ejecuta la función que contiene:
function myFunction() {
console.log( "This is my function." );
};
myFunction;
> myFunction() {
console.log( "This is my function." );
}
Para ejecutar el código dentro del cuerpo de la función, llama (o invoca) la función. siguiendo el nombre de la función con un par de paréntesis coincidente:
function myFunction() {
console.log( "My function has been executed." );
}
myFunction();
> "My function has been executed."
Los parámetros en la definición de la función actúan como variables de marcador de posición para valores que se pueden pasar al cuerpo de la función cuando se la llama. Los valores entre paréntesis cuando se llama a una función son “argumentos” (aunque es posible que veas “argumentos” que se usa para describir argumentos y parámetros en algunas documentación):
function myFunction( myParameter ) {
console.log( `The value is: ${ myParameter }.` );
};
myFunction( "this string" );
> "The value is: this string."
Si se omite un argumento esperado, el parámetro resultante contiene un
valor undefined
, porque el parámetro se declara en el cuerpo de la función, pero
no inicializado con un valor:
function myFunction( myParameter ) {
console.log( `The value is: ${ myParameter }.` );
};
myFunction();
> "The value is: undefined."
Puedes establecer valores de parámetros predeterminados si los inicializas de la misma manera que lo harías
inicializamos una variable: un operador de asignación (=
) seguido de un valor. Si
especificar un argumento para esa función, ese valor nuevo anula
valor predeterminado:
function myFunction( myParameter = "omitted" ) {
console.log( `The value is: ${ myParameter }.` );
};
myFunction( "this string" );
> "The value is: this string."
myFunction();
> "The value is: omitted."
El cuerpo de una no flecha
también tiene acceso a una entrada no indexada,
Un objeto arguments
similar a un array
que contenga cualquier valor pasado como argumento, ya sea que la función
definición especifica los parámetros:
function myFunction() {
console.log( arguments );
};
myFunction( 3, true, "My string" );
> Arguments { 0: 3, 1: true, 2: "My string", … }
Funciones variadicas
El objeto arguments
te permite crear funciones variables básicas, que pueden
aceptar una cantidad variable de argumentos:
function myFunction() {
let result = "";
for (let i = 0; i < arguments.length; i++) {
result += arguments[i] + " - ";
}
console.log( result );
};
myFunction( "My first string", "My second string", "my third string" );\
> "My first string - My second string - my third string - "
Sin embargo, este enfoque para las funciones variádicas rara vez se utiliza en el JavaScript moderno. en el desarrollo de software. Es más común usar el framework más moderno y legible sintaxis del parámetro rest lo que crea un parámetro con nombre inicializado como un array que contiene argumentos aparte de los especificados explícitamente:
function myFunction( mySeparator, ...myStrings ) {
console.log( myStrings.join( mySeparator ) );
};
myFunction( " - ", "My first string", "My second string", "my third string" );
> "My first string - My second string - my third string"
A diferencia de la vinculación de parameter
, la sintaxis del parámetro rest funciona como se espera con los parámetros de la función de flecha:
function myOuterFunction() {
let myInnerArrowFunction = ( ...myParams ) => {
console.log( myParams[ 0 ] );
}
myInnerArrowFunction( true );
};
myOuterFunction( false );
> true
let myArrowFunction = ( ...myParams ) => {
console.log( myParams[ 0 ] );
};
myArrowFunction( true );
> true`
``