Come e perché decidere tra i metodi di denominazione con i prefissi "get" e "find"

Ho sempre difficoltà a capire se devo citare un certo metodo inizia con getSomethingrispetto findSomething.

Il problema risiede nella creazione di helper per API mal progettate. Questo di solito si verifica quando si ottengono dati da un oggetto, che richiede l'oggetto come parametro. Qui c'è un semplice esempio:

public String getRevision(Item item) {
    service.load(item, "revision");
    // there is usually more work to do before getting the data..
    try {
        return item.get_revision();
    }
    catch(NotLoadedException exception) {
        log.error("Property named 'property_name' was not loaded", exception);
    }
    return null;
}

Come e perché decidere tra denominazione questo metodo come getRevision()o findRevision()?

Uso Getquando so che il tempo di recupero sarà molto breve (come in una ricerca da una tabella hash o btree).

Findimplica un processo di ricerca o un algoritmo computazionale che richiede un periodo di tempo "più lungo" per l'esecuzione (per un valore arbitrario di più lungo).

Direi che findpotrebbe fallire ma getnon dovrebbe.

Per citare una conversazione che ho spesso con i miei figli:

io: Ehi ragazzo! Vai a cercarmi delle batterie

bambino: ma dove sono?

me: è per questo che ho detto di andare a trovare loro. Se avessi saputo dove fossero, ti avrei detto di andare a prenderli . Oppure potresti chiedere a tua madre.

La stessa idea vale:

• usa "get" per un metodo che restituisce un'informazione a basso costo disponibile (e che probabilmente può essere incorporata o altrimenti ottimizzata) o per un'informazione posseduta in modo univoco da questo oggetto.

• usa "trova" per un metodo che funziona per ottenere un'informazione o usa altri oggetti per trovarla.

Trovare implica che non si ottengono risultati, ad esempio quando si esegue una query del database con alcuni parametri che possono cambiare tra le chiamate. Get, d'altra parte, implica che i risultati siano noti al metodo in anticipo o non cambieranno una volta noti, che non ci sono parametri per la chiamata.
Quindi, utilizzerei ad esempio Customer findCustomerById (long customerId) e Customer getCustomer ()

Applico il seguente modello:

• Foo GetFoo() non può restituire null e la sua complessità è O (log (n)) o inferiore
• bool TryGetFoo(out Foo) può restituire null e la sua complessità è O (log (n)) o inferiore
• Foo FindFoo() non può restituire null e la sua complessità è maggiore di O (log (n))
• bool TryFindFoo(out Foo) può restituire null e la sua complessità è maggiore di O (log (n))

In questo modo il codice è abbastanza chiaro sull'intento e sulla complessità che ci si può aspettare.

In genere, i Getter sono per l'elenco diretto o l'accesso a dizionario / set.
I Finder sono ricerca approfondita, scansione completa dell'elenco, ecc ...

Nel tuo caso:

public bool TryGetRevision( Item item, out String revision ) 
{
    service.load( item, "revision" );
    // there is usually more work to do before getting the data..
    try 
    {
        revision = item.get_revision();
        return true;
    }
    catch( NotLoadedException exception )
    {
        log.error( "Property named 'property_name' was not loaded", exception );
        revision = "";
        return false;
    }
}

getè appropriato in ogni caso _ infatti si presume spesso che per ottenere qualcosa sia necessario prima trovarlo. Quindi, se non sei sicuro, usa get.

Vorrei utilizzare findmetodi come findMinimum()o findOptimal(), ad esempio, dove esiste un algoritmo speciale che calcola il valore restituito e non fa semplicemente una richiesta al DB, al file system, al server remoto, ecc. Per ricevere alcuni dati.

Non utilizzare trova o ottieni prefissi. Questa è una violazione di UniformAccessPrinciple coniata da Bertrand Meyer . Perché non creare un metodo come il seguente:

public String revision(Item item)

Generalmente userò Getper recuperare un oggetto / valore e Findper recuperare la sua posizione (in un array, ad esempio).

per esempio:

object o = obj.GetItem( 'name');

integer i = somearray.Find( 'name');

Per me, findimplica che potrebbe esserci più di un risultato presente. getimplica solo uno.