No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Dart

Curso de Dart

Argel Franco Bejarano de la Cruz

Argel Franco Bejarano de la Cruz

Parámetros requeridos, opcionales, posicionados, nombrados y por defecto

11/29
Recursos

No olvides compartir tus ejemplos de funciones con parámetros en los aportes.

Aportes 42

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

RESUMEN DE LA CLASE

Parámetros requeridos: Al momento de invocar la función deben enviarse sí o sí, o el compilador indicará un error.

void main() => paramReq(24, 17); 

void paramReq(int a, int b){
	print("Parametro 1: $a");
	print("Parametro 2: $b");
}

//Salida
Parametro 1: 24
Parametro 2: 17

Parámetros opcionales posicionados: Los corchetes indican que el parámetro es opcional posicionado. Por lo tanto, no es obligatorio invocar la función con ese parámetro.

void main() => paramOpcPos(24); 

void paramOpcPos(int a, [int b]){
	print("Parametro 1: $a");
	print("Parametro 2: $b");
}

//Salida
Parametro 1: 24
Parametro 2: null

Parámetros opcionales nombrados: Poseen la misma lógica que el anterior tipo, pero aquí podemos nombrarlos al momento de la invocación.

void main() => paramOpcNom(24, segundoParametro:17);  

void paramOpcNom(int a, {int segundoParametro}){
	print("Parametro 1: $a");
	print("Parametro 2: $b");
}

//Salida
Parametro 1: 24
Parametro 2: 17

Parámetros opcionales por defecto: Poseen la misma lógica que el anterior tipo nombrado, pero podemos asignar un valor por defecto si no se invoca a la función con otro diferente.

void main() => paramOpcNom(24);  

void paramOpcNom(int a, {int b = 16}){
	print("Parametro 1: $a");
	print("Parametro 2: $b");
}

//Salida
Parametro 1: 24
Parametro 2: 16

Parámetros Requeridos son aquellos parámetros que deben ser enviados obligatoriamente al llamar una función.
Ejemplo:

void main() {
  paramRequerido(1,2);
}
void paramRequerido(int a, int b) {
  print('Los valores son $a y $b');
}
// Salida:
// Los valores son 1 y 2

Parámetros Opcionales son aquellos que no son obligatorios enviarlos al llamar una función. Estos deben ser declarados luego de los parámetros obligatorios o en su defecto todos los parámetros de la función sean opcionales.

Estos también pueden ser inicializados con un valor por defecto en caso de no se enviados al llamar la función.

Los tipos de parámetros opcionales son: por posición y nombrados.

Parámetros Opcionales por Posición: estos son declarados dentro de corchetes [ ] y la asignación de valor a los mismos viene dado por la posición en la cual fueron declarados.

Ejemplo del parámetro opcional por posicion b:

void main() {
  paramOptPosicion(5);
  paramOptPosicion(5, 8);
}
void paramOptPosicion(int a, [int b]) {  
  print('Los valores son $a y $b ' + (b == null ? '(Opcional por Posición)': ''));
}
// Salida:
// Los valores son 5 y null (Opcional por Posición)
// Los valores son 5 y 8 

Ejemplo del parámetro opcional por posicion b inicializado con un valor por defecto:

void main() {
  paramOptPosValorDefecto(3);
  paramOptPosValorDefecto(3, 13);
}
void paramOptPosValorDefecto(int a, [int b = 12]) {
  print('Los valores son $a y $b ' + (b == 12 ? '(Valor por Defecto)': ''));
}
// Salida:
// Los valores son 3 y 12 (Valor por Defecto)
// Los valores son 3 y 13 

Parámetros Opcionales Nombrados: estos son declarados dentro de llaves { } y la asignación de valor a los mismos viene dado por el nombre del parámetro.

Ejemplo del parámetro opcional nombrado c:

void main() {
  paramOptNombrado(6);
  paramOptNombrado(6, c:9);
}
void paramOptNombrado(int a, {int c}) {
  print('Los valores son $a y $c ' + (c == null ? '(Opcional Nombrado)': ''));
}
// Salida:
// Los valores son 6 y null (Opcional Nombrado)
// Los valores son 6 y 9 

Ejemplo del parámetro opcional nombrado c inicializado con un valor por defecto:

