Dies ist eine alte Frage, aber ich werde sie trotzdem hier posten. Ich habe mehr als 20 Jahre Erfahrung in der Programmierung und im Umgang mit dem Code anderer Leute.
Ich denke, dass die Benennung Ihrer Variablen mit einem kurzen Hinweis auf deren Gültigkeitsbereich für die nächste Person (oder für Sie selbst), die sich Ihren Code ansieht, wirklich sehr nützlich ist.
Man sieht sich Code in einer IDE mit hübschen Farben noch nicht an (und ich kann mich nicht erinnern, was die Farben bedeuten, und verschiedene IDE zeigen verschiedene Farben usw.).
Richtig, Methoden sollten kurz genug sein, damit sie nicht mit Tonnen von Variablen und Tonnen von Code geladen werden, sondern sogar mit einer kurzen - wenn Sie sich Code ansehen, der völlig ungewohnt ist, ist es manchmal schwierig zu sagen, ob eine Variable eine Klassenvariable ist, lokal Variable oder Methodenparameter.
Um auf einen Blick unterscheiden zu können, ist es sehr einfach, den Code zu überprüfen, mit dem Sie nicht vertraut sind.
Nehmen Sie dieses Beispiel:
public <T> Page<T> moreLikeThis(MoreLikeThisQuery query, Class<T> clazz) {
int startRecord = 0;
ElasticsearchPersistentEntity persistentEntity = getPersistentEntityFor(clazz);
String indexName = isNotBlank(query.getIndexName()) ? query.getIndexName() : persistentEntity.getIndexName();
String type = isNotBlank(query.getType()) ? query.getType() : persistentEntity.getIndexType();
Assert.notNull(indexName, "No 'indexName' defined for MoreLikeThisQuery");
Assert.notNull(type, "No 'type' defined for MoreLikeThisQuery");
Assert.notNull(query.getId(), "No document id defined for MoreLikeThisQuery");
MoreLikeThisRequestBuilder requestBuilder = client.prepareMoreLikeThis(indexName, type, query.getId());
if (query.getPageable() != null) {
startRecord = query.getPageable().getPageNumber() * query.getPageable().getPageSize();
requestBuilder.setSearchSize(query.getPageable().getPageSize());
}
requestBuilder.setSearchFrom(startRecord);
if (isNotEmpty(query.getSearchIndices())) {
requestBuilder.setSearchIndices(toArray(query.getSearchIndices()));
}
if (isNotEmpty(query.getSearchTypes())) {
requestBuilder.setSearchTypes(toArray(query.getSearchTypes()));
}
if (isNotEmpty(query.getFields())) {
requestBuilder.setField(toArray(query.getFields()));
}
if (isNotBlank(query.getRouting())) {
requestBuilder.setRouting(query.getRouting());
}
if (query.getPercentTermsToMatch() != null) {
requestBuilder.setPercentTermsToMatch(query.getPercentTermsToMatch());
}
if (query.getMinTermFreq() != null) {
requestBuilder.setMinTermFreq(query.getMinTermFreq());
}
if (query.getMaxQueryTerms() != null) {
requestBuilder.maxQueryTerms(query.getMaxQueryTerms());
}
if (isNotEmpty(query.getStopWords())) {
requestBuilder.setStopWords(toArray(query.getStopWords()));
}
if (query.getMinDocFreq() != null) {
requestBuilder.setMinDocFreq(query.getMinDocFreq());
}
if (query.getMaxDocFreq() != null) {
requestBuilder.setMaxDocFreq(query.getMaxDocFreq());
}
if (query.getMinWordLen() != null) {
requestBuilder.setMinWordLen(query.getMinWordLen());
}
if (query.getMaxWordLen() != null) {
requestBuilder.setMaxWordLen(query.getMaxWordLen());
}
if (query.getBoostTerms() != null) {
requestBuilder.setBoostTerms(query.getBoostTerms());
}
SearchResponse response = requestBuilder.execute().actionGet();
return resultsMapper.mapResults(response, clazz, query.getPageable());
}
Nehmen Sie sich jetzt die Zeit und schauen Sie sich den Code an (extrahiert aus ElasticsearchTemplate aus dem Projekt spring-data-elasticsearch - der Code, den ich gerade durchgesehen habe und der mich dazu veranlasste, in Google nach den Aussagen zu Namenskonventionen zu suchen).
- Was ist der Scode von
resultsMapper?
- Ist
requestBuildingein Parameter?
- etc...
Hier ist mein einfacher Vorschlag, wie Variablen benannt werden sollten:
- Statische Klassenattribute (dh Konstanten): ALL_CAPS_WITH_UNDERSCORES (zB
HOST_NAME).
- Klassenattribute (dh Klasseninstanzvariablen): camelCase (zB
resultsMapper).
- Verfahrensparameter: mit dem Präfix
a(z aQuery, aClazz).
- Lokale Variablen: mit dem Präfix
my(zB myIndexName, myType).
Der obige Code wird:
public <T> Page<T> moreLikeThis(MoreLikeThisQuery aQuery, Class<T> aClazz) {
int myStartRecord = 0;
ElasticsearchPersistentEntity myPersistentEntity = getPersistentEntityFor(aClazz);
String myIndexName = isNotBlank(aQuery.getIndexName()) ? aQuery.getIndexName() : myPersistentEntity.getIndexName();
String myType = isNotBlank(aQuery.getType()) ? aQuery.getType() : myPersistentEntity.getIndexType();
Assert.notNull(myIndexName, "No 'indexName' defined for MoreLikeThisQuery");
Assert.notNull(myType, "No 'type' defined for MoreLikeThisQuery");
Assert.notNull(aQuery.getId(), "No document id defined for MoreLikeThisQuery");
MoreLikeThisRequestBuilder myRequestBuilder = client.prepareMoreLikeThis(myIndexName, myType, aQuery.getId());
if (aQuery.getPageable() != null) {
myStartRecord = aQuery.getPageable().getPageNumber() * aQuery.getPageable().getPageSize();
myRequestBuilder.setSearchSize(aQuery.getPageable().getPageSize());
}
myRequestBuilder.setSearchFrom(myStartRecord);
if (isNotEmpty(aQuery.getSearchIndices())) {
myRequestBuilder.setSearchIndices(toArray(aQuery.getSearchIndices()));
}
if (isNotEmpty(aQuery.getSearchTypes())) {
myRequestBuilder.setSearchTypes(toArray(aQuery.getSearchTypes()));
}
if (isNotEmpty(aQuery.getFields())) {
myRequestBuilder.setField(toArray(aQuery.getFields()));
}
if (isNotBlank(aQuery.getRouting())) {
myRequestBuilder.setRouting(aQuery.getRouting());
}
if (aQuery.getPercentTermsToMatch() != null) {
myRequestBuilder.setPercentTermsToMatch(aQuery.getPercentTermsToMatch());
}
if (aQuery.getMinTermFreq() != null) {
myRequestBuilder.setMinTermFreq(aQuery.getMinTermFreq());
}
if (aQuery.getMaxQueryTerms() != null) {
myRequestBuilder.maxQueryTerms(aQuery.getMaxQueryTerms());
}
if (isNotEmpty(aQuery.getStopWords())) {
myRequestBuilder.setStopWords(toArray(aQuery.getStopWords()));
}
if (aQuery.getMinDocFreq() != null) {
myRequestBuilder.setMinDocFreq(aQuery.getMinDocFreq());
}
if (aQuery.getMaxDocFreq() != null) {
myRequestBuilder.setMaxDocFreq(aQuery.getMaxDocFreq());
}
if (aQuery.getMinWordLen() != null) {
myRequestBuilder.setMinWordLen(aQuery.getMinWordLen());
}
if (aQuery.getMaxWordLen() != null) {
myRequestBuilder.setMaxWordLen(aQuery.getMaxWordLen());
}
if (aQuery.getBoostTerms() != null) {
myRequestBuilder.setBoostTerms(aQuery.getBoostTerms());
}
SearchResponse myResponse = myRequestBuilder.execute().actionGet();
return resultsMapper.mapResults(myResponse, aClazz, aQuery.getPageable());
}
Ist das perfekt Ich glaube nicht. Was die Variablen betrifft, ist das oben Gesagte jetzt einfacher zu lesen. Es gibt andere Dinge wie Ausrichtung und Abstand, auf die ich in dieser Antwort nicht eingehen werde, da es sich nicht um die Frage handelt, die auch das Lesen erleichtern würde.
Du magst Camel Case nicht? Gut, verwenden Sie Unterstriche usw., aber stellen Sie Ihren lokalen Variablen und Ihren Parametern ein Präfix voran, damit sie sich von den Klasseninstanzvariablen unterscheiden.
Sie mögen aund my- gut, bleiben Sie einfach in Ihrem Projekt konsistent und verwenden Sie etwas anderes ... aber verwenden Sie etwas.
Regel 1: Konsistenz innerhalb des Projekts.
Regel 2: Erleichtern Sie das Lesen und fordern Sie den Leser nicht auf, alles zu wissen, bevor er lernen kann.