Che cos'è un'operazione idempotente?

Che cos'è un'operazione idempotente?

Nell'informatica, un'operazione idempotente è un'operazione che non ha alcun effetto aggiuntivo se viene chiamata più volte con gli stessi parametri di input. Ad esempio, la rimozione di un elemento da un set può essere considerata un'operazione idempotente sul set.

In matematica, un'operazione idempotente è quella in cui f (f (x)) = f (x) . Ad esempio, la abs()funzione è idempotente perché abs(abs(x)) = abs(x)per tutti x.

Queste definizioni leggermente diverse possono essere riconciliate considerando che x nella definizione matematica rappresenta lo stato di un oggetto e f è un'operazione che può mutare quell'oggetto. Ad esempio, considera Pythonset e il suo discardmetodo. Il discardmetodo rimuove un elemento da un set e non fa nulla se l'elemento non esiste. Così:

my_set.discard(x)

ha esattamente lo stesso effetto di fare due volte la stessa operazione:

my_set.discard(x)
my_set.discard(x)

Le operazioni idempotenti sono spesso utilizzate nella progettazione di protocolli di rete, in cui è garantito che una richiesta di eseguire un'operazione accada almeno una volta, ma potrebbe anche accadere più di una volta. Se l'operazione è idempotente, non vi è alcun danno nell'esecuzione dell'operazione due o più volte.

Vedi l'articolo di Wikipedia sull'idempotenza per ulteriori informazioni.

^{La risposta di cui sopra aveva in precedenza alcuni esempi errati e fuorvianti. I commenti di seguito scritti prima di aprile 2014 fanno riferimento a una revisione precedente.}

Un'operazione idempotente può essere ripetuta un numero arbitrario di volte e il risultato sarà lo stesso di se fosse stato fatto solo una volta. In aritmetica, l'aggiunta di zero a un numero è idempotente.

L'idempotenza è molto discussa nel contesto dei servizi web "RESTful". REST cerca di sfruttare al massimo l'HTTP per fornire ai programmi l'accesso al contenuto Web e di solito è impostato in contrasto con i servizi Web basati su SOAP, che effettuano semplicemente il tunneling di servizi di stile di chiamata di procedura remota all'interno di richieste e risposte HTTP.

REST organizza un'applicazione Web in "risorse" (come un utente Twitter o un'immagine Flickr) e quindi utilizza i verbi HTTP POST, PUT, GET e DELETE per creare, aggiornare, leggere ed eliminare tali risorse.

L'idempotenza svolge un ruolo importante nel REST. Se OTTIENI una rappresentazione di una risorsa REST (ad esempio, OTTIENI un'immagine jpeg da Flickr) e l'operazione non riesce, puoi semplicemente ripetere GET ancora e ancora fino a quando l'operazione non riesce. Per il servizio Web, non importa quante volte l'immagine viene ottenuta. Allo stesso modo, se si utilizza un servizio Web RESTful per aggiornare le informazioni del proprio account Twitter, è possibile INSERIRE le nuove informazioni tutte le volte che è necessario per ottenere la conferma dal servizio web. Metterlo mille volte è lo stesso di Metterlo una volta. Allo stesso modo ELIMINARE una risorsa REST mille volte equivale a eliminarla una volta. L'idempotenza rende quindi molto più semplice la costruzione di un servizio Web resiliente agli errori di comunicazione.