void main() {
  paramOptNomValorDefecto(5);
  paramOptNomValorDefecto(5, c:17);  
}
void paramOptNomValorDefecto(int a, {int c = 15}) {
  print('Los valores son $a y $c ' + (c == 15 ? '(Valor por Defecto)': ''));
}
// Salida:
// Los valores son 5 y 15 (Valor por Defecto)
// Los valores son 5 y 17 

En Flutter definir opcional como requerido

Ejemplos

void main() {
  
  void requerido(int a, int b , int c) => print('Requerido: ${a+b+c}');
  void opcional(int a, int b , [int c]) => print('Opcional: ${a+b} $c');
  void nombrados(int a, int b , {int tercero}) => print('Nombrado: ${a+b+tercero}');
  void defecto(int a, int b , [int c=100]) => print('Defecto: ${a+b} $c');
  
  requerido(1,2,3);
  opcional(1,2);
  nombrados(1,2,tercero:3);
  defecto(1,2);
}

Código de la clase comentado:

// Clase sobre parámetros.

main(List<String> args) {
  parametrosRequeridos(3, 5);
  parametrosOpcionalesPosicionados(5);
  parametrosPosicionadosNombrados(5, y: 4);
  parametrosNombrados(y: 5, x: 9);
  parametrosSobreescritos(9);
  parametrosSobreescritos(1,1);
}

// * Estas son las funciones que hemos trabajado anteriormente,
// * A las cuales le pasamos los parámetros requeridos.
// ! Son funciones a las cuales debemos pasarles los parámetros obligatoriamente.
void parametrosRequeridos(int x, int y) {
  print((x + y));
}

// * Este es un ejemplo de parámetros opcionales.
// * El primer parámetro sigue teniendo la misma notación que en la función anterior, por lo que será requerido.
// * El segundo parámetro, tiene una notación diferente, debido a que está encerrado entre corchetes.
// * Esta notación, denota que ese parámetro es opcional, y que no es obligatorio para el funcionamiento de la función.
void parametrosOpcionalesPosicionados(int x, [int y]) {
  if (y != null) {
    print((x + y));
  } else {
    print(x);
  }
}

// * Es un tipo de función que nos permite asignar las variables por nombre.
void parametrosPosicionadosNombrados(int x, {int y}) {
  if (y != null) {
    print((x + y));
  } else {
    print(x);
  }
}

// * Todos nombrados.
void parametrosNombrados({int x, int y}){
  print((x + y));
}

// * En caso de que no se le asigne un valor a y, a esta se le da el valor asigando.
void parametrosSobreescritos(int x, [int y = 9]){
  print((x + y));
}

Abril 2021 en parametros opcionales posicionados el segundo parametro se debe pasar sin definir el tipo de dato es decir el int, de lo contrario marca error.

void parametrosOpcionalesPosicionados(int a, [b]) {
  print('Imprime parametro1 $a');
  print('Imprime parametro2 $b');
}

Tambien podemos declarar la variable dynamic y colocrle un mensaje si no fue asignada

void parametrosOpcionales(int a , [dynamic b=“no se asigno valor”]) {
print(“El valor del parametro 1 es: $a”);
if (b != null) {
print(“El valor del parametro 2 es: $b”);
}
}

Dejo un prueba de parametros opcionales nombrados tipo String.

Hice una pequeña practica con nombres de profesores 😄

main(List<String> arguments){
  nomOpcional('Ana', 'Freddy', 'Argel');
  nomRequerido('Anahi Salgado', 'Freddy Vega', 'Argel Bejarano');
}

void nomOpcional(String a, String b, String c){
  print('Me llamo $a');
  print('Me llamo $b');
  print('Me llamo $c');
}

void nomRequerido(String a, String b, String c){
  print('Mi nombre es $a');
  print('Mi nombre es $b');
  print('Mi nombre es $c');
}

Es Dart posible agregar un valor por defecto a un parámetro requerido?

La función flecha está definida con parámetros opcionales. Se ha incorporado el uso del operador ?? para que se verifique si los parámetors opcionales son nulos, en cuyo caso, al hacer la suma tomará el valor de 0 en el(los) que falte(n).

void main() {
  print( sumaArrow(2) );
  print( sumaArrow(2, 6) ); 
  print( sumaArrow(2, 6, 10) ); 
}

int sumaArrow(int a, [int b, int c]) => a + (b ?? 0) + (c ?? 0);

creo que aunque el lenguaje permita tener parametros opcionales o nombrados en nuestras funciones, siempre debemos validar los parametros o asignales un valor por defecto para no causar errores

