Parâmetros e argumentos

Parâmetro pertence à definição; argumento pertence à chamada

Um parâmetro é um nome declarado pela rotina para representar uma entrada. Um argumento é o dado concreto fornecido quando essa rotina é chamada.

Observe as duas linhas:

FUNÇÃO calcularFrete(distanciaKm, pesoKg, taxaFixa): REAL

frete <- calcularFrete(300, 2.5, 10)

Na definição, distanciaKm, pesoKg e taxaFixa são parâmetros. Na chamada, 300, 2,5 e 10 são argumentos. Durante essa execução, cada argumento é associado ao parâmetro correspondente para que o corpo possa trabalhar com nomes que expressem significado.

Em conversas informais, os termos às vezes aparecem como sinônimos. Ao projetar ou diagnosticar uma chamada, a distinção é útil: parâmetros descrevem o contrato reutilizável; argumentos descrevem uma utilização concreta desse contrato.

Construa primeiro o contrato de entrada

Partindo das funções e procedimentos, vamos criar uma função que calcula um frete hipotético:

FUNÇÃO calcularFrete(distanciaKm, pesoKg, taxaFixa): REAL
  custoDistancia <- distanciaKm * 0.05
  custoPeso <- pesoKg * 2
  RETORNAR custoDistancia + custoPeso + taxaFixa
FIM FUNÇÃO

Cada parâmetro responde a uma pergunta diferente:

Parâmetro	Significado	Valor esperado no exemplo
distanciaKm	distância da entrega em quilômetros	número maior ou igual a zero
pesoKg	peso transportado em quilogramas	número maior que zero
taxaFixa	parcela monetária independente de distância e peso	número maior ou igual a zero

Não basta escolher nomes diferentes. O contrato precisa comunicar significado, unidade, tipo esperado e restrições. Dois parâmetros podem aceitar números e ainda assim representar conceitos incompatíveis.

Monte o recibo de cada chamada

Considere:

distanciaDoPedido <- 300
pesoDoPacote <- 2.5
frete <- calcularFrete(distanciaDoPedido, pesoDoPacote, 10)

Antes de entrar no corpo, cada expressão usada como argumento é avaliada. O resultado dessa avaliação é associado a um parâmetro:

Posição	Expressão enviada	Valor avaliado	Parâmetro de destino	Unidade esperada
1	distanciaDoPedido	300	distanciaKm	km
2	pesoDoPacote	2,5	pesoKg	kg
3	10	10	taxaFixa	moeda

Esse é o recibo da chamada. Dentro da função, o cálculo torna-se:

custoDistancia <- 300 * 0.05  // 15
custoPeso <- 2.5 * 2          // 5
frete <- 15 + 5 + 10          // 30

Um argumento não precisa ser apenas um literal. Pode ser uma variável, uma expressão ou o resultado de outra função, desde que produza um dado aceito pelo parâmetro:

frete <- calcularFrete(distanciaBase + desvioKm, obterPeso(pacote), 10)

Primeiro são obtidos os valores das expressões; depois a rotina trabalha com eles por meio dos nomes declarados.

Em chamadas posicionais, a ordem faz parte do contrato

Na forma posicional, o primeiro argumento ocupa o primeiro parâmetro, o segundo ocupa o segundo e assim por diante.

Esta chamada está correta:

calcularFrete(300, 2.5, 10)

Já esta troca distância e peso:

calcularFrete(2.5, 300, 10)

Os três argumentos continuam sendo números. Uma linguagem pode aceitar a chamada porque os tipos são compatíveis, mas o significado ficou errado:

custoDistancia <- 2.5 * 0.05  // 0.125
custoPeso <- 300 * 2          // 600
frete <- 610.125

O resultado não denuncia um erro de sintaxe; ele denuncia uma associação semântica incorreta. Por isso, testes e nomes de unidade são necessários mesmo quando o compilador ou interpretador aceita todos os valores.

Argumentos nomeados tornam a associação explícita

Algumas linguagens permitem indicar o parâmetro de destino pelo nome. Em Python, por exemplo:

def calcular_frete(distancia_km, peso_kg, taxa_fixa):
    return distancia_km * 0.05 + peso_kg * 2 + taxa_fixa

frete = calcular_frete(
    peso_kg=2.5,
    taxa_fixa=10,
    distancia_km=300,
)

Como os nomes estabelecem a associação, a ordem escrita pode mudar sem trocar os papéis. O resultado continua sendo 30.

C# também possui argumentos nomeados. JavaScript não possui a mesma sintaxe geral; um padrão comum é receber um objeto e extrair propriedades, mas isso é outra forma de desenhar a interface. Consulte as regras da linguagem antes de combinar argumentos posicionais e nomeados.

Use nomes quando eles eliminarem ambiguidade, especialmente em chamadas com vários valores do mesmo tipo:

agendar(dataInicio, dataFim, incluirFim)

Uma chamada como agendar(fim, inicio, verdadeiro) pode parecer plausível. Nomes explícitos ajudam a revisão, mas não corrigem valores errados por conta própria: associar dataInicio = fim continua sendo um erro lógico.

Parâmetros opcionais precisam de um padrão legítimo

Um parâmetro obrigatório exige que a chamada forneça o argumento correspondente. Um parâmetro opcional possui uma regra para quando o argumento é omitido.

Suponha que a taxa fixa normal seja 10:

FUNÇÃO calcularFrete(distanciaKm, pesoKg, taxaFixa = 10): REAL
  RETORNAR distanciaKm * 0.05 + pesoKg * 2 + taxaFixa
FIM FUNÇÃO

