Qual é a diferença entre parâmetros nomeados e posicionais no Dart?

O Dart suporta parâmetros opcionais nomeados e parâmetros opcionais posicionais. Quais sao as diferenças entre os dois?

Além disso, como você pode saber se um parâmetro opcional foi realmente especificado?

O Dart possui dois tipos de parâmetros opcionais: nomeado e posicional . Antes de discutir as diferenças, primeiro quero discutir as semelhanças.

Os parâmetros opcionais do Dart são opcionais , pois o chamador não precisa especificar um valor para o parâmetro ao chamar a função.

Parâmetros opcionais só podem ser declarados após quaisquer parâmetros necessários.

Os parâmetros opcionais podem ter um valor padrão, usado quando um chamador não especifica um valor.

Parâmetros opcionais posicionais

Um parâmetro agrupado por [ ]é um parâmetro opcional posicional. Aqui está um exemplo:

getHttpUrl(String server, String path, [int port=80]) {
  // ...
}

No código acima, porté opcional e tem um valor padrão de 80.

Você pode chamar getHttpUrlcom ou sem o terceiro parâmetro.

getHttpUrl('example.com', '/index.html', 8080); // port == 8080
getHttpUrl('example.com', '/index.html');       // port == 80

Você pode especificar vários parâmetros posicionais para uma função:

getHttpUrl(String server, String path, [int port=80, int numRetries=3]) {
  // ...
}

Os parâmetros opcionais são posicionais , pois você não pode omitir portse desejar especificar numRetries.

getHttpUrl('example.com', '/index.html');
getHttpUrl('example.com', '/index.html', 8080);
getHttpUrl('example.com', '/index.html', 8080, 5);

Claro, a menos que você saiba o que são 8080 e 5, é difícil dizer quais são esses números aparentemente mágicos. Você pode usar parâmetros opcionais nomeados para criar APIs mais legíveis.

Parâmetros opcionais nomeados

Um parâmetro agrupado por { }é um parâmetro opcional nomeado. Aqui está um exemplo:

getHttpUrl(String server, String path, {int port = 80}) {
  // ...
}

Você pode chamar getHttpUrlcom ou sem o terceiro parâmetro. Você deve usar o nome do parâmetro ao chamar a função.

getHttpUrl('example.com', '/index.html', port: 8080); // port == 8080
getHttpUrl('example.com', '/index.html');             // port == 80

Você pode especificar vários parâmetros nomeados para uma função:

getHttpUrl(String server, String path, {int port = 80, int numRetries = 3}) {
  // ...
}

Como os parâmetros nomeados são referenciados por nome, eles podem ser usados ​​em uma ordem diferente de sua declaração.

getHttpUrl('example.com', '/index.html');
getHttpUrl('example.com', '/index.html', port: 8080);
getHttpUrl('example.com', '/index.html', port: 8080, numRetries: 5);
getHttpUrl('example.com', '/index.html', numRetries: 5, port: 8080);
getHttpUrl('example.com', '/index.html', numRetries: 5);

Acredito que os parâmetros nomeados facilitam a compreensão dos sites de chamada, especialmente quando há sinalizadores booleanos ou números fora do contexto.

Verificando se o parâmetro opcional foi fornecido

Infelizmente, você não pode distinguir entre os casos "um parâmetro opcional não foi fornecido" e "um parâmetro opcional foi fornecido com o valor padrão".

Nota: Você pode usar parâmetros opcionais posicionais ou parâmetros opcionais nomeados, mas não os dois na mesma função ou método. O seguinte não é permitido.

thisFunctionWontWork(String foo, [String positonal], {String named}) {
  // will not work!
}

No Dart, pelo que entendi, o parâmetro method pode ser fornecido em dois tipos.

• Parâmetro obrigatório
• Parâmetro opcional (posicional, nomeado e padrão)

>> Parâmetro Necessário

O parâmetro obrigatório é um parâmetro de estilo antigo bem conhecido, que todos conhecemos.

exemplo :

findVolume(int length, int breath, int height) {
 print('length = $length, breath = $breath, height = $height');
}

findVolume(10,20,30);

resultado:

length = 10, breath = 20, height = 30

>> Parâmetro Posicional Opcional

O parâmetro será divulgado com colchete [] e parâmetro entre colchetes são opcionais.

exemplo:

findVolume(int length, int breath, [int height]) {
 print('length = $length, breath = $breath, height = $height');
}

findVolume(10,20,30);//valid
findVolume(10,20);//also valid

resultado:

length = 10, breath = 20, height = 30
length = 10, breath = 20, height = null // no value passed so height is null

>> Parâmetro nomeado opcional

• O parâmetro será divulgado com colchete {}
• parâmetro entre colchetes são opcionais.
• tem que usar o nome do parâmetro para atribuir um valor que se separou com colan :
• na ordem dos parâmetros entre colchetes encaracolados não importa
• esses parâmetros de tipo nos ajudam a evitar confusão ao passar valor para uma função que possui muitos parâmetros.

exemplo:

findVolume(int length, int breath, {int height}) {
 print('length = $length, breath = $breath, height = $height');
}

findVolume(10,20,height:30);//valid & we can see the parameter name is mentioned here.
findVolume(10,20);//also valid

resultado:

length = 10, breath = 20, height = 30
length = 10, breath = 20, height = null

>> Parâmetro padrão opcional

• igual ao parâmetro nomeado opcional. Além disso, podemos atribuir um valor padrão para esse parâmetro.
• o que significa que nenhum valor é passado, esse valor padrão será utilizado.

exemplo:

findVolume(int length, int breath, {int height=10}) {
 print('length = $length, breath = $breath, height = $height');
} 

findVolume(10,20,height:30);//valid
findVolume(10,20);//valid 

resultado:

length = 10, breath = 20, height = 30
length = 10, breath = 20, height = 10 // default value 10 is taken

obrigado pela explicação clara fornecida neste link do vídeo, créditos para o criador do vídeo.

link do vídeo: OptionalPositionalParameters

link do vídeo: OptionalNamedParameters

link do vídeo: OptionalDefaultParameters

Quando o parâmetro de uma função é especificado usando a sintaxe "paramName: value", é um parâmetro nomeado. Tais parâmetros podem ser tornados opcionais, colocando-os entre [e] colchetes. Uma demonstração rudimentar dessa função pode ser demonstrada no seguinte programa Hello World:

sayHello([String name = ' World!']) {
  print('Hello, ${name}');
}

void main() {
  sayHello('Govind');
}

De doc temos que tanto positionale namedparâmetros são opcionais, o que significa que todos eles podem estar ausentes.

Na minha opinião, os namedparâmetros são mais rigorosos que positionalos. Por exemplo, se você declarar esse método:

String say({String from, String msg})

Acima frome msgsão namedparâmetros, quando você chama o método, saydeve usar say(from: "xx", msg: "xx"). As teclas não podem estar ausentes.

No entanto, se você usar parâmetros posicionais, estará livre.

Parâmetros Posicionais:

Eles são iguais aos parâmetros padrão. Por exemplo:

void add(int x, [int y = 3]);

Aqui y tem o valor padrão de 3

Parâmetros nomeados:

Estes são parâmetros que podem ser passados ​​em qualquer ordem, passando o nome do parâmetro seguido pelo valor passado. Por exemplo:

void sum({int num1, int num2});

Esta função é chamada assim:

sum(num1: 12, num2: 24);

Os parâmetros também nomeados também podem ter valores padrão.