void paramOpcposi(int a, [int b]){
	b??=0;
	print(a+b);
}

Hasta ahora dart para mi ha sido como dar un paseo, considero que este para gente nueva seria un excelente primer lenguaje, ya que mucha gente toma a Java de referencia, yo considero que este lenguaje es muy suave para aprender a programar.

Respondida mi pregunta realizada sobre los parametros opcionales.

El audio está demasiado bajo en todos los videos, pense que solo era en la app de platzi 😕

// Parametros requeridos

main(List<String> arguments){
paramRequerids(1, 2);
}

void paramRequerids(int a, int b){
print(‘imprime param1 $a’);
print(‘imprime param2 $b’);
}

Son parámetros requeridos porque debemos mandar ambos parametros paramRequerids(1, 2); y si no enviamos los dos Dart nos mandara un mensaje de error diciendo que se deben enviar dos y solo se ha enviado uno.

// Parametros Opcionales

void paramOpcposi(int a, [int b]){
print(‘imprime param1 $a’);
print(‘imprime param1 $b’);
}

y en el main:

paramOpcposi(1);
(no nos pide el segundo parametro)
(si no esta el segundo parametro el param2 aparece null)

Salida: imprime param 1 imprime param2 null

void paraOpcNombrado(int a, {int b}){
print(‘imprime param1 $a’);
print(‘imprime param2 $param2’);
}

y en el main:

paramOpcNombrado(1, param2: 2);

(el param2 es opcional y si no lo declaramos nos dara null en el param2 pero no hay problema y puede utilizarse).

Tambien desde la funcion podemos asignar su valor:

void paraOpcNombrado(int a, {int param2 = 4}){
print(‘imprime param1 $a’);
print(‘imprime param2 $param2’);
}

de esta manera no hara falta asignar su valor en el main.

los parametros nombrados reconocen su posicion y aunque cambiemos el orden seguira estando el param1 primero y el param2 despues.

el requerido lo imprimira en el orden que se manden.

y con esto la diferencia de que sean opcionales o posicionados.

Los parámetros nombrados son geniales, ya que le dan más legibilidad y claridad a tu código, y también puedes hacer que tengan valores por defecto ❤️:

void main() { 
  greet(compl: 'Hola'); // Uso de parámetro nombrado :-)
  greet(); // Se imprimirá el valor por defecto.
}

void greet({String compl = 'Hello'}) {
  print('$compl, World!');
}
main(List<String> arguments){
  saludar(parmb: 'todos', parma: 'hola');
}
void saludar({String parma, String parmb}) => print('$parma a $parmb');
void main() {
  parametroRequerido(9,10);
  parametroRequeridoOpcional(9,3);
  parametroRequeridoOpcionalNombrado(9, b:2);
}

void parametroRequerido(int a, int b){
  print('Imprime parámetro 1 $a');
  print('Imprime parámetro 2 $b');
}

void parametroRequeridoOpcional(int a, [int b=11]){
  print('Imprime parámetro 1 $a');
  print('Imprime parámetro 2 $b');
}

void parametroRequeridoOpcionalNombrado(int a, {int b = 1}){
  print('Imprime parámetro 1 $a');
  print('Imprime parámetro 2 $b');
}

Por si a alguien más le salía error en “parametros opcionales” poniendo solo:
[int b]

Se soluciona escribiendo:
[int? b]

void parametrosOpcionales(int a, [int? b]){
  print("Imprime parametro opcional 1: $a");
  print("Imprime parametro opcional 2: $b");
}

Parece que ahora en Dart, para que una variable pueda tener null debe ser de tipo var. Por lo que, si un parámetro es opcional, este debe ser tipo var, porque si no genera un error:

void optionalParams(int a, [int b]) { ... } // no se puede

void optionalParams(int a, [var b]) { ... } // si se puede

Solo si el parámetro tiene un valor por defecto, entonces puede tener un tipo diferente de var:

void optionalParams(int a, [int b = 5]) { ... } // ahora sí se puede

Parámetros opcionales ❤️

Muchas gracias

Parámetros opcionales

Parámetros requeridos

Parámetros opcionales nombrados

Dónde poner las llaves y corchetes en parámetros opcionales?

Super me encantó esta clase!

Muy interesantes estos tipos de parametros habia visto en c# algo parecido con params que te perimitia uno o una lista, pero aqui veo que son cien por ciento opcional

wow muchas gracias

