Qu'est-ce qu'un "effet secondaire?"

Je n'ai pas bien compris le concept d'effet secondaire.

• Quel est l'effet secondaire dans la programmation?
• Cela dépend-il du langage de programmation?
• Existe-t-il des effets secondaires externes et internes?

S'il vous plaît donner quelques exemples de causes qui créent des effets secondaires.

Un effet secondaire fait simplement référence à la modification d'un type d'état - par exemple:

• Changer la valeur d'une variable;
• Écrire des données sur le disque;
• Activer ou désactiver un bouton dans l'interface utilisateur.

Contrairement à ce que certaines personnes semblent dire:

• Un effet secondaire ne doit pas nécessairement être caché ou inattendu (cela peut être, mais cela n’a rien à voir avec la définition telle qu’elle s’applique à l’informatique);

• Un effet secondaire n'a rien à voir avec idempotency. Une fonction idempotente peut avoir des effets secondaires, et une fonction non-idempotente peut ne pas en avoir (par exemple, obtenir la date et l'heure actuelles du système).

C'est vraiment très simple. Effet secondaire = changer quelque chose quelque part.

PS Comme le commente Benjol l'a fait remarquer, plusieurs personnes peuvent associer la définition d'un effet secondaire à la définition d'une fonction pure , fonction qui est (a) idempotente et (b) ne produit pas d'effets secondaires. L’un n’implique pas l’autre en informatique générale, mais les langages de programmation fonctionnels tendent généralement à imposer ces deux contraintes.

Toute opération qui modifie l'état de l'ordinateur ou qui interagit avec le monde extérieur est réputée avoir un effet secondaire. Voir Wikipedia sur les effets secondaires .

Par exemple, cette fonction n'a pas d'effets secondaires. Son résultat dépend uniquement de ses arguments d'entrée, et rien de l'état du programme ou de son environnement ne change quand il est appelé:

int square(int x) { return x * x; }

En revanche, l’appel de ces fonctions vous donnera des résultats différents selon l’ordre dans lequel vous les appelez, car elles changent quelque chose sur l’état de l’ordinateur:

int n = 0;
int next_n() { return n++; }
void set_n(int newN) { n = newN; }      

Cette fonction a pour effet d’écrire des données dans la sortie. Vous n'appelez pas la fonction parce que vous voulez sa valeur de retour; vous l'appelez parce que vous voulez l'effet qu'il a sur le "monde extérieur":

int Write(const char* s) { return printf("Output: %s\n", s); }

Je pense que les réponses existantes sont assez bonnes. Je voudrais développer certains aspects sur lesquels l’OMI n’a pas été suffisamment soulignée.

En mathématiques, une fonction est simplement un mappage d'un tuple de valeurs sur une valeur. Donc, étant donné une fonction fet une valeur x, le résultat f(x)sera toujours le même y. Vous pouvez bien remplacer f(x)par ypartout dans une expression et rien ne changera.

Ce que l’on appelle une fonction (ou une procédure) dans de nombreux langages de programmation est une construction (morceau de code) qui peut être exécutée pour les raisons suivantes:

1. Il calcule une fonction au sens mathématique, c’est-à-dire à partir de valeurs d’entrée, il renvoie un résultat, ou
2. Cela produit un effet, par exemple, affiche quelque chose à l'écran, modifie une valeur dans une base de données, lance des missiles, dort pendant 10 secondes, envoie un SMS.

Les effets peuvent donc être liés à l’état, mais également à d’autres aspects tels que le tir d’un missile ou la suspension de l’exécution pendant quelques secondes.

Le terme effet secondaire peut sembler négatif, mais normalement, l’appel d’une fonction est l’objet même de la fonction elle-même. Je suppose que, puisque le terme fonction a été utilisé à l'origine en mathématiques, le calcul d'une valeur est considéré comme le principal effet d'une fonction, alors que tout autre effet est considéré comme un effet secondaire . Certains langages de programmation utilisent le terme procédure pour éviter toute confusion avec les fonctions au sens mathématique.

Notez que

1. Certaines procédures sont utiles à la fois pour leur valeur de retour et leur effet secondaire.
2. Certaines procédures ne calculent qu'une valeur de résultat et n'ont aucun autre effet. On les appelle souvent des fonctions pures car elles ne font que calculer une fonction au sens mathématique.
3. Certaines procédures, par exemple sleep()en Python, ne sont utiles que pour leurs effets (secondaires),. Celles-ci sont souvent modélisées comme des fonctions renvoyant une valeur spéciale None, ou unitou ()ou ..., ce qui indique simplement que le calcul s'est terminé correctement.

Un effet secondaire survient lorsqu'une opération a un effet sur une variable / un objet en dehors de l'utilisation prévue.