As duas chamadas abaixo produzem 30:

calcularFrete(300, 2.5)
calcularFrete(300, 2.5, 10)

O padrão deve representar um comportamento seguro e esperado. Se não existe uma escolha natural para distanciaKm, torná-la opcional apenas para encurtar a chamada esconde um dado necessário.

Também diferencie omissão de valores fornecidos explicitamente:

• omitir taxaFixa pede à rotina que aplique o padrão;
• fornecer 0 declara que não existe cobrança fixa;
• fornecer texto vazio passa um texto, não ausência numérica;
• fornecer null ou equivalente passa um marcador cujo tratamento depende do contrato e da linguagem.

Em JavaScript, um parâmetro padrão é usado quando o argumento está ausente ou é undefined; valores como 0, null e "" não acionam automaticamente o padrão.

Quantidade, tipo e significado precisam concordar

Ao revisar uma chamada, faça quatro verificações:

1. Quantidade: todos os parâmetros obrigatórios receberam argumento?
2. Associação: cada argumento chegou ao parâmetro correto por posição ou nome?
3. Compatibilidade: o valor possui um tipo de dado aceito ou uma conversão intencional?
4. Significado: unidade, faixa e regra do valor correspondem ao papel do parâmetro?

As linguagens reagem de maneiras diferentes. C# normalmente rejeita, durante a compilação, uma quantidade inadequada ou um tipo incompatível. Python costuma sinalizar na execução chamadas com argumentos obrigatórios ausentes ou nomes inesperados. JavaScript aceita quantidades flexíveis: parâmetros sem argumento recebem undefined, e argumentos excedentes podem não ser usados pela função.

Flexibilidade não elimina o contrato. Se uma string como "300" chega onde o algoritmo espera quilômetros numéricos, faça a conversão de tipos e a validação em uma fronteira definida, em vez de depender de coerções acidentais.

Associação não explica sozinha o compartilhamento de estado

Dizer que um argumento “vai para” um parâmetro não informa, por si só, se existe cópia de valor, cópia de referência, alias explícito ou outro mecanismo. Essas regras dependem da linguagem, do tipo e dos modificadores usados.

Em JavaScript, por exemplo, argumentos são passados por valor. Com um número, reatribuir o parâmetro não altera a variável externa:

function tentarAlterar(numero) {
  numero = 99;
}

let total = 10;
tentarAlterar(total);
console.log(total); // 10

Quando o valor copiado referencia um objeto, porém, alterar uma propriedade alcança o mesmo objeto:

function marcarCalculado(pedido) {
  pedido.status = "calculado";
}

const pedido = { status: "novo" };
marcarCalculado(pedido);
console.log(pedido.status); // "calculado"

Isso não significa que o objeto foi “passado por referência” no sentido técnico usado por outras linguagens. A referência ao objeto é o valor compartilhado. Ao aprender outra linguagem, confirme suas regras de passagem antes de prever mutações.

Teste o contrato com chamadas contrastantes

Para calcularFrete(distanciaKm, pesoKg, taxaFixa = 10), monte casos que revelem erros diferentes:

Chamada	Expectativa	O que verifica
calcularFrete(300, 2.5)	30	uso do padrão
calcularFrete(300, 2.5, 0)	20	zero explícito não vira padrão
calcularFrete(0, 2.5, 10)	15	limite da distância
calcularFrete(2.5, 300, 10)	rejeitar no domínio ou revelar 610,125	argumentos trocados
calcularFrete(300)	chamada incompleta	parâmetro obrigatório ausente
calcularFrete("300", 2.5)	converter ou rejeitar explicitamente	tipo inadequado

Um único caso correto não valida o contrato. Compare omissão e zero, posições corretas e trocadas, tipos aceitos e limites do domínio.

Pratique criando um recibo da chamada

Considere a rotina:

calcularPrecoFinal(precoBase, descontoPercentual, frete)

Analise a chamada:

preco <- 200
percentual <- 10
total <- calcularPrecoFinal(preco, percentual, 15)

Faça o exercício:

1. identifique os três parâmetros e os três argumentos;
2. crie o recibo com expressão, valor, destino e unidade;
3. calcule o resultado esperado: 195;
4. troque preco e percentual e observe por que os tipos numéricos não detectam o erro;
5. reescreva a chamada com argumentos nomeados em uma linguagem que os suporte;
6. decida se frete pode ter padrão zero e explique em qual regra de negócio isso seria legítimo.

O exercício está concluído quando outra pessoa consegue ler apenas a definição e a chamada e explicar exatamente qual valor ocupará cada parâmetro.

O que você deve guardar

Parâmetros são os nomes que definem as entradas de uma rotina; argumentos são as expressões e valores fornecidos por uma chamada. A execução associa cada argumento ao parâmetro correspondente por posição, por nome ou por outra regra da linguagem.

Uma chamada correta respeita quantidade, associação, compatibilidade e significado. Parâmetros opcionais precisam de padrões legítimos, e omissão não deve ser confundida com zero, vazio ou null. Depois que os dados entram de forma clara, aprenda como uma função produz e entrega resultados em retorno de valores.

Referências

• Microsoft Learn — Methods: parameters versus arguments. Acesso em 11 set. 2026.
• Microsoft Learn — Overview of methods: optional parameters and arguments. Acesso em 11 set. 2026.
• Python 3 Documentation — Keyword Arguments. Acesso em 11 set. 2026.
• MDN Web Docs — Functions: passing arguments. Acesso em 11 set. 2026.
• MDN Web Docs — Default parameters. Acesso em 11 set. 2026.