Arguments ou paramètres?
Je me retrouve souvent confus avec la façon dont les termes "arguments" et "paramètres" sont utilisés. Ils semblent être utilisés de manière interchangeable dans le monde de la programmation.
Quelle est la convention correcte pour leur utilisation?
Les paramètres sont les choses définies par les fonctions en entrée, les arguments sont les choses passées en paramètres.
void foo(int bar) { ... }
foo(baz);
Dans cet exemple, bar est un paramètre pour foo. baz est un argument passé à foo.
A Parameter est une variable dans la déclaration d'une fonction:
functionName(parameter) {
// do something
}
Un Argument est la valeur réelle de cette variable qui est passée à la fonction:
functionName(argument);
Pour user1515422, un exemple très concret montrant la différence entre paramètres et arguments:
Considérez cette fonction:
int divide(int numerator, int denominator) {
return numerator/denominator;
}
Il a deux paramètres: numerator et denominator, définis quand il est défini. Une fois définis, les paramètres d'une fonction sont fixes et ne changeront pas.
Considérons maintenant une invocation de cette fonction:
int result = divide(8, 4);
Dans ce cas, 8 et 4 sont les arguments passés à la fonction. Le paramètre numerator est défini sur la valeur de l'argument 8 et denominator est défini sur 4. Ensuite, la fonction est évaluée avec les paramètres définis sur la valeur des arguments. Vous pouvez considérer le processus comme équivalent à:
int divide() {
int numerator = 8;
int denominator = 4;
return numerator/denominator;
}
La différence entre un paramètre et un argument s'apparente à la différence entre une variable et sa valeur. Si j'écris int x = 5;, la variable est x et la valeur est 5. La confusion peut survenir parce qu'il est naturel de dire des choses comme "x est cinq", comme raccourci pour "La variable x a la valeur 5", mais j'espère que la distinction est claire.
Est-ce que cela clarifie les choses?
Les arguments sont ce que vous avez lorsque vous invoquez un sous-programme. Les paramètres sont ce à quoi vous accédez à l'intérieur du sous-programme.
argle(foo, bar);
foo et bar sont des arguments.
public static void main(final String[] args) {
args.length;
}
args est un paramètre.
Il y a une belle section dans paramètre article Wikipedia sur ce sujet.
En bref - paramètre est le nom formel défini par la fonction et argument est une valeur réelle (comme 5) ou une chose (comme une variable) passée en fonction.
Bien que Wikipedia ne soit guère une source faisant autorité, il fait un travail décent de expliquant les termes .
Je suppose que vous pourriez dire que les paramètres sont aux arguments ce que les classes sont aux instances d'objets ...
Lorsque vous définissez une fonction comme:
MyFunction(param1,param2) {
print parameter1, parameter
}
Vous définissez les paramètres lorsque vous définissez la fonction. Lorsque vous appelez la fonction comme ceci:
MyFunction('argument1', 'argument2');
Vous définissez les valeurs des paramètres sur les arguments que vous avez transmis. Les arguments sont ce que vous mettez dans la question lorsque vous l'appelez. J'espère que cela a aidé.
Dans la plupart des cas, une procédure a besoin d'informations sur les circonstances dans lesquelles elle a été appelée. Une procédure qui effectue des tâches répétées ou partagées utilise des informations différentes pour chaque appel. Ces informations sont constituées de variables, de constantes et d'expressions que vous transmettez à la procédure lorsque vous l'appelez.
Pour communiquer ces informations à la procédure, la procédure définit un paramètre et le code appelant transmet un argument à ce paramètre. Vous pouvez considérer le paramètre comme une place de parking et l'argument comme une automobile. Tout comme différentes voitures peuvent se garer sur le parking à différents moments, le code appelant peut passer un argument différent au même paramètre chaque fois qu'il appelle la procédure.
Paramètres
Un paramètre représente une valeur que la procédure attend de vous que vous l'appeliez. La déclaration de la procédure définit ses paramètres.
Lorsque vous définissez un Fonction ou Sous-procédure, vous spécifiez une liste de paramètres entre parenthèses immédiatement après le nom de la procédure. Pour chaque paramètre, vous spécifiez un nom, un type de données et un mécanisme de passage (ByVal ou ByRef). Vous pouvez également indiquer qu'un paramètre est facultatif, ce qui signifie que le code appelant n'a pas à lui transmettre de valeur.
Le nom de chaque paramètre sert de variable locale dans la procédure. Vous utilisez le nom du paramètre de la même manière que vous utilisez n'importe quelle autre variable.
Arguments
Un argument représente la valeur que vous transmettez à un paramètre de procédure lorsque vous appelez la procédure. Le code appelant fournit les arguments lorsqu'il appelle la procédure.
Lorsque vous appelez un Function ou Sub procedure, vous incluez une liste d'arguments entre parenthèses immédiatement après le nom de la procédure. Chaque argument correspond au paramètre à la même position dans la liste.
Contrairement à la définition des paramètres, les arguments n'ont pas de nom. Chaque argument est une expression, qui peut contenir zéro ou plusieurs variables, constantes et littéraux. Le type de données de l'expression évaluée doit normalement correspondre au type de données défini pour le paramètre correspondant et, dans tous les cas, il doit être convertible en type de paramètre.
Il n'y a tout simplement pas de différences majeures. Si nous allons profondément à l'intérieur de cela, nous pouvons identifier le diff.Mainly nous savons que l'argument/paramètre/signature sont tous les mêmes.
Fondamentalement, Parameter définit le type de données que nous transmettons. Là où Argument définit les données/variables réelles que nous transmettons.
Exemple de paramètre: -
int add(int a,int b){ //Here a and be both can treated as Parameter
return a+b;
}
Exemple d'argument: -
int return_result=add(3,4); // Here 3 and 4 both can treated as Argument
or
int x=3,y=4;
int return_result=add(x,y);// Here x and y both can treated as Argument
Pensez-y comme une algèbre de base. X est le paramètre que vous devez remplir et le nombre que vous placez à l'intérieur est l'argument. Donc, si vous avez une équation comme X + 2, X est votre paramètre, et tous les nombres que vous modifiez pour X deviennent connus comme les arguments. Donc, si vous utilisez cette équation, vous complétez 1 pour x, vous obtenez 1 + 2. Cela signifie que 1 est un argument, fourni au paramètre de X.
De même, si vous avez une fonction comme dosomething ("This"), sa définition serait dosomething (string parametername), mais "This" serait l'argument réel qui est fourni au paramètre, ici nommé parametername.
De la manière la plus simple à voir, le paramètre est la chose que l'argument remplit, et l'argument peut être un nombre quelconque de choses autorisées par ce paramètre.
Il s'agit donc d'une relation plusieurs à un entre les paramètres et les arguments, car vous pouvez avoir un paramètre qui peut avoir de nombreux arguments valides, comme notre équation X + 1 ci-dessus. X peut être n'importe quel nombre connu, et ils sont tous valides.
En fait, le paramètre et l'argument sont tous deux des types de paramètres différents. Ce sont
1) Paramètres formels - les variables apparaissent dans les définitions de fonction/sous-programme
par exemple. (en Java)
public void foo(Integer integer, String... s2)
Ici, entier et s2 sont des paramètres formels ou des paramètres en gros.
2) Paramètres ou arguments réels - les variables apparaissent dans les sous-programmes lors de l'appel
sous-programme déjà défini
par exemple. (en Java) supposons que si la fonction "foo" réside dans l'objet "testObject",
testObject.foo(new Integer(1), "test")
Ainsi, les variables dans la définition de fonction sont appelées paramètres formels ou simplement paramètres et variables tandis que les méthodes d'appel sont appelées comme paramètres ou arguments réels. J'espère que ça aide.
Une variable est un emplacement de stockage et un nom symbolique associé (un identifiant) qui contient des données, une valeur.
Un paramètre est une variable passée à une fonction.
Un argument est une donnée (une valeur) passée à une fonction.
$variable = 'data/value';
function first($variable){ ... }
function second('data/value'){ ... }
function third(16){ ... }
En fonction nous passons d'abord un paramètre.
Dans les fonctions deuxième et troisième, nous passons des arguments.