Muy buena clase, por ahora no se me ocurre algún caso en el que pueda ocupar los parámetros posicionados pero es posible que en Flutter se vea el uso de esto

Ejercicio de lo visto en clase.

void student ({String persona = 'David', int nota = 10})
{
	print('El estudiante $persona tuvo una calificacion de: $nota');
}

main() => ();

//salida por defecto: El estudiante David tuvo una calificacion de: 10

Otras posibles salidas de este código

main => (persona: 'Pedro', nota: 6);
//salida: El estudiante Pedro tuvo una calificacion de: 6

No importa el orden

main => (nota: 8, persona: 'Jose');
//Salida: El estudiante Jose tuvo una calificacion de: 8
main(List<String> args) {
  parametrosRequeridos(1, 2);
  parametrosOpcPosicionados(1);
  parametrosOpcNombrados(1, parametro2: 5);
  parametrosOpcNombrados(1);

  parametrosOpcNombrados2(parametro2: 5, parametro1: 10);
}

void parametrosRequeridos(int a, int b) {
  print('Imprime parametro1 ${a}');
  print('Imprime parametro2 ${b}');
}

//Parametros opcionales posicionados []
void parametrosOpcPosicionados(int a, [int b]) {
  print('Imprime parametro1 ${a}');
  print('Imprime parametro2 ${b}');
}

//Parametros opcionales nombrados {} debe ser el opc al final de los parametros
void parametrosOpcNombrados(int a, {int parametro2 = 6}) {
  print('Imprime parametro1 ${a}');
  print('Imprime parametro2 ${parametro2}');
}

void parametrosOpcNombrados2({int parametro1 = 3, int parametro2 = 6}) {
  print('Imprime parametro1 ${parametro1}');
  print('Imprime parametro2 ${parametro2}');
}

Parametros opcionales

`main(){
functionPositioned(3);
functionNamed(3 , b:-1);
}

//El parametro entre [] significa que es opcional.
void functionPositioned(int a , [int b]){
print(‘Parametro #1 $a’);
print(‘Parametro #2 $b’);
}

//El parametro entre {} significa que es opcional.
void functionNamed(int a , {int b}){
print(‘Parametro #1 $a’);
print(‘Parametro #2 $b’);
}`

Interesante el uso que se le puede dar a esto.

main(List<String> args) {

//Esta funcion contiene parametros requeridos, ya que si no funciona
paramRequeridos(4,5);
paramOpcPosi(4);//=>El editor incluso nos marca que solo requier el primer parametro
paramOpcNombrado(7,param2:2);
paramOpcNombradoDefecto(8, param2: 6);//=>asigna el nuevo valor al parametro
paramOpcNombradosTodos(param2:9,param1: 23 );

}

void paramRequeridos( int a, int b){
print(‘Imprime param1 $a’);
print(‘Imprime param2 $b’);
}

void paramOpcPosi(int a, [int b]){

print(‘Imprime param1 $a’);
print(‘Imprime param2 $b’);
}
//Para una lista larga de parametros
void paramOpcNombrado(int a, {int param2}){
print(‘Imprime param1 $a’);
print(‘Imprime param2 $param2’);
}

//Funcion con parametros por defecto

void paramOpcNombradoDefecto(int a, {int param2 = 4}){
print(‘Imprime param1 $a’);
print(‘Imprime param2 $param2’);

}

//Funcion paratros nombrados opcionales, cambiando el orden pero no afecta el funcionamiento
void paramOpcNombradosTodos({int param1, int param2 }){
print(‘Imprime param1 $param1’);
print(‘Imprime param2 $param2’);

}

Para usar parámetros opcionales nombrados que deben ser enviados debe utilizarse @required

requiredParameter('Jose Luis', age:23);

void requiredParameter(String name, {@required int age} ){
  print('Name $name');
  print('Age $age');
}

esto lo encontré bien explicado

main(List<String> args) {
  paramRequeridos(1, 2);
  paramopuesto(1);
  paraOPCNombrado(a:1, b: 6);
}

void paramRequeridos(int a , int b){
  print('paramatro 1 $a');
  print('paramatro 2 $a');
}

void paramopuesto(int a , [int b]){
print('parametro 1 $a');
print('parametro 1 $b');
}