Cela peut arriver lorsque vous appelez une fonction complexe qui a pour effet secondaire de modifier une variable globale, même si ce n'est pas pour cette raison que vous l'avez appelée (vous l'avez peut-être appelée pour extraire quelque chose d'une base de données).

J'avoue que j'ai du mal à trouver un exemple simple qui n'a pas l'air totalement artificiel, et des exemples de choses sur lesquelles j'ai travaillé sont trop longs à publier ici (et comme c'est lié au travail, je ne devrais probablement pas de toute façon ).

Un exemple que j'ai vu (il y a quelque temps) était une fonction qui ouvrait une connexion à une base de données si la connexion était dans un état fermé. Le problème était qu'il était supposé fermer la connexion à la fin de la fonction, mais le développeur avait oublié d'ajouter ce code. Donc, ici, il y avait un effet secondaire non intentionnel : l'appel d'une procédure était supposé faire uniquement une requête et l'effet secondaire était que la connexion restait ouverte et si la fonction était appelée deux fois de suite, une erreur serait générée en indiquant que la connexion était déjà ouvert.

Ok, puisque tout le monde donne des exemples maintenant, je pense que je le ferai aussi;)

/*code is PL/SQL-styled pseudo-code because that's what's on my mind right now*/

g_some_global int := 0; --define a globally accessible variable somewhere.

function do_task_x(in_a in number) is
begin
    b := calculate_magic(in_a);
    if b mod 2 == 0 then
        g_some_global := g_some_global + b;
    end if;
    return (b * 2.3);
end;

La fonction do_task_xa un premier effet de retourner le résultat de certains calculs, et un côté pour effet de modifier éventuellement une variable globale.

Bien sûr, ce qui est l'effet primaire et qui est le côté pourrait être ouvert à l' interprétation et peut dépendre de l'utilisation réelle. Si j'appelle cette fonction dans le but de modifier le global et que je rejette la valeur renvoyée, je dirais que la modification du global est l'effet principal.

En informatique, une fonction ou une expression est dite avoir un effet secondaire si elle modifie un état ou a une interaction observable avec des fonctions appelantes ou avec le monde extérieur.

De Wikipedia - Effet secondaire

Une fonction, au sens mathématique, est un mappage d’entrée en sortie. L’appel d’une fonction a pour effet de mapper l’entrée sur la sortie qu’elle renvoie. Si la fonction fait autre chose, peu importe, mais si elle a un comportement qui ne mappe pas l'entrée vers la sortie, ce comportement est connu pour être un effet secondaire.

En termes plus généraux, un effet secondaire est un effet qui n’est pas l’effet recherché par le concepteur de la construction.

Un effet est tout ce qui affecte un acteur. Si j'appelle une fonction qui envoie un message texte de séparation à ma petite amie, qui affecte un groupe d'acteurs, moi-même, elle-même, le réseau de l'entreprise de téléphonie mobile, etc. Le seul effet recherché en appelant une fonction sans effets secondaires, c'est pour la fonction pour me retourner un mappage de mon entrée. Donc pour:

   public void SendBreakupTextMessage() {
        Messaging.send("I'm breaking up with you!")
   }

Si cela est censé être une fonction, la seule chose à faire est de retourner vide. S'il était sans effet secondaire, il ne devrait pas envoyer le message texte.

Dans la plupart des langages de programmation, il n'y a pas de construction pour une fonction mathématique. Aucune construction n'est destinée à être utilisée en tant que telle. C'est pourquoi la plupart des langues disent que vous avez des méthodes ou des procédures. De par leur conception, ceux-ci sont conçus pour pouvoir produire beaucoup plus d’effets. Dans le langage courant de la programmation, personne ne se soucie vraiment de l’intention de ce qu’est une méthode ou une procédure, ainsi quand on dit que cette fonction a un effet secondaire, ils veulent dire en réalité que cette construction ne se comporte pas comme une fonction mathématique. Et quand quelqu'un dit que cette fonction est sans effet secondaire, ils veulent dire que cette construction se comporte efficacement comme une fonction mathématique.

Une fonction pure est toujours libre d'effets secondaires, par définition. Une fonction pure, est une façon de dire, cette fonction, même si elle utilise une construction qui permet plus d'effets, n'a pour effet qu'un effet égal à celui d'une fonction mathématique.

Je défie quiconque de me dire quand une fonction sans effets secondaires ne serait pas pure. À moins que l'effet recherché principal du contexte de la phrase utilisant les termes pur et effet secondaire secondaire ne soit pas celui de l'effet recherché mathématique d'une fonction, ceux-ci sont toujours égaux.

