De manière générale, nous entendons tous parler des fonctions ou procédures des langages de programmation. Cependant, je viens de découvrir que j'utilise ces termes de manière presque interchangeable (ce qui est probablement très faux).

Donc, ma question est:

Quelle est la différence en termes de fonctionnalité, d’objectif et d’utilisation?

Un exemple serait apprécié.

Une fonction renvoie une valeur et une procédure exécute simplement des commandes.

La fonction de nom vient des mathématiques. Il est utilisé pour calculer une valeur basée sur l'entrée.

Une procédure est un ensemble de commandes qui peuvent être exécutées dans l'ordre.

Dans la plupart des langages de programmation, même les fonctions peuvent avoir un ensemble de commandes. Par conséquent, la différence ne concerne que le retour d'une partie valeur.

Mais si vous aimez garder une fonction propre, (regardez simplement les langages fonctionnels), vous devez vous assurer qu'une fonction n'a pas d'effet secondaire.

Cela dépend du contexte.

Dans les langages de type Pascal, les fonctions et les procédures sont des entités distinctes, différant selon qu'elles renvoient ou non une valeur. Ils se comportent différemment. la syntaxe du langage (par exemple, la procédure appelle des instructions de formulaire; vous ne pouvez pas utiliser un appel de procédure dans une expression et les appels de fonction ne forment pas d'instructions, vous devez les utiliser dans d'autres instructions). Par conséquent, les programmeurs de race Pascal font la différence entre ceux-ci.

Dans les langages de type C et dans de nombreux autres langages contemporains, cette distinction a disparu; dans les langages typés statiquement, les procédures ne sont que des fonctions avec un type de retour amusant. C'est probablement pourquoi ils sont utilisés de manière interchangeable.

Dans les langages fonctionnels, il n'y a généralement pas de procédure - tout est fonction.

Exemple en C:

// function
int square( int n ) {
   return n * n;
}

// procedure
void display( int n ) {
   printf( "The value is %d", n );
}

Même si vous devez noter que la norme C ne parle pas de procédures, elle fonctionne uniquement.

En général, une procédure est une séquence d'instructions.
Une fonction peut être la même, mais elle renvoie généralement un résultat.

Il y a un terme sous - programme ou sous - programme qui représente un morceau de code paramétré qui peut être appelé à partir de différents endroits.

Les fonctions et procédures sont des implémentations de celles-ci. Les fonctions renvoient généralement des valeurs et les procédures ne renvoient rien.

Différences fondamentales

• Une fonction doit renvoyer une valeur mais dans les procédures stockées, elle est facultative: une procédure peut renvoyer 0 ou n valeurs.
• Les fonctions ne peuvent avoir que des paramètres d'entrée, tandis que les procédures peuvent avoir des paramètres d'entrée / sortie.
• Pour une fonction, il est obligatoire de prendre un paramètre d'entrée, mais une procédure stockée peut prendre de 0 à n paramètres d'entrée.
• Les fonctions peuvent être appelées à partir d'une procédure tandis que les procédures ne peuvent pas être appelées à partir d'une fonction.

Différences avancées

• Les exceptions peuvent être gérées par des blocs try-catch dans une procédure, alors qu'un bloc try-catch ne peut pas être utilisé dans une fonction.
• Nous pouvons opter pour la gestion des transactions dans une procédure, alors que dans une fonction, nous ne pouvons pas.

En SQL:

• Une procédure permet SELECTainsi que DML (INSERT , UPDATE, DELETE) déclarations qu'elle, alors que la fonction ne permetSELECT déclaration en elle.
• Les procédures ne peuvent pas être utilisées dans une SELECTinstruction, tandis que les fonctions peuvent être intégrées dans unSELECT instruction.
• Les procédures stockées ne peuvent pas être utilisées dans des instructions SQL n'importe où dans un WHERE (ou un HAVINGou unSELECT bloc ), contrairement aux fonctions.
• Les fonctions qui renvoient des tables peuvent être traitées comme un autre ensemble de lignes. Cela peut être utilisé dans unJOIN bloc avec d'autres tables.
• Les fonctions en ligne peuvent être considérées comme des vues qui prennent des paramètres et peuvent être utilisées dans des JOINblocs et d'autres opérations d'ensemble de lignes.

Plus strictement, une fonction f obéit à la propriété que f (x) = f (y) si x = y, c'est-à-dire qu'elle calcule le même résultat chaque fois qu'elle est appelée avec le même argument (et donc qu'elle ne change pas l'état de la système.)

