Header Ads Widget

Ticker

6/recent/ticker-posts

Tutorial de TypeScript: Lección 6 - Funciones

TypeScript - Funciones

Definición de una función

Sintaxis:

1
2
3
function [function_name]() {
   //body
}

Ejemplo 1:

1
2
3
function sum(x:number,y:number):number {
   return x+y
}

Ejemplo 2: función anónima

1
2
3
function (x:number,y:number):number {
   return x+y
}

Llamar a una función

Se debe llamar a una función para ejecutarla. Este proceso se denomina invocación de función .

Sintaxis

1
function_name()

Nota: function_name puede ser una variable

Ejemplo 1:

1
2
3
4
5
function sum(x:number,y:number):number {
   return x+y
}
 
console.log(sum(1,2))

Ejemplo 2: función anónima

1
2
3
(function (x:number,y:number):number {
   return x+y
})(1,2)

Ejemplo 3:

1
2
3
4
5
var sum = function (x:number,y:number):number {
   console.log( x+y )
}
 
sum(1,2)

Devolver una función

Las funciones también pueden devolver valor junto con el control, de vuelta a la persona que llama. Estas funciones se denominan funciones de retorno.

Sintaxis

1
2
3
4
function [function_name]():return_type {
   //body
   return value;
}

Nota: ¿return_type Debe uno de estos valores: cadena, número, objeto, booleano, void, any

Ejemplo:

1
2
3
4
5
6
7
var round = function (x:number):any {
   return function(){
      return Math.round(x)
   }
}
 
console.log(round(2.2)())

Parámetros de función

Al llamar a una función, hay dos formas de pasar argumentos a una función

S.No.Tipo de llamada y descripción
1.

Llamar por valor

Este método copia el valor real de un argumento en el parámetro formal de la función. En este caso, los cambios realizados en el parámetro dentro de la función no tienen ningún efecto en el argumento.

2.

Llamar por puntero

Este método copia la dirección de un argumento en el parámetro formal. Dentro de la función, la dirección se usa para acceder al argumento real usado en la llamada. Esto significa que los cambios realizados en el parámetro

Sintaxis:

1
2
3
function [func_name](param1[:datatype1], [param2[?][:datatype2]]) {  
    //body
}


Ejemplo de llamada por puntero :

1
2
3
4
5
6
7
8
9
10
11
12
var myInfo = {
   name: 'Tutorialspots',
   age: 35
}
 
function changeAge(info:any,newAge:number){
   info.age = newAge
}
 
changeAge(myInfo,40)
 
console.log(myInfo)

Resultado:

1
[LOG]: { "name": "Tutorialspots", "age": 40 }

Parámetros opcionales

El parámetro opcional debe establecerse como el último argumento en una función:
Ejemplo: Parámetros opcionales

