Réponses:
En informatique, une opération idempotente est une opération qui n'a aucun effet supplémentaire si elle est appelée plusieurs fois avec les mêmes paramètres d'entrée. Par exemple, la suppression d'un élément d'un ensemble peut être considérée comme une opération idempotente sur l'ensemble.
En mathématiques, une opération idempotente est celle où f (f (x)) = f (x) . Par exemple, la abs()
fonction est idempotente car abs(abs(x)) = abs(x)
pour tous x
.
Ces définitions légèrement différentes peuvent être rapprochées en considérant que x dans la définition mathématique représente l'état d'un objet, et f est une opération qui peut muter cet objet. Par exemple, considérons le Pythonset
et sa discard
méthode. La discard
méthode supprime un élément d'un ensemble et ne fait rien si l'élément n'existe pas. Donc:
my_set.discard(x)
a exactement le même effet que de faire deux fois la même opération:
my_set.discard(x)
my_set.discard(x)
Les opérations idempotentes sont souvent utilisées dans la conception de protocoles réseau, où une demande d'exécution d'une opération est garantie de se produire au moins une fois, mais peut également se produire plusieurs fois. Si l'opération est idempotente, il n'y a aucun mal à effectuer l'opération deux fois ou plus.
Voir l'article Wikipedia sur l' idempotence pour plus d'informations.
La réponse ci-dessus contenait précédemment des exemples incorrects et trompeurs. Les commentaires ci-dessous écrits avant avril 2014 font référence à une ancienne révision.
set
exemple Python de la réponse, l'objet défini a clairement un état et propose également des opérations idempotentes telles que discard
.
discard
peut également être mis en œuvre d'une manière sans état en englobant l'état de la valeur de retour: discard([my_set, x]) = [my_new_set, x]
. Vous pouvez donc le faire discard(discard([my_set, x]))
. Notez qu'il ne [my_new_set, x]
s'agit que d'un seul argument et que son type est à 2 tuples.
discard(x)
une deuxième fois aura le même effet que l'appeler la première fois: l'ensemble ne contiendra plus x
. Le calcul de l'idempotence concerne la robustesse d'un système. Étant donné que les choses peuvent échouer (par exemple, une panne de réseau), lorsqu'une défaillance est détectée, comment récupérez-vous? La récupération la plus simple consiste à recommencer, mais cela ne fonctionne que si la répétition est idempotente. Par exemple, discard(x)
est idempotent, mais pop()
ne l'est pas. C'est une question de récupération d'erreur.
Une opération idempotente peut être répétée un nombre arbitraire de fois et le résultat sera le même que s'il n'avait été effectué qu'une seule fois. En arithmétique, l'ajout de zéro à un nombre est idempotent.
L'idempotence est souvent évoquée dans le contexte des services Web "RESTful". REST cherche à tirer le meilleur parti de HTTP pour donner aux programmes un accès au contenu Web, et est généralement défini contrairement aux services Web basés sur SOAP, qui ne font que tunneler les services de style d'appel de procédure distante dans les requêtes et réponses HTTP.
REST organise une application Web en «ressources» (comme un utilisateur Twitter ou une image Flickr), puis utilise les verbes HTTP POST, PUT, GET et DELETE pour créer, mettre à jour, lire et supprimer ces ressources.
L'idempotence joue un rôle important dans le REST. Si vous OBTENEZ une représentation d'une ressource REST (par exemple, OBTENEZ une image jpeg à partir de Flickr) et que l'opération échoue, vous pouvez simplement répéter GET encore et encore jusqu'à ce que l'opération réussisse. Pour le service Web, peu importe le nombre de fois où l'image est obtenue. De même, si vous utilisez un service Web RESTful pour mettre à jour les informations de votre compte Twitter, vous pouvez METTRE les nouvelles informations autant de fois qu'il le faut pour obtenir la confirmation du service Web. Le mettre mille fois est le même que le mettre une fois. De même, SUPPRIMER mille fois une ressource REST revient à la supprimer une fois. L'idempotence facilite donc beaucoup la construction d'un service Web résistant aux erreurs de communication.
Pour en savoir plus: RESTful Web Services , par Richardson et Ruby (l'idempotence est discutée page 103-104), et la thèse de Roy Fielding sur REST . Fielding a été l'un des auteurs de HTTP 1.1, RFC-2616, qui parle d'idempotence dans la section 9.1.2 .
Peu importe combien de fois vous appelez l'opération, le résultat sera le même.
truncate
et delete
.
L'idempotence signifie que l'application d'une opération une ou plusieurs fois a le même effet.
Exemples:
Pour les fonctions pures (fonctions sans effets secondaires), l'idempotence implique que f (x) = f (f (x)) = f (f (f (x))) = f (f (f (f (x)))) ) = ...... pour toutes les valeurs de x
Pour les fonctions avec effets secondaires , l'idempotence implique en outre qu'aucun effet secondaire supplémentaire ne sera provoqué après la première application. Vous pouvez considérer l'état du monde comme un paramètre "caché" supplémentaire à la fonction si vous le souhaitez.
Notez que dans un monde où vous avez des actions simultanées en cours, vous pouvez constater que les opérations que vous pensiez idempotentes cessent de l'être (par exemple, un autre thread peut annuler la valeur de l'indicateur booléen dans l'exemple ci-dessus). Fondamentalement, chaque fois que vous avez un accès simultané et un état mutable, vous devez réfléchir beaucoup plus attentivement à l'idempotence.
L'idempotence est souvent une propriété utile dans la construction de systèmes robustes. Par exemple, s'il existe un risque que vous receviez un message en double d'un tiers, il est utile que le gestionnaire de messages agisse comme une opération idempotente afin que l'effet de message ne se produise qu'une seule fois.
f(x) = f(f(x))
, voulez-vous dire que ce f(x){return x+1;}
n'est pas une fonction pure? parce que f(x) != f(f(x))
: f(1)
donne 2 tandis que f(2)
donne 3.
f(x) = f(f(x))
. Mais comme @GregHewgill l'a mentionné, pour que cette définition ait un sens, vous devez considérer x
comme un objet et f
comme une opération qui mute l'état de l'objet (c'est-à-dire que la sortie de f
est une mutée x
).
Une opération idempotente produit le résultat dans le même état même si vous l'appelez plus d'une fois, à condition de transmettre les mêmes paramètres.
Je voulais juste jeter un vrai cas d'utilisation qui démontre l'idempotence. En JavaScript, supposons que vous définissez un groupe de classes de modèle (comme dans le modèle MVC). La façon dont cela est souvent implémenté est fonctionnellement équivalente à quelque chose comme ça (exemple de base):
function model(name) {
function Model() {
this.name = name;
}
return Model;
}
Vous pouvez alors définir de nouvelles classes comme ceci:
var User = model('user');
var Article = model('article');
Mais si vous tentiez d'obtenir la User
classe via model('user')
, ailleurs dans le code, cela échouerait:
var User = model('user');
// ... then somewhere else in the code (in a different scope)
var User = model('user');
Ces deux User
constructeurs seraient différents. C'est,
model('user') !== model('user');
Pour le rendre idempotent , vous devez simplement ajouter une sorte de mécanisme de mise en cache, comme ceci:
var collection = {};
function model(name) {
if (collection[name])
return collection[name];
function Model() {
this.name = name;
}
collection[name] = Model;
return Model;
}
En ajoutant la mise en cache, chaque fois que vous le ferez, model('user')
ce sera le même objet, et donc c'est idempotent. Donc:
model('user') === model('user');
Une opération idempotente est une opération, une action ou une demande qui peut être appliquée plusieurs fois sans modifier le résultat, c'est-à-dire l'état du système, au-delà de l'application initiale.
EXEMPLES (CONTEXTE DE L'APPLICATION WEB):
IDEMPOTENT: Faire plusieurs demandes identiques a le même effet que faire une seule demande. Un message dans un système de messagerie électronique est ouvert et marqué comme "ouvert" dans la base de données. On peut ouvrir le message plusieurs fois, mais cette action répétée n'entraînera que le message à l'état "ouvert". Il s'agit d'une opération idempotente. La première fois que l'on met une mise à jour sur une ressource en utilisant des informations qui ne correspondent pas à la ressource (l'état du système), l'état du système change à mesure que la ressource est mise à jour. Si un PUT effectue la même mise à jour sur une ressource à plusieurs reprises, les informations contenues dans la mise à jour correspondront aux informations déjà présentes dans le système à chaque PUT et aucune modification de l'état du système ne se produira. Les PUT répétés avec les mêmes informations sont idempotents:
NON-IDEMPOTENT: Si une opération provoque toujours un changement d'état, comme POSER le même message à un utilisateur à plusieurs reprises, résultant en un nouveau message envoyé et stocké à chaque fois dans la base de données, nous disons que l'opération est NON-IDEMPOTENT.
NULLIPOTENT: Si une opération n'a pas d'effets secondaires, comme afficher uniquement des informations sur une page Web sans aucune modification dans une base de données (en d'autres termes, vous ne faites que lire la base de données), nous disons que l'opération est NULLIPOTENT. Tous les GET doivent être nullipotents.
Lorsque nous parlons de l'état du système, nous ignorons évidemment, espérons-le, les effets inoffensifs et inévitables comme la journalisation et les diagnostics.
Opérations idempotentes: opérations qui n'ont aucun effet secondaire si elles sont exécutées plusieurs fois.
Exemple : une opération qui récupère des valeurs d'une ressource de données et, par exemple, l'imprime
Opérations non idempotentes: opérations qui causeraient des dommages si elles étaient exécutées plusieurs fois. (Comme ils changent certaines valeurs ou certains états)
Exemple: une opération qui se retire d'un compte bancaire
Des réponses assez détaillées et techniques. Il suffit d'ajouter une définition simple.
Idempotent = réexécutable
Par exemple, l'
Create
opération en soi n'est pas garantie de fonctionner sans erreur si elle est exécutée plusieurs fois. Mais s'il y a une opération, CreateOrUpdate
elle indique la réexécution (Idempotency).
Une opération idempotente sur un ensemble laisse ses membres inchangés lorsqu'elle est appliquée une ou plusieurs fois.
Il peut s'agir d'une opération unaire comme absolue (x) où x appartient à un ensemble d'entiers positifs. Ici absolu (absolu (x)) = x.
Il peut s'agir d'une opération binaire comme l' union d'un ensemble avec lui - même retournerait toujours le même ensemble.
à votre santé
C'est n'importe quelle opération que chaque nième résultat se traduira par une sortie correspondant à la valeur du 1er résultat. Par exemple, la valeur absolue de -1 est 1. La valeur absolue de la valeur absolue de -1 est 1. La valeur absolue de la valeur absolue de la valeur absolue de -1 est 1. Et ainsi de suite.
Voir aussi: Quel serait le moment vraiment idiot d'utiliser la récursivité?
Un bon exemple de compréhension d'une opération idempotente pourrait être de verrouiller une voiture avec une clé à distance.
log(Car.state) // unlocked
Remote.lock();
log(Car.state) // locked
Remote.lock();
Remote.lock();
Remote.lock();
log(Car.state) // locked
lock
est une opération idempotente. Même s'il y a des effets secondaires à chaque fois que vous courez lock
, comme clignoter, la voiture est toujours dans le même état verrouillé, peu importe le nombre de fois que vous exécutez le verrouillage.
mon 5c: Dans l'intégration et la mise en réseau, l'idempotence est très importante. Plusieurs exemples tirés de la vie réelle: Imaginez, nous livrons des données au système cible. Données fournies par une séquence de messages. 1. Que se passerait-il si la séquence était mixée en canal? (Comme les packages réseau le font toujours :)). Si le système cible est idempotent, le résultat ne sera pas différent. Si le système cible dépend du bon ordre dans la séquence, nous devons implémenter le reséquenceur sur le site cible, ce qui rétablirait le bon ordre. 2. Que se passerait-il s'il y avait des doublons de message? Si le canal du système cible ne reconnaît pas en temps opportun, le système source (ou le canal lui-même) envoie généralement une autre copie du message. En conséquence, nous pouvons avoir un message en double du côté du système cible. Si le système cible est idempotent, il s'en occupe et le résultat ne sera pas différent. Si le système cible n'est pas idempotent, nous devons implémenter le déduplicateur du côté système cible du canal.
En bref , les opérations idempotentes signifient que l'opération n'entraînera pas de résultats différents quel que soit le nombre de fois que vous exécutez les opérations idempotentes.
Par exemple, selon la définition de la spécification de HTTP, GET, HEAD, PUT, and DELETE
sont des opérations idempotentes; mais POST and PATCH
ne le sont pas. C'est pourquoi POST
est parfois remplacé par PUT
.
réessayez.
Est généralement le moyen le plus simple de comprendre sa signification en informatique.
Idempotent operations are often used in the design of network protocols
s'agit d'un exemple connexe ** GET n'est pas supposé changer quoi que ce soit sur le serveur, donc GET est idempotent. Dans le contexte HTTP / servlet, cela signifie que la même demande peut être effectuée deux fois sans conséquences négatives. ** POST N'EST PAS idempotent.