void paraOPCNombrado({int a , int b =3}){
print('parametro 1 $a');
print('parametro 1 $b');

}```

Un pequeño ejemplo con el tema del orden de los parametros de una funcion.

void main() {
  
  //Funciones
  //String mensaje = saludar(1, true); esto no se hace
  String mensaje = saludar2(nombre:'Pepa',texto: 'Hola:');
  
  //
  print(mensaje);

  
}

//Pasamos dos parametros establecidos en un orden
String saludar({String texto, String nombre}) {
  return '$texto $nombre';
}

//Funcion de flecha
String saludar2({String texto, String nombre}) => '$texto $nombre';
  
main(List<String> args) {
  paramReq(24, 17);
  paramOpcPos(24);
  paramOpcNom(24, segundoParametro: 17);
  paramOptNomValorDefecto(5);
  paramOptNomValorDefecto(5, c: 17);
}

//Parámetros requeridos: Al momento de invocar la función
//deben enviarse sí o sí, o el compilador indicará un error.

void paramReq(int a, int b) {
  print('Parametro 1: $a');
  print('Parametro 2: $b');
}

//Salida
//Parámetro 1: 24
//Parámetro 2: 17

//Parámetros opcionales posicionados: Los corchetes indican
//que el parámetro es opcional posicionado en ese lugar.
//Por lo tanto, no es obligatorio invocar la función con ese
//parámetro y saldrá 'null'.

void paramOpcPos(int a, [int b]) {
  print('Parametro 1: $a');
  print('Parametro 2: $b');
}

//Salida
//Parámetro 1: 24
//Parámetro 2: null

//Parámetros opcionales nombrados: Poseen la misma lógica
//que el anterior tipo, pero aquí podemos nombrarlos al
//momento de la invocación con el valor que se quiera.

void paramOpcNom(int a, {int segundoParametro}) {
  print('Parametro 1: $a');
  print('Parametro 2: $segundoParametro');
}

//Salida
//Parámetro 1: 24
//Parámetro 2: 17

//Parámetros opcionales por defecto: Poseen la misma
//lógica que el anterior tipo nombrado, pero podemos
//asignar un valor por defecto si es que no se invoca
//otro valor diferente...

void paramOptNomValorDefecto(int a, {int c = 15}) {
  print('Los valores son $a y $c ' + (c == 15 ? '(Valor por Defecto)' : ''));
}

// Salida:
// Los valores son 5 y 15 (Valor por Defecto)
// Los valores son 5 y 17```

Resumen:

main(List <String> arguments){


  //Imprimiendo Función con parámetros requeridos
  paramRequeridos(4, 7);

  print('');

  //Imprimiendo Función con parámetros opcionales
  paramOpcionales(15, 23);

  print('');

  // Imprimiendo Función con parámetros opcionales nombrados
  paramOpcionalNombrado(4, c: 78, b: 8);
}

/**
*Función con PARÁMETROS REQUERIDOS
*/
void paramRequeridos(int a, int b){

  print('El parámetro 1 es: $a');
  print('El parámetro 2 es: $b');
}

/**
 * Función con PARÁMETROS OPCIONALES
 * No es necesario indicar el nombre del parámetro a la hora de enviar el valor
 * Se utilizan corchetes []
 * Se puede enviar valor o simplemente no se envía
 */
void paramOpcionales(int a, [int b]){

  if(b == null){
    print('El parámetro 1 es: $a');
    print('El parámetro 2 no pudo ser capturado');
  }else{
  print('El parámetro 1 es: $a');
  print('El parámetro 2 es: $b');}
}

/**
 * Función con PARÁMETROS OPCIONALES NOMBRADOS
 * En caso de asignar un valor a un parámetro opcional, el mismo debe de ser
 * nombrado.
 * Se utilizan llaves {}
 * Los valores pueden asignarse en cualquier orden debido a que son nombrados
 * SOLO APLICA PARA LAS VARIABLES DENTRO DE LAS LLAVES {}
 */
void paramOpcionalNombrado(int a, {int b, int c}){

  if(b == null && c == null){
    print('El parámetro 1 es: $a');
    print('Los parámetros 2 y 3 no pudieron ser capturados');
  }
  else if(b == null && c != null) {
    print('El parámetro 1 es: $a');
    print('El parámetro 2 no pudo ser capturado');
    print('El parámetro 3 es: $c');
  }
  else if(c == null && b != null) {
    print('El parámetro 1 es: $a');
    print('El parámetro 2 es: $b');
    print('El parámetro 3 no pudo ser capturado');
  }
  else{
    print('El parámetro 1 es: $a');
    print('El parámetro 2 es: $b');
    print('El parámetro 3 es: $c');}

}