1
2
3
4
5
6
7
8
9
10
11
12
function sum(x:number,y:number,z?:number) {
   console.log("x:", x)
   console.log("y:", y)
    
   if(typeof z!="undefined"
   console.log("z:",z)
 
   return x+y+(typeof z!="undefined"?z:0)
}
 
console.log(sum(1,2,3))
console.log(sum(1,2))

Resultado:

1
2
3
4
5
6
7
[LOG]: x:,  1
[LOG]: y:,  2
[LOG]: z:,  3
[LOG]: 6
[LOG]: x:,  1
[LOG]: y:,  2
[LOG]: 3

Parámetros de descanso

Detalle: Tutorial de TypeScript: Lección 3 Ir a: Operador de descanso (parámetros de descanso)

Parámetros predeterminados

Al igual que PHP, a los parámetros de función de TypeScript también se les pueden asignar valores de forma predeterminada:

Sintaxis:

1
2
3
function [function_name](param1[:type1], param2[:type2] = default_value) {
    //body
}

Ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
var myInfo = {
   name: 'Tutorialspots',
   age: 35
}
 
function changeAge(newAge:number=40){
   myInfo.age = newAge
}
 
changeAge()
 
console.log(myInfo)

Resultado:

1
[LOG]: { "name": "Tutorialspots", "age": 40 }

El constructor de funciones

Al igual que PHP (función create_function), TypeScript también admite la definición de una función con el constructor de JavaScript incorporado llamado Function().

Sintaxis

1
new Function( [arguments,] function_body_as_string )

Ejemplo:

1
2
3
var sum = new Function("x","y","return x+y")
 
console.log(sum(1,2))

Resultado:

1
[LOG]: 3

Funciones de
Lambda Lambda se refiere a funciones anónimas en programación. Las funciones Lambda son un mecanismo conciso para representar funciones anónimas. Estas funciones también se denominan funciones de flecha.


Sintaxis de expresión Lambda :

1
( [param1, param2, …param n] )=>statement

Ejemplo 1:

1
2
3
var myFunc = (x:number,y:number)=>(x=x+1,x+y)
 
console.log(myFunc(1,2))

Resultado:

1
[LOG]: 4


Sintaxis de la declaración Lambda :

1
2
3
( [param1, param2, …param n] )=>{
    //block
}

Ejemplo 2:

1
2
3
4
5
6
var myFunc = (x:number,y:number)=>{
   x=x+1
   console.log(x+y)
}
 
myFunc(1,2)

Resultado:

1
[LOG]: 4

Función de
función generadora *
La function*palabra clave define una expresión de función generadora.
yield
Pausa y reanuda una función de generador.
rendimiento *
Delegado a otra función generadora u objeto iterable.

El objeto Generator: es devuelto por una función generadora y se ajusta tanto al protocolo iterable como al protocolo iterador.

Constructor: debes usar la función de generador:

Ejemplo:

1
2
3
4
5
6
function* foo() {
    yield 2
    yield 1
}
 
const iterator = foo()

Métodos de instancia
Generator.prototype.next()
Devuelve un valor obtenido por la expresión de rendimiento.
Generator.prototype.return()
Devuelve el valor dado y finaliza el generador.
Generator.prototype.throw()
Lanza un error a un generador (también finaliza el generador, a menos que se detecte dentro de ese generador).

Ejemplo:

1
2
3
4
5
6
7
8
9
function* foo() {
    yield 2
    yield 1
}
 
const iterator = foo()
 
console.log(iterator.next().value)
console.log(iterator.next().value)

Resultado:

1
2
[LOG]: 2
[LOG]: 1

Ejemplo: rendimiento * palabra clave

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function* func1() {
  yield 100
  yield 101
}
 
function* func2() {
  yield 99
  yield* func1()
}
 
const iterator = func2()
 
console.log(iterator.next().value)
console.log(iterator.next().value)
console.log(iterator.next().value)

Resultado:

1
2
3
[LOG]: 99
[LOG]: 100
[LOG]: 101

Sobrecargas de funciones

Las funciones tienen la capacidad de operar de manera diferente según la información que se les proporcione. En otras palabras, un programa puede tener varios métodos con el mismo nombre con diferente implementación. Este mecanismo se denomina sobrecarga de funciones. TypeScript proporciona soporte para la sobrecarga de funciones.

Ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//Declare multiple functions with the same name but different function signature
function calculateDistance(p1:object,p2:object):number
function calculateDistance(x1:number,y1:number,x2:number,y2:number):number
 
//Function definition with optional parameters
function calculateDistance(a:any,b:any,c?:any,d?:any):number{
   if(typeof a == "number"){
      return Math.sqrt((a-c)**2 + (b-d)**2)
   }else{
      return Math.sqrt((a.x-b.x)**2+(a.y-b.y)**2)
   }
}
 
console.log(calculateDistance({x:10,y:20},{x:30,y:50}))
console.log(calculateDistance(10,20,30,50))

Resultado:

1
2
[LOG]: 36.05551275463989
[LOG]: 36.05551275463989

Publicar un comentario

0 Comentarios