Wat is een idempotent-bewerking?
Antwoord 1, autoriteit 100%
In informatica is een idempotent-bewerking een bewerking die geen extra effect heeft als deze meer dan één keer wordt aangeroepen met dezelfde invoerparameters. Het verwijderen van een item uit een set kan bijvoorbeeld worden beschouwd als een idempotente bewerking op de set.
In de wiskunde is een idempotente bewerking een bewerking waarbij f(f(x)) = f(x). De functie abs()is bijvoorbeeld idempotent omdat abs(abs(x)) = abs(x)voor alle x.
Deze enigszins verschillende definities kunnen met elkaar worden verzoend door te bedenken dat xin de wiskundige definitie de toestand van een object vertegenwoordigt, en feen bewerking is die dat object kan muteren. Denk bijvoorbeeld aan de Python seten zijn discardmethode. De methode discardverwijdert een element uit een set en doet niets als het element niet bestaat. Dus:
my_set.discard(x)
heeft precies hetzelfde effect als twee keer dezelfde bewerking uitvoeren:
my_set.discard(x)
my_set.discard(x)
Idempotente bewerkingen worden vaak gebruikt bij het ontwerpen van netwerkprotocollen, waarbij een verzoek om een bewerking uit te voeren gegarandeerd minstens één keer voorkomt, maar ook meer dan één keer kan gebeuren. Als de bewerking idempotent is, kan het geen kwaad om de bewerking twee of meer keren uit te voeren.
Zie het Wikipedia-artikel over idempotencevoor meer informatie.
Het bovenstaande antwoord bevatte eerder enkele onjuiste en misleidende voorbeelden. Onderstaande opmerkingen die vóór april 2014 zijn geschreven, verwijzen naar een oudere revisie.
Antwoord 2, autoriteit 14%
Een idempotente bewerking kan een willekeurig aantal keren worden herhaald en het resultaat zal hetzelfde zijn alsof het maar één keer was gedaan. In de rekenkunde is het toevoegen van nul aan een getal idempotent.
Idempotentie wordt veel besproken in de context van “RESTful” webservices. REST probeert HTTP maximaal te benutten om programma’s toegang te geven tot webinhoud, en wordt meestal ingesteld in tegenstelling tot SOAP-gebaseerde webservices, die alleen externe procedure-aanroepstijlservices tunnelen binnen HTTP-verzoeken en -antwoorden.
REST organiseert een webtoepassing in “bronnen” (zoals een Twitter-gebruiker of een Flickr-afbeelding) en gebruikt vervolgens de HTTP-werkwoorden POST, PUT, GET en DELETE om die bronnen te maken, bij te werken, te lezen en te verwijderen.
Idempotentie speelt een belangrijke rol bij REST. Als u een weergave van een REST-bron KRIJGT (bijv. GET een jpeg-afbeelding van Flickr), en de bewerking mislukt, kunt u de GET gewoon keer op keer herhalen totdat de bewerking slaagt. Voor de webservice maakt het niet uit hoe vaak de afbeelding wordt opgehaald. Evenzo, als u een RESTful-webservice gebruikt om uw Twitter-accountgegevens bij te werken, kunt u de nieuwe informatie zo vaak PUTTEN als nodig is om bevestiging van de webservice te krijgen. Duizend keer ZETTEN is hetzelfde als één keer PUT. Op dezelfde manier is het duizend keer VERWIJDEREN van een REST-bron hetzelfde als één keer verwijderen. Idempotence maakt het dus een stuk eenvoudiger om een webservice te bouwen die bestand is tegen communicatiefouten.
Verder lezen: RESTful Web Services, door Richardson en Ruby (idempotence is besproken op pagina 103-104), en Roy Fielding’s PhD-dissertatie over REST. Fielding was een van de auteurs van HTTP 1.1, RFC-2616, dat spreekt over idempotentie in sectie 9.1.2.
Antwoord 3, autoriteit 11%
Het maakt niet uit hoe vaak je de operatie aanroept, het resultaat zal hetzelfde zijn.
Antwoord 4, autoriteit 5%
Idempotentie betekent dat het één keer of meerdere keren toepassen van een bewerking hetzelfde effect heeft.
Voorbeelden:
- Vermenigvuldiging met nul. Het maakt niet uit hoe vaak je het doet, het resultaat is nog steeds nul.
- Een booleaanse vlag instellen. Het maakt niet uit hoe vaak je het doet, de vlag blijft staan.
- Een rij verwijderen uit een database met een gegeven ID. Als je het opnieuw probeert, is de rij nog steeds weg.
Voor pure functies(functies zonder bijwerkingen) impliceert idempotentie dat f(x) = f(f(x)) = f(f(f(x))) = f( f(f(f(x)))) = …… voor alle waarden van x
Voor functies met bijwerkingenhoudt idempotentie bovendien in dat er na de eerste toepassing geen extra bijwerkingen zullen optreden. Je kunt de toestand van de wereld als een extra “verborgen” parameter voor de functie beschouwen als je wilt.
Houd er rekening mee dat in een wereld waar u gelijktijdige acties uitvoert, u wellicht zult merken dat bewerkingen waarvan u dacht dat ze idempotent waren, niet meer zo zijn (bijvoorbeeld, een andere thread zou de waarde van de booleaanse vlag in het bovenstaande voorbeeld kunnen uitschakelen). In principe moet je, wanneer je concurrency en veranderlijke status hebt, veel zorgvuldiger nadenken over idempotentie.
Idempotentie is vaak een nuttige eigenschap bij het bouwen van robuuste systemen. Als er bijvoorbeeld een risico bestaat dat u een duplicaat bericht van een derde partij ontvangt, is het handig om de berichthandler als een idempotent-bewerking te laten fungeren, zodat het berichteffect slechts één keer optreedt.
Antwoord 5, autoriteit 2%
Een idempotent-bewerking produceert het resultaat in dezelfde staat, zelfs als u het meer dan eens aanroept, op voorwaarde dat u dezelfde parameters doorgeeft.
Antwoord 6, autoriteit 2%
Een goed voorbeeld van het begrijpen van een idempotent-operatie is het vergrendelen van een auto met een afstandsbediening.
log(Car.state) // unlocked
Remote.lock();
log(Car.state) // locked
Remote.lock();
Remote.lock();
Remote.lock();
log(Car.state) // locked
lockis een idempotent-bewerking. Zelfs als er een neveneffect is elke keer dat u lockuitvoert, zoals knipperen, is de auto nog steeds in dezelfde vergrendelde staat, ongeacht hoe vaak u de lock-bewerking uitvoert.
Antwoord 7, autoriteit 2%
Ik wilde gewoon een echte use-case weggooien die idempotentie aantoont. Stel dat u in JavaScript een aantal modelklassen definieert (zoals in het MVC-model). De manier waarop dit vaak wordt geïmplementeerd is functioneel equivalent aan iets als dit (basisvoorbeeld):
function model(name) {
function Model() {
this.name = name;
}
return Model;
}
Je zou dan nieuwe klassen als volgt kunnen definiëren:
var User = model('user');
var Article = model('article');
Maar als je zou proberen om de klasse Uservia model('user')ergens anders in de code te krijgen, zou het mislukken:
var User = model('user');
// ... then somewhere else in the code (in a different scope)
var User = model('user');
Die twee Userconstructors zouden anders zijn. Dat wil zeggen,
model('user') !== model('user');
Om het idempotentte maken, zou je gewoon een soort caching-mechanisme toevoegen, zoals dit:
var collection = {};
function model(name) {
if (collection[name])
return collection[name];
function Model() {
this.name = name;
}
collection[name] = Model;
return Model;
}
Door caching toe te voegen, zal elke keer dat je model('user')deed hetzelfde object zijn, en dus idempotent. Dus:
model('user') === model('user');
Antwoord 8
Een idempotent-bewerking is een bewerking, actie of verzoek die meerdere keren kan worden toegepast zonder het resultaat, d.w.z. de status van het systeem, te wijzigen na de eerste toepassing.
VOORBEELDEN (WEB-APP CONTEXT):
IDEMPOTENT:
Het maken van meerdere identieke verzoeken heeft hetzelfde effect als het doen van een enkel verzoek. Een bericht in een e-mailsysteem wordt geopend en gemarkeerd als “geopend” in de database. Men kan het bericht vele malen openen, maar deze herhaalde actie zal er alleen maar toe leiden dat dat bericht in de “geopende” staat is. Dit is een idempotente operatie. De eerste keer dat men een update naar een bron PUT met informatie die niet overeenkomt met de bron (de status van het systeem), zal de status van het systeem veranderen als de bron wordt bijgewerkt. Als men herhaaldelijk dezelfde update naar een bron PUT zal de informatie in de update overeenkomen met de informatie die al in het systeem aanwezig is bij elke PUT, en zal er geen verandering in de toestand van het systeem plaatsvinden. Herhaalde PUT’s met dezelfde informatie zijn idempotent: de eerste PUT kan de status van het systeem veranderen, volgende PUT’s niet.
NIET-IDEMPOTENT:
Als een bewerking altijd een statusverandering veroorzaakt, zoals het keer op keer POST van hetzelfde bericht naar een gebruiker, wat resulteert in een nieuw bericht dat elke keer wordt verzonden en opgeslagen in de database, zeggen we dat de bewerking NIET-IDEMPOTENT is.
NULLIPPOTENT:
Als een operatie geen neveneffecten heeft, zoals het puur weergeven van informatie op een webpagina zonder enige verandering in een database (met andere woorden, je leest alleen de database), zeggen we dat de operatie NULLIPOTENT is. Alle GET’s moeten nullipotent zijn.
Als we het hebben over de toestand van het systeem, negeren we uiteraard hopelijk onschadelijke en onvermijdelijke effecten zoals logboekregistratie en diagnostiek.
Antwoord 9
Vrij gedetailleerde en technische antwoorden. Gewoon een simpele definitie toevoegen.
Idempotent = Opnieuw uit te voeren
Bijvoorbeeld,
De bewerking Createop zich wordt niet gegarandeerd foutloos uitgevoerd als deze meer dan eens wordt uitgevoerd.
Maar als er een bewerking CreateOrUpdateis, dan geeft deze de mogelijkheid om opnieuw uit te voeren (Idempotency).
Antwoord 10
Idempotente bewerkingen:bewerkingen die geen bijwerkingen hebben als ze meerdere keren worden uitgevoerd.
Voorbeeld: een bewerking die waarden ophaalt uit een gegevensbron en deze bijvoorbeeld afdrukt
Niet-idempotente bewerkingen:bewerkingen die enige schade zouden veroorzaken als ze meerdere keren worden uitgevoerd. (Omdat ze sommige waarden of toestanden veranderen)
Voorbeeld:een handeling die geld opneemt van een bankrekening
Antwoord 11
Het is elke bewerking waarbij elk nde resultaat resulteert in een uitvoer die overeenkomt met de waarde van het 1e resultaat. De absolute waarde van -1 is bijvoorbeeld 1. De absolute waarde van de absolute waarde van -1 is 1. De absolute waarde van de absolute waarde van de absolute waarde van -1 is 1. En zo verder.
Zie ook: Wanneer zou een echt gekke tijd zijn om recursie te gebruiken?
Antwoord 12
Een idempotente bewerking over een set laat de leden ervan ongewijzigd wanneer ze een of meer keren worden toegepast.
Het kan een unaire bewerking zijn zoals absolute(x)waarbij x behoort tot een set positieve gehele getallen. Hier absoluut(absoluut(x)) = x.
Het kan een binaire bewerking zijn, zoals eenheid van een set met zichzelfaltijd dezelfde set zou retourneren.
proost
Antwoord 13
Kortombetekent Idempotent-bewerkingen dat de bewerking niet tot verschillende resultaten leidt, ongeacht hoe vaak u de idempotent-bewerkingen uitvoert.
Bijvoorbeeld, volgens de definitie van de specificatie van HTTP, zijn GET, HEAD, PUT, and DELETEidempotente bewerkingen; echter POST and PATCHzijn dat niet. Daarom wordt soms POSTvervangen door PUT.
Antwoord 14
mijn 5c:
Bij integratie en netwerken is de idempotentie erg belangrijk.
Enkele voorbeelden uit de praktijk:
Stel je voor, we leveren data aan het doelsysteem. Gegevens geleverd door een reeks berichten.
1. Wat zou er gebeuren als de sequentie in het kanaal wordt gemixt? (Zoals netwerkpakketten altijd doen 🙂 ). Als het doelsysteem idempotent is, zal het resultaat niet anders zijn. Als het doelsysteem afhankelijk is van de juiste volgorde in de reeks, moeten we een resequencer op de doelsite implementeren, die de juiste volgorde zou herstellen.
2. Wat zou er gebeuren als er dubbele berichten zijn? Als het kanaal van het doelsysteem niet tijdig bevestigt, stuurt het bronsysteem (of het kanaal zelf) meestal nog een kopie van het bericht. Als gevolg hiervan kunnen we een dubbel bericht hebben aan de kant van het doelsysteem.
Als het doelsysteem idempotent is, zorgt het ervoor en het resultaat zal niet anders zijn.
Als het doelsysteem niet idempotent is, moeten we deduplicator implementeren aan de kant van het doelsysteem van het kanaal.
Antwoord 15
veilig opnieuw.
Is meestal de gemakkelijkste manier om de betekenis ervan in de informatica te begrijpen.