Ainsi, rand () ou print ("Bonjour"), etc. ne sont pas des fonctions mais des procédures. Alors que sqrt (2.0) devrait être une fonction: il n'y a pas d'effet observable ni de changement d'état quelle que soit la fréquence à laquelle on l'appelle et il renvoie toujours 1.41 et certains.

Si nous sommes indépendants de la langue ici, la procédure spécifie généralement une série d'actes nécessaires pour atteindre de manière fiable et idempotente un certain résultat. Autrement dit, une procédure est essentiellement un algorithme.

Les fonctions, d'autre part, sont un morceau de code quelque peu indépendant dans un programme plus vaste. En d'autres termes, la fonction est la mise en œuvre d'une procédure.

C'est une vieille question bien connue, mais j'aimerais partager quelques idées sur la recherche et la conception d'un langage de programmation moderne.

Réponse basique

Traditionnellement (dans le sens d' une programmation structurée ) et informelle, une procédure est une construction structurelle réutilisable pour avoir une «entrée» et pour faire quelque chose de programmable. Lorsque quelque chose doit être fait dans une procédure, vous pouvez fournir des arguments (réels) à la procédure dans un appel de procédure codé dans le code source (généralement dans une sorte d'expression), et les actions codées dans le corps des procédures (fournies dans la définition de la procédure) sera exécuté avec la substitution des arguments dans les paramètres (formels) utilisés dans le corps.