En tant que tel, parfois, bien que plus rarement, et je crois que c'est la distinction qui manque et qui égare les gens (car ce n'est pas l'hypothèse la plus courante) dans la réponse acceptée, mais on suppose parfois que l'effet recherché d'une fonction de programmation est: mapper l'entrée sur la sortie, entrée non contrainte aux paramètres explicites de la fonction, mais sortie limitée à la valeur de retour explicite. Si vous supposez que c'est l'effet recherché, alors une fonction lisant un fichier et renvoyant un résultat différent en fonction de son contenu est toujours sans effet secondaire, car vous avez autorisé les entrées provenant d'autres endroits de l'effet souhaité.

Alors, pourquoi est-ce si important?

Tout est question de contrôle et de maintien. Si vous appelez une fonction et que cette dernière renvoie une valeur, il est difficile de raisonner sur son comportement. Vous devrez aller à l'intérieur de la fonction pour que le code réel devine ce qu'il fait et affirme son exactitude. La situation idéale est qu’il est très clair et facile de savoir quelle entrée est utilisée par la fonction et qu’elle ne fait rien d’autre que de renvoyer une sortie pour elle. Vous pouvez vous détendre un peu et dire que savoir exactement quelle entrée il utilise n’est pas aussi utile que d’être certain de ne rien faire d’autre que vous pourriez ne pas être au courant, puis de renvoyer une valeur. Vous êtes donc peut-être content qu'il ne fait rien d'autre que mapper l'entrée, peu importe d'où il provient, à la sortie.

Dans presque tous les cas, le but d'un programme est d'avoir des effets autres que la cartographie des éléments entrant dans les éléments à venir. L'idée de contrôler l'effet secondaire est que vous pouvez organiser le code d'une manière plus facile à comprendre et à raisonner. Si vous mettez tous les effets secondaires ensemble, dans un endroit très explicite et central, il est facile de savoir où regarder et de croire que c'est tout ce qui se passe, pas plus. Si vous souhaitez que l'entrée soit très explicite également, cela permet de tester le comportement de différentes entrées, et il est plus facile à utiliser, car vous n'avez pas besoin de modifier l'entrée dans de nombreux endroits différents. Certains peuvent ne pas être évidents, pour obtenir ce que vous voulez.

Parce que le meilleur moyen de comprendre, de raisonner et de contrôler le comportement d’un programme est de regrouper toutes les entrées de manière claire et explicite, et de regrouper et d’expliciter tous les effets secondaires, c’est généralement ce dont les gens parlent quand ils disent: effet secondaire, pur, etc.

Parce que le plus utile est le regroupement des effets secondaires et de leur caractère explicite, parfois les gens ne veulent que le dire, et le différencient en disant que ce n'est pas pur, mais qu'il reste "sans effets secondaires". Mais l’effet secondaire est relatif à l’effet supposé «effet primaire voulu», il s’agit donc d’un terme contextuel. Je trouve que cela est moins souvent utilisé, bien qu’étonnamment, on en parle beaucoup dans ce fil.

Enfin, idempotent signifie que si vous appelez cette fonction plusieurs fois avec les mêmes entrées (peu importe d'où elles viennent), vous obtiendrez toujours les mêmes effets (effets secondaires ou non).

En programmation, un effet secondaire survient lorsqu'une procédure modifie une variable en dehors de sa portée. Les effets secondaires ne dépendent pas de la langue. Il existe certaines classes de langages qui visent à éliminer les effets secondaires (langages fonctionnels purs), mais je ne suis pas sûr qu'il en existe qui nécessitent des effets secondaires, mais je peux me tromper.

Pour autant que je sache, il n'y a pas d'effets secondaires internes et externes.

Voici un exemple simple:

int _totalWrites;
void Write(string message)
{
    // Invoking this function has the side effect of 
    // incrementing the value of _totalWrites.
    _totalWrites++;
    Debug.Write(message);
}

La définition des effets secondaires n’est pas spécifique à la programmation; imaginez simplement les effets secondaires de vos médicaments ou de l’alimentation.

Un effet secondaire est ce qui se passe dans le code et qui n'est pas évident.

Par exemple, disons que vous avez cette classe

public class ContrivedRandomGenerator {
   public int Seed { get; set; }

   public int GetRandomValue()
   {
      Random(Seed);
      Seed++;
   }
}

Lorsque vous créez initialement la classe, vous lui donnez une graine.

var randomGenerator = new ContrivedRandomGenerator();
randomGenerator.Seed = 15;
randomGenerator.GetRandomValue();

Vous ne connaissez pas les composants internes, vous vous attendez simplement à obtenir une valeur aléatoire et vous vous attendez à ce que randomGenerator.Seed soit toujours 15 ... mais ce n'est pas le cas.

L’appel de fonction a eu l’effet secondaire de changer la valeur de la graine.