Ulteriori letture: RESTful Web Services , di Richardson e Ruby (l'idempotenza è discussa a pagina 103-104) e la tesi di dottorato di Roy Fielding su REST . Fielding è stato uno degli autori di HTTP 1.1, RFC-2616, che parla di idempotenza nella sezione 9.1.2 .

Non importa quante volte si chiama l'operazione, il risultato sarà lo stesso.

Idempotenza significa che applicare una volta un'operazione o applicarla più volte ha lo stesso effetto.

Esempi:

• Moltiplicazione per zero. Non importa quante volte lo fai, il risultato è ancora zero.
• Impostazione di una bandiera booleana. Non importa quante volte lo fai, la bandiera rimane impostata.
• Eliminazione di una riga da un database con un determinato ID. Se lo riprovi, la riga è ancora andata.

Per le funzioni pure (funzioni senza effetti collaterali) allora l'idempotenza implica che f (x) = f (f (x)) = f (f (f (x))) = f (f (f (f (x ()))) ) = ...... per tutti i valori di x

Per le funzioni con effetti collaterali , l'idempotenza implica inoltre che non saranno causati ulteriori effetti collaterali dopo la prima applicazione. Se lo desideri, puoi considerare lo stato del mondo come un parametro "nascosto" aggiuntivo alla funzione.

Si noti che in un mondo in cui sono in corso azioni simultanee, è possibile che le operazioni ritenute idempotenti cessino di esserlo (ad esempio, un altro thread potrebbe annullare il valore della bandiera booleana nell'esempio sopra). Fondamentalmente ogni volta che si ha la concorrenza e lo stato mutevole, è necessario riflettere molto più attentamente sull'idempotenza.

L'idempotenza è spesso una proprietà utile nella costruzione di sistemi robusti. Ad esempio, se esiste il rischio che tu possa ricevere un messaggio duplicato da una terza parte, è utile che il gestore messaggi agisca come un'operazione idempotente in modo che l'effetto del messaggio si verifichi una sola volta.

Un'operazione idempotente produce il risultato nello stesso stato anche se lo chiami più di una volta, a condizione che passi gli stessi parametri.

Volevo solo lanciare un caso d'uso reale che dimostra idempotenza. In JavaScript, supponi di definire un gruppo di classi di modelli (come nel modello MVC). Il modo in cui questo viene spesso implementato è funzionalmente equivalente a qualcosa del genere (esempio di base):

function model(name) {
  function Model() {
    this.name = name;
  }

  return Model;
}

È quindi possibile definire nuove classi come questa:

var User = model('user');
var Article = model('article');

Ma se dovessi provare a ottenere la Userclasse tramite model('user'), da qualche altra parte del codice, fallirebbe:

var User = model('user');
// ... then somewhere else in the code (in a different scope)
var User = model('user');

Quei due Usercostruttori sarebbero diversi. Questo è,

model('user') !== model('user');

Per renderlo idempotente , è sufficiente aggiungere una sorta di meccanismo di memorizzazione nella cache, come questo:

var collection = {};

function model(name) {
  if (collection[name])
    return collection[name];

  function Model() {
    this.name = name;
  }

  collection[name] = Model;
  return Model;
}

Aggiungendo la cache, ogni volta che lo fai model('user')sarà lo stesso oggetto, quindi è idempotente. Così:

model('user') === model('user');

Un'operazione idempotente è un'operazione, un'azione o una richiesta che può essere applicata più volte senza modificare il risultato, ovvero lo stato del sistema, oltre l'applicazione iniziale.

ESEMPI (CONTESTO DELL'APP WEB):

IDEMPOTENT: l'esecuzione di più richieste identiche ha lo stesso effetto di una singola richiesta. Un messaggio in un sistema di messaggistica e-mail viene aperto e contrassegnato come "aperto" nel database. Si può aprire il messaggio molte volte, ma questa azione ripetuta comporterà sempre e solo quel messaggio nello stato "aperto". Questa è un'operazione idempotente. La prima volta che si METTE un aggiornamento a una risorsa utilizzando informazioni che non corrispondono alla risorsa (lo stato del sistema), lo stato del sistema cambierà man mano che la risorsa viene aggiornata. Se uno PUT invia ripetutamente lo stesso aggiornamento a una risorsa, le informazioni nell'aggiornamento corrisponderanno alle informazioni già presenti nel sistema ad ogni PUT e non si verificherà alcuna modifica allo stato del sistema. I PUT ripetuti con le stesse informazioni sono idempotenti:

NON IDEMPOTENTE: se un'operazione provoca sempre un cambiamento di stato, ad esempio POST inviando ripetutamente lo stesso messaggio a un utente, risultando in un nuovo messaggio inviato e archiviato nel database ogni volta, si dice che l'operazione è NON IDEMPOTENTE.

NULLIPOTENT: se un'operazione non ha effetti collaterali, come la semplice visualizzazione di informazioni su una pagina Web senza alcuna modifica in un database (in altre parole si sta solo leggendo il database), si dice che l'operazione è NULLIPOTENT. Tutti i GET dovrebbero essere nullipotent.

Quando parliamo dello stato del sistema, stiamo ovviamente ignorando gli effetti sperabilmente innocui e inevitabili come la registrazione e la diagnostica.

Operazioni idempotenti: operazioni che non hanno effetti collaterali se eseguite più volte.
Esempio : un'operazione che recupera i valori da una risorsa dati e dice, la stampa

Operazioni non idempotenti: operazioni che potrebbero causare danni se eseguite più volte. (Mentre cambiano alcuni valori o stati)
Esempio: un'operazione che si ritira da un conto bancario

Piuttosto una risposta dettagliata e tecnica. Basta aggiungere una semplice definizione.

Idempotent = Ri-eseguibile

Ad esempio, l' Createoperazione in sé non è garantita per l'esecuzione senza errori se eseguita più di una volta. Ma se c'è un'operazione, CreateOrUpdateallora indica la rieseguibilità (Idempotency).

Un'operazione idempotente su un set lascia invariati i suoi membri quando viene applicata una o più volte.

Può essere un'operazione unaria come assoluta (x) in cui x appartiene a un insieme di numeri interi positivi. Qui assoluto (assoluto (x)) = x.

Può essere un'operazione binaria come l' unione di un set con se stesso restituirebbe sempre lo stesso set.

Saluti

È qualsiasi operazione che ogni ennesimo risultato comporterà un'uscita corrispondente al valore del primo risultato. Ad esempio, il valore assoluto di -1 è 1. Il valore assoluto del valore assoluto di -1 è 1. Il valore assoluto del valore assoluto di valore assoluto di -1 è 1. E così via.

Vedi anche: Quando sarebbe un momento davvero sciocco usare la ricorsione?

Un buon esempio di comprensione di un'operazione idempotente potrebbe essere il blocco di un'auto con chiave remota.

log(Car.state) // unlocked

Remote.lock();
log(Car.state) // locked

Remote.lock();
Remote.lock();
Remote.lock();
log(Car.state) // locked

lockè un'operazione idempotente. Anche se ci sono degli effetti collaterali ogni volta che corri lock, come battere le palpebre, l'auto è ancora nello stesso stato di blocco, indipendentemente da quante volte esegui l'operazione di blocco.

my 5c: In integrazione e networking l'idempotenza è molto importante. Diversi esempi dalla vita reale: immagina di fornire dati al sistema di destinazione. Dati forniti da una sequenza di messaggi. 1. Cosa succederebbe se la sequenza fosse mista nel canale? (Come sempre fanno i pacchetti di rete :)). Se il sistema di destinazione è idempotente, il risultato non sarà diverso. Se il sistema target dipende dal giusto ordine nella sequenza, dobbiamo implementare resequencer sul sito target, che ripristinerebbe il giusto ordine. 2. Cosa accadrebbe se ci fossero duplicati del messaggio? Se il canale del sistema di destinazione non riconosce tempestivamente, il sistema di origine (o il canale stesso) di solito invia un'altra copia del messaggio. Di conseguenza possiamo avere un messaggio duplicato sul lato del sistema di destinazione. Se il sistema di destinazione è idempotente, se ne prende cura e il risultato non sarà diverso. Se il sistema di destinazione non è idempotente, dobbiamo implementare il deduplicatore sul lato del sistema di destinazione del canale.

In breve , Operazioni idempotenti significa che l'operazione non produrrà risultati diversi, indipendentemente da quante volte si eseguono le operazioni idempotenti.

Ad esempio, secondo la definizione della specifica di HTTP, GET, HEAD, PUT, and DELETEsono operazioni idempotenti; tuttavia POST and PATCHnon lo sono. Ecco perché a volte POSTviene sostituito da PUT.

tentativi di sicurezza.

Di solito è il modo più semplice per comprenderne il significato nell'informatica.