Une fonction est plus qu'une procédure car les valeurs de retour peuvent également être spécifiées comme "sortie" dans le corps. Les appels de fonction sont plus ou moins identiques aux appels de procédure, sauf que vous pouvez également utiliser le résultat de l'appel de fonction, syntaxiquement (généralement comme sous-expression d'une autre expression).

Traditionnellement, les appels de procédure (plutôt que les appels de fonction) sont utilisés pour indiquer qu'aucune sortie ne doit être intéressée, et il doit y avoir des effets secondaires pour éviter que l'appel ne soit sans opération, mettant ainsi l'accent sur le paradigme de programmation impératif . De nombreux langages de programmation traditionnels comme Pascal fournissent à la fois des "procédures" et des "fonctions" pour distinguer cette différence intentionnelle de styles.

(Pour être clair, les "entrées" et les "sorties" mentionnées ci-dessus sont des notions simplifiées basées sur les propriétés syntaxiques des fonctions. De nombreux langages prennent également en charge la transmission d'arguments aux paramètres par référence / partage, pour permettre aux utilisateurs de transporter des informations encodées en arguments pendant les appels. Un tel paramètre peut même être appelé simplement "paramètre d'entrée / sortie". Cette caractéristique est basée sur la nature des objets passés dans les appels, qui est orthogonale aux propriétés de la caractéristique de procédure / fonction.)

Cependant, si le résultat d'un appel de fonction n'est pas nécessaire, il peut être simplement (au moins logiquement) ignoré, et les définitions de fonction / appels de fonction doivent être cohérentes avec les définitions de procédure / appels de procédure de cette manière. Les langages de type ALGOL comme C, C ++ et Java fournissent tous la fonctionnalité de "fonction" de cette manière: en codant le type de résultat voidcomme un cas spécial de fonctions ressemblant à des procédures traditionnelles, il n'est pas nécessaire de fournir la fonctionnalité de "procédures" "séparément. Cela empêche certains ballonnements dans la conception du langage.

Puisque SICP est mentionné, il convient également de noter que dans le langage Scheme spécifié par R ⁿ RS , une procédure peut ou non avoir à renvoyer le résultat du calcul. Il s'agit de l'union de la "fonction" traditionnelle (renvoyant le résultat) et de la "procédure" (ne renvoyant rien), essentiellement identique au concept de "fonction" de nombreux langages de type ALGOL (et partageant en fait encore plus de garanties comme des évaluations applicatives des opérandes avant l'appel). Cependant, des différences à l'ancienne se produisent encore, même dans des documents normatifs comme SRFI-96 .

Je ne sais pas grand-chose sur les raisons exactes de la divergence, mais comme je l'ai expérimenté, il semble que les concepteurs de langage seront plus heureux sans un gonflement des spécifications de nos jours. Autrement dit, la «procédure» en tant que fonction autonome n'est pas nécessaire. Des techniques comme le voidtype sont déjà suffisantes pour marquer l'utilisation où les effets secondaires doivent être accentués. Cela est également plus naturel pour les utilisateurs ayant des expériences sur les langages de type C, qui sont populaires depuis plus de quelques décennies. De plus, cela évite l'embarras dans des cas comme R ⁿ RS où les "procédures" sont en fait des "fonctions" au sens large.

En théorie, une fonction peut être spécifiée avec un type d'unité spécifié comme type du résultat de l'appel de fonction pour indiquer que le résultat est spécial. Cela distingue les procédures traditionnelles (où le résultat d'un appel n'est pas intéressé) des autres. Il existe différents styles dans la conception d'une langue:

• Comme dans R ⁿ RS, il suffit de marquer les résultats non intéressés comme valeur "non spécifiée" (de type non spécifié, si le langage doit le mentionner) et il suffit d'être ignoré.
• Spécification du résultat indifférent que la valeur d'un type de cellule dédiée (par exemple , le noyau est #inert) fonctionne aussi.
• Lorsque ce type est un autre type inférieur , il peut être (espérons-le) vérifié statiquement et empêché d'être utilisé comme type d'expression. Le voidtype dans les langages de type ALGOL est exactement un exemple de cette technique. ISO C11 _Noreturnest similaire mais plus subtile dans ce genre.

Lectures complémentaires

Comme le concept traditionnel dérivé des mathématiques, il existe tonnes de magie noire que la plupart des gens ne se soucient pas de savoir. À strictement parler, vous ne pourrez probablement pas tout clarifier selon vos livres de mathématiques. Les livres CS pourraient ne pas fournir beaucoup d'aide non plus.

Concernant les langages de programmation, il y a plusieurs mises en garde:

• Les fonctions dans différentes branches des mathématiques ne sont pas toujours définies avec les mêmes significations. Les fonctions dans différents paradigmes de programmation peuvent également être très différentes (même parfois les syntaxes des appels de fonction se ressemblent). Parfois, les raisons de ces différences sont les mêmes, mais parfois elles ne le sont pas.
  • Il est idiomatique de modéliser le calcul par des fonctions mathématiques puis d' implémenter le calcul sous - jacent dans les langages de programmation. Faites attention à ne pas les mapper un à un à moins que vous ne sachiez de quoi on parle.
• Ne confondez pas le modèle avec l'entité à modéliser.
  • Ce dernier n'est qu'une des applications de la première. Il peut y avoir plus d'un choix, selon les contextes (les branches de mathématiques intéressées, par exemple).
  • En particulier, il est plus ou moins tout aussi absurde de traiter des "fonctions" comme des "mappages" ou des sous-ensembles de produits cartésiens comme pour traiter les nombres naturels comme le codage Von-Neumann des ordinaux (ressemblant à un tas de {{{}}, {}}...) en plus de certains contextes limités .
• Mathématiquement, les fonctions peuvent être partielles ou totales . Différents langages de programmation sont traités différemment ici.
  • Certains langages fonctionnels peuvent honorer la totalité des fonctions pour garantir que le calcul dans les appels de fonction se termine toujours par étapes finies. Cependant, ce n'est essentiellement pas Turing-complet, d'où une plus faible expressivité de calcul, et pas beaucoup vu dans les langages à usage général en dehors de la sémantique de la vérification typographique (qui devrait être totale).
  • Si la différence entre les procédures et les fonctions est importante, devrait-il y avoir des «procédures totales»? Hmm ...
• Les constructions similaires aux fonctions des calculs utilisées pour modéliser le calcul général et la sémantique des langages de programmation (par exemple les abstractions lambda dans les calculs lambda ) peuvent avoir différentes stratégies d'évaluation sur les opérandes.
  • Dans les réductions traditionnelles des calculs purs ainsi que dans les évaluations d'expressions dans les langages fonctionnels purs , il n'y a pas d'effets secondaires altérant les résultats des calculs. Par conséquent, il n'est pas nécessaire d'évaluer les opérandes avant le corps des constructions de type fonctions (car l'invariant pour définir les "mêmes résultats" est conservé par des propriétés comme l' équivalence β garantie par la propriété Church-Rosser ).
  • Cependant, de nombreux langages de programmation peuvent avoir des effets secondaires lors des évaluations d'expressions. Cela signifie que les stratégies d'évaluation strictes comme l' évaluation applicative ne sont pas les mêmes que celles d'évaluation non strictes comme l' appel par besoin . Ceci est important, car sans la distinction, il n'est pas nécessaire de distinguer les macros de type fonction (c'est-à-dire utilisées avec des arguments) des fonctions (traditionnelles). Mais selon la saveur des théories, cela peut toujours être un artefact. Cela dit, dans un sens plus large, les macros fonctionnelles (en particulier hygiéniques ) sont des fonctions mathématiques avec quelques limitations inutiles (phases syntaxiques). Sans les limitations, il pourrait être judicieux de traiter des macros de type fonction (de première classe) comme des procédures ...
  • Pour les lecteurs intéressés par ce sujet, considérez quelques abstractions modernes .
• Les procédures sont généralement considérées comme sortant du cadre des mathématiques traditionnelles. Cependant, dans les modèles de calcul de la sémantique du langage de calcul et de programmation, ainsi que dans les conceptions de langage de programmation contemporaines, il peut y avoir une grande famille de concepts connexes partageant la nature "appelable". Certains d'entre eux sont utilisés pour implémenter / étendre / remplacer des procédures / fonctions. Il existe des distinctions encore plus subtiles.
  • Voici quelques mots - clés connexes: subroutines / (stackless / stackful) coroutines / (delimited) non délimitées continuations ... et même (non vérifiées) exceptions .

Dans la plupart des contextes: une fonction renvoie une valeur, contrairement à une procédure. Les deux sont des morceaux de code regroupés pour faire la même chose.

Dans un contexte de programmation fonctionnelle (où toutes les fonctions renvoient des valeurs), une fonction est un objet abstrait:

f(x)=(1+x)
g(x)=.5*(2+x/2)

Ici, f est la même fonction que g, mais est une procédure différente.

Procédure interne, nous pouvons utiliser des instructions DML (Insert / Update / Delete), mais la fonction Inside nous ne pouvons pas utiliser des instructions DML.

La procédure peut avoir les deux paramètres d'entrée / sortie, mais la fonction ne peut avoir qu'un paramètre d'entrée.

Nous pouvons utiliser le bloc Try-Catch dans la procédure stockée, mais en fonction, nous ne pouvons pas utiliser le bloc Try-Catch.

Nous ne pouvons pas utiliser la procédure stockée dans l'instruction Select, mais dans la fonction, nous pouvons utiliser dans l'instruction Select.

La procédure stockée peut renvoyer 0 ou n valeurs (max 1024), mais la fonction ne peut renvoyer qu'une seule valeur qui est obligatoire.

La procédure stockée ne peut pas être appelée depuis la fonction, mais nous pouvons appeler la fonction depuis la procédure stockée.

Nous pouvons utiliser la transaction dans la procédure stockée, mais en fonction, nous ne pouvons pas utiliser la transaction.

Nous ne pouvons pas utiliser la procédure stockée dans l'instruction SQL n'importe où dans la section Où / Avoir / Sélectionner, mais la fonction Dans nous pouvons utiliser.

Nous ne pouvons pas rejoindre la procédure stockée, mais nous pouvons rejoindre la fonction.

pour en savoir plus ... cliquez ici ... http://dotnet-developers-cafe.blogspot.in/2013/08/difference-between-stored-procedure-and.html

Une fonction renvoie une valeur et une procédure exécute simplement des commandes.

La fonction de nom vient des mathématiques. Il est utilisé pour calculer une valeur basée sur l'entrée.

Une procédure est un ensemble de commandes qui peuvent être exécutées dans l'ordre.

Dans la plupart des langages de programmation, même les fonctions peuvent avoir un ensemble de commandes. Par conséquent, la différence ne concerne que le retour d'une partie valeur.

Mais si vous aimez garder une fonction propre, (regardez simplement les langages fonctionnels), vous devez vous assurer qu'une fonction n'a pas d'effet secondaire.

La fonction peut être utilisée dans une instruction sql alors que la procédure ne peut pas être utilisée dans une instruction sql.

Les instructions Insert, Update et Create ne peuvent pas être incluses dans la fonction mais une procédure peut avoir ces instructions.

La procédure prend en charge les transactions mais les fonctions ne prennent pas en charge les transactions.

La fonction doit renvoyer une et une seule valeur (une autre peut être renvoyée par la variable OUT) mais la procédure renvoie autant d'ensembles de données et de valeurs de retour.

Les plans d'exécution des fonctions et des procédures sont mis en cache, de sorte que les performances sont identiques dans les deux cas.

Je m'objecte avec quelque chose que je ne cesse de voir dans la plupart de ces réponses, que ce qui fait d'une fonction une fonction, c'est qu'elle renvoie une valeur.

Une fonction n'est pas n'importe quelle ancienne méthode qui renvoie une valeur. Ce n'est pas le cas: pour qu'une méthode soit une fonction réelle, elle doit renvoyer la même valeur, toujours avec une entrée spécifique. Un exemple de méthode qui n'est pas une fonction est la randomméthode dans la plupart des langues, car bien qu'elle renvoie une valeur, la valeur n'est pas toujours la même.

Une fonction est donc plus proche d'une carte (par exemple, où x -> x'pour une fonction unidimensionnelle). Il s'agit d'une distinction très importante entre les méthodes et les fonctions régulières, car lorsqu'il s'agit de fonctions réelles, le moment et l'ordre dans lesquels elles sont évaluées ne devraient jamais avoir d'importance, car ce n'est pas toujours le cas pour les non fonctions.

Voici un autre exemple d'une méthode qui n'est pas une fonction mais qui, sinon, renverra toujours une valeur.

// The following is pseudo code:
g(x) = {
  if (morning()) {
     g = 2 * x;
  }
  else {
   g = x;
  }
  return g;
}

Je m'oppose en outre à l'idée que les procédures ne renvoient pas de valeurs. Une procédure n'est qu'une manière spécifique de parler d'une fonction ou d'une méthode. Cela signifie donc que si la méthode sous-jacente que votre procédure définit ou implémente renvoie une valeur, devinez ce que cette procédure renvoie une valeur. Prenons par exemple l'extrait suivant du SICP :

// We can immediately translate this definition into a recursive procedure 
// for computing Fibonacci numbers:

(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1))
                 (fib (- n 2))))))

Avez-vous entendu parler des procédures récursives ces derniers temps? Ils parlent d'une fonction récursive (une fonction réelle) et cela renvoie une valeur et ils utilisent le mot "procédure". Alors, quelle est la différence, alors?

Une autre façon de penser une fonction (en plus du sens mentionné ci-dessus) est comme une représentation abstraite d'un idéal comme le chiffre 1. Une procédure est cette implémentation réelle de cette chose. Je pense personnellement qu'ils sont interchangeables.

(Remarque: si vous lisez ce chapitre à partir du lien que je fournis, vous constaterez peut-être qu'un concept plus difficile à saisir n'est pas la différence entre une fonction et une procédure, mais un processus et une procédure. Saviez-vous qu'une procédure récursive peut avoir un processus itératif?)

Un analogue pour les procédures sont les recettes. Par exemple; supposons que vous ayez une machine appelée make-piescette machine absorbe les ingrédients de (fruit, milk, flower, eggs, sugar, heat)et cette machine retourne a pie.

Une représentation de cette machine pourrait ressembler

make-pies (fruit, milk, flower, eggs, sugar, heat) = {
   return (heat (add fruit (mix eggs flower milk)))
}

Bien sûr, ce n'est pas la seule façon de faire une tarte.

Dans ce cas, nous pouvons voir que:

A       function     is to a     machine
as a    procedure    is to a     recipe
as      attributes   are to      ingredients
as      output       is to       product

Cette analogie est correcte, mais elle se décompose lorsque vous tenez compte du fait que lorsque vous avez affaire à un programme informatique, tout est une abstraction. Donc, contrairement au cas d'une recette à une machine, nous comparons deux choses qui sont elles-mêmes des abstractions; deux choses qui pourraient tout aussi bien être la même chose. Et je soutiens qu'ils sont (à toutes fins utiles) la même chose.

Dans le contexte de db : la procédure stockée est un plan d'exécution précompilé où les fonctions ne le sont pas.

En termes de С # / Java, la fonction est le bloc de code, qui retourne une valeur particulière, mais la procédure est le bloc de code qui retourne void (rien). En C # / Java, les fonctions et les procédures sont plus souvent appelées méthodes simples .

    //This is a function
    public DateTime GetCurrentDate()
    {
        return DateTime.Now.Date;
    }

    //This is a procedure(always return void)
    public void LogMessage()
    {
        Console.WriteLine("Just an example message.");
    }

Procédures: 1. Les sont les collections d'instructions qui définissent les calculs paramétrés. 2. Les procédures ne peuvent pas renvoyer de valeurs.

3. Les procédures ne peuvent pas être appelées à partir de la fonction.

Fonctions 1. Les fonctions ressemblent structurellement aux procédures mais sont sémantiquement modélisées sur des fonctions mathématiques. 2.Il peut renvoyer des valeurs 3. La fonction peut être appelée à partir de procédures.

Les procédures et les fonctions sont toutes deux des sous-routines, la seule différence entre elles est qu'une procédure renvoie plusieurs valeurs (ou du moins peut le faire) alors qu'une fonction ne peut renvoyer qu'une seule valeur (c'est pourquoi la notation de fonction est utilisée en mathématiques car généralement une seule valeur est trouvée à un moment donné) bien que certains langages de programmation ne suivent pas ces règles, ce sont leurs véritables définitions