To stare pytanie, ale i tak zamierzam tutaj napisać. Mam ponad 20 lat programowania i radzenia sobie z kodem innych osób.
Myślę, że nazywanie twojej zmiennej krótkim wskazaniem co do jej zakresu jest naprawdę przydatne dla następnej osoby (lub ciebie), która spojrzy na twój kod.
Jeszcze nie patrzy się na kod w IDE z ładnymi kolorami (i nie pamiętam, co oznaczają kolory, a różne IDE pokazują różne kolory itp.).
To prawda, że metody powinny być wystarczająco krótkie, aby nie było załadowane tonami zmiennych i tonami kodu, ale nawet na jednym krótkim - kiedy spojrzysz na kod, który jest zupełnie nieznany, czasami trudno jest stwierdzić, czy zmienna jest zmienną klasową, lokalną zmienna lub parametr metody.
Umiejętność odróżnienia na pierwszy rzut oka ułatwia zapoznanie się z nieznanym kodem.
Weź ten przykład:
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());
}
Teraz czas i spójrz na kod (wyodrębniony z ElasticsearchTemplate z projektu spring-data-elasticsearch - kod, który sprawdzałem, co skłoniło mnie do wyszukiwania w Google tego, co ludzie mówią o konwencjach nazewnictwa).
- Jaki jest tryb
resultsMapper?
- Czy
requestBuildingparametr?
- itp...
Oto moja prosta sugestia, jak należy nazywać zmienne:
- Atrybuty statyczne klasy (tj. Stałe): ALL_CAPS_WITH_UNDERSCORES (np
HOST_NAME.).
- Atrybuty klas (tj. Zmienne instancji klasy): camelCase (np
resultsMapper.).
- Parametry metody: prefiksem
a(np aQuery, aClazz).
- Zmienne lokalne: prefiksem
my(np myIndexName, myType).
Powyższy kod staje się:
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());
}
Czy to jest idealne? Nie wydaje mi się Ale powyższe, jeśli chodzi o zmienne, jest teraz łatwiejsze do odczytania. Są inne rzeczy, takie jak wyrównanie i odstępy, do których nie wchodzę w tę odpowiedź, ponieważ nie jest to związane z pytaniem, co ułatwiłoby również czytanie.
Nie lubisz Camel Case? Dobrze, użyj podkreślników itp., Ale poprzedź lokalne zmienne i parametry, aby różniły się od zmiennych instancji klasy.
Nie lubisz ai my- dobrze, po prostu bądź konsekwentny w swoim projekcie i używaj czegoś innego ... ale używaj czegoś.
Zasada nr 1: spójność w ramach projektu.
Zasada nr 2: ułatw czytanie i nie wymagaj od czytelnika, aby wiedział wszystko, zanim będzie mógł się uczyć.