Arguments ou paramètres? [dupliquer]

Un Paramètre 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 passe à la fonction:

functionName(argument);

pour user1515422, un exemple très concret montrant la différence entre les paramètres et les arguments:

Considérer cette fonction:

int divide(int numerator, int denominator) {
    return numerator/denominator;
}

il a deux paramètres : numerator et denominator , réglé quand il est défini. Une fois définis, les paramètres d'une fonction sont fixes et ne changent pas.

considérez 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 à la valeur de l'argument 8 , et denominator est défini à 4 . Ensuite, la fonction est évaluée avec les paramètres définis à la valeur des arguments. Vous pouvez penser au processus comme équivalent à:

int divide() {
    int numerator = 8;
    int denominator = 4;
    return numerator/denominator;
}

la différence entre un paramètre et un argument 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 surgir parce qu'il est naturel de dire des choses comme "x est cinq", comme raccourci pour "la variable x a la valeur 5", mais avec un peu de chance la distinction est claire.

est-ce que ça clarifie les choses?

les Arguments sont ce que vous avez quand 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 Wikipédia sur ce sujet.

en bref -- paramètre est le nom formel défini par la fonction et argument est la valeur réelle (comme 5) ou chose (comme variable) passé 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 qu'on peut dire que les paramètres sont aux arguments ce que les classes sont aux instances des objets...

quand 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 aux arguments que vous avez passés. Les arguments sont ce que vous mettez dans la question, quand vous l'appelez. Espérons que cela a aidé.

il N'y a simplement pas de différences majeures. Si nous allons profondément à l'intérieur de cela nous pouvons identifier la diff.Principalement nous savons que L'Argument / paramètre / signature sont tous les mêmes.

essentiellement paramètre définit le type de données que nous transmettons.Où comme le Argument définit les données réelles / variable que nous passons.

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

dans la plupart des cas, une procédure nécessite des informations sur les circonstances dans lesquelles elle a été appelée. Une procédure qui effectue répétée ou tâches partagées utilise des informations différentes pour chaque appel. Cette information se compose de variables, constantes et expressions que vous passez à la procédure lorsque vous l'appelez.

pour communiquer cette information à la procédure, la procédure définit un paramètre, et le code appelant passe un argument à ce paramètre. Vous pouvez considérer le paramètre comme une place de stationnement et l'argument comme une automobile. Tout comme des automobiles différentes peuvent se garer dans le parking à des moments différents, 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 vous demande de passer lorsque vous l'appelez. La déclaration de la procédure définit ses paramètres.

lorsque vous définissez une "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 optionnel, ce qui signifie que le code appelant n'a pas à passer une valeur pour lui.

le nom de chaque paramètre sert de variable dans la procédure. Vous utilisez le nom du paramètre de la même manière que vous utilisez toute autre variable.

Arguments

Un argument représente la valeur que vous passez à un paramètre de procédure lorsque vous appelez la procédure. Le code d'appel fournit les arguments quand il appelle la procédure.

lorsque vous appelez une fonction ou Sous-procédure , vous incluez liste d'arguments entre parenthèses, immédiatement après le nom de la procédure. Chaque argument correspond au paramètre dans la même position dans la liste.

contrairement à la définition des paramètres, les arguments n'ont pas de noms. Chaque argument est une expression, qui peut contenir zéro ou plus de variables, constantes, et littérales. Le type de données de l'expression évaluée devrait normalement correspondre au type de données défini pour le paramètre correspondant, et dans tous les cas, il doit être convertible au type de paramètre.

en fait les deux paramètres et l'argument sont des types différents de paramètres. 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 à la fois integer et s2 sont des paramètres formels ou des paramètres parlant vaguement.

2)paramètres ou arguments réels-variables apparaissent dans sous-programmes appelant le

sous-programme déjà défini

, par exemple. (en Java) supposons que 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 paramètres ou arguments réels. J'espère que cela aide.

pensez-y comme de l'algèbre de base. X est le paramètre que vous devez remplir, et de le nombre à l'intérieur de c'est l'argument. Donc si vous avez une équation comme X+2, X est votre paramètre, et tous les nombres que vous changez 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("ceci"), c'est la définition serait dosomething (chaîne parametername), mais "ceci" serait l'argument réel qui est fourni au paramètre, ici appelé parametername.

De la façon la plus simple de le regarder, le paramètre est la chose que l'argument comble, et l'argument peut être n'importe quel nombre de choses permises par ce paramètre.

donc c'est une relation de plusieurs paramètres à un argument, comme vous pouvez avoir un paramètre qui peut avoir plusieurs valides arguments, comme notre équation X+1 ci-dessus. X peut être n'importe quel nombre connu, et ils sont tous valides.

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 transmise à une fonction.

un argument est une donnée (une valeur) transmise à une fonction.

$variable = 'data/value';

function first($variable){ ... }

function second('data/value'){ ... }
function third(16){ ... }

en fonction d'abord nous passons un paramètre.

en fonction deuxième et troisième nous passons des arguments.