Cómo y por qué decidir entre los métodos de nomenclatura con los prefijos "get" y "find"

Siempre tengo problemas para determinar si debo nombrar un cierto método comenzando con getSomethingversus findSomething.

El problema reside en crear ayudantes para API mal diseñadas. Esto generalmente ocurre cuando se obtienen datos de un objeto, que requiere el objeto como parámetro. Aquí hay un ejemplo simple:

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;
}

¿Cómo y por qué decidir entre nombrar este método como getRevision()o findRevision()?

Lo uso Getcuando sé que el tiempo de recuperación será muy corto (como en una búsqueda de una tabla hash o btree).

Findimplica un proceso de búsqueda o algoritmo computacional que requiere un período de tiempo "más largo" para ejecutarse (por algún valor arbitrario de más tiempo).

Yo diría que findpuede fallar pero getno debería.

Para citar una conversación que a menudo tengo con mis hijos:

Yo: Hola chico! Ve a buscarme algunas baterías

niño: ¿ Pero dónde están?

Yo: Por eso te dije que fueras a buscarlos . Si supiera dónde están, te habría dicho que fueras a buscarlos . O podrías preguntarle a tu madre.

La misma idea es válida:

• use "get" para un método que devuelva una información disponible a bajo precio (y que probablemente pueda ser incorporada o de otra forma optimizada), o para una información de propiedad exclusiva de este objeto.

• use "find" para un método que funcione para obtener información, o use otros objetos para encontrarla.

Buscar implica no tener el resultado, como cuando se ejecuta una consulta de base de datos con algunos parámetros que pueden cambiar entre llamadas. Obtener, por otro lado, implica que los resultados son conocidos por el método de antemano o que no cambiarán una vez conocidos, que no hay parámetros para la llamada.
Entonces, usaría, por ejemplo, Customer findCustomerById (long customerId) y Customer getCustomer ()

Aplico el siguiente patrón:

• Foo GetFoo() no puede devolver nulo y su complejidad es O (log (n)) o menos
• bool TryGetFoo(out Foo) puede devolver nulo y su complejidad es O (log (n)) o menos
• Foo FindFoo() no puede devolver nulo y su complejidad es más que O (log (n))
• bool TryFindFoo(out Foo) puede devolver nulo y su complejidad es más que O (log (n))

De esa manera, el código es bastante claro sobre la intención y la complejidad que puede esperar.

Por lo general, los Getters son para acceso directo a listas o diccionarios / conjuntos.
Los buscadores son búsqueda profunda, escaneo completo de la lista, etc.

En tu 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;
    }
}

getes apropiado en cualquier caso _ de hecho, a menudo se supone que para obtener algo, primero debe encontrarlo. Entonces, si no estás seguro, úsalo get.

Lo usaría findpara métodos como findMinimum()o findOptimal(), es decir, donde hay algún algoritmo especial que calcula el valor de retorno, y no simplemente hace una solicitud al DB, sistema de archivos, servidor remoto, etc. para recibir algunos datos.

No use buscar u obtener prefijos. Esto es una violación de UniformAccessPrinciple acuñado por bertrand meyer. ¿Por qué no crear un método como el siguiente?

public String revision(Item item)

Generalmente lo usaré Getpara recuperar un objeto / valor, y Findpara recuperar su ubicación (en una matriz, por ejemplo).

por ejemplo:

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

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

Para mí, findimplica que posiblemente puede haber más de un resultado presente. getimplica solo uno.