Uma coisa a notar é que o código é lido com freqüência, para diferentes "profundidades". Este código:
PowerManager powerManager = (PowerManager)getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "abc");
wakeLock.acquire();
é fácil de "skim". São 3 declarações. Primeiro, chegamos a um PowerManager
. Então chegamos a um WakeLock
. Então nós acquire
the wakeLock
. Eu posso ver isso muito facilmente apenas olhando para o início de cada linha; Atribuições de variáveis simples são realmente fáceis de reconhecer parcialmente como "Digite varName = ..." e apenas mentalmente passe o "...". Da mesma forma, a última afirmação obviamente não é a forma da atribuição, mas envolve apenas dois nomes, portanto a "essência principal" é imediatamente aparente. Muitas vezes é tudo o que eu preciso saber se eu estava apenas tentando responder "o que esse código faz?" em um nível altíssimo.
Se eu estou perseguindo um bug sutil que acho que está aqui, então, obviamente, eu precisarei passar por isso com muito mais detalhes, e realmente me lembrarei dos "..." s. Mas a estrutura de instruções separada ainda me ajuda a fazer essa declaração de cada vez (especialmente útil se eu precisar ir mais fundo na implementação das coisas que estão sendo chamadas em cada declaração; quando eu voltar, eu entendi completamente "uma unidade" e pode então passar para a próxima declaração).
((PowerManager)getSystemService(POWER_SERVICE))
.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyWakelockTag")
.acquire();
Agora é tudo uma declaração. A estrutura de nível superior não é tão fácil de ler; na versão original do OP, sem quebra de linha e recuo para comunicar visualmente qualquer estrutura, eu teria que contar os parênteses para decodificá-lo em uma sequência de 3 etapas. Se algumas das expressões de várias partes estiverem aninhadas umas nas outras, em vez de serem organizadas como uma cadeia de chamadas de método, ela ainda pode parecer semelhante a isso, portanto, preciso ter cuidado ao confiar nisso sem contar os parênteses. E se eu confio no recuo e apenas deslizo para a última coisa como o ponto presumido de tudo isso, o que .acquire()
me diz por si mesmo?
Às vezes, isso pode ser o que você quer. Se eu aplicar sua transformação no meio do caminho e escrever:
WakeLock wakeLock =
((PowerManeger)getSystemService(POWER_SERVICE))
.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyWakeLockTage");
wakeLock.acquire();
Agora, isso se comunica para uma rápida descoberta "receba WakeLock
e, em seguida, acquire
it". Ainda mais simples que a primeira versão. É imediatamente óbvio que a coisa que é adquirida é um WakeLock
. Se obter o PowerManager
é apenas um sub-detalhe que é bastante insignificante para o ponto deste código, mas o wakeLock
é importante, então ele pode realmente ajudar a enterrar o material PowerManager
, então é natural você está apenas tentando rapidamente ter uma ideia do que esse código faz. E não nomear comunica que é usado apenas uma vez, e às vezes isso é importante (se o resto do escopo for muito longo, eu teria que ler tudo isso para saber se ele é usado novamente, embora o uso de subescopos explícitos possa ser outra maneira de resolver isso, se o seu idioma oferecer suporte a eles).
O que explica que tudo depende do contexto e do que você deseja comunicar. Como em escrever prosa em linguagem natural, sempre existem muitas maneiras de escrever uma determinada parte do código que é basicamente equivalente em termos de conteúdo de informação. Assim como escrever a prosa em linguagem natural, a maneira como você escolhe entre eles deve geralmente não ser aplicar regras mecanicistas como "eliminar qualquer variável local que só ocorre uma vez". Em vez disso, como você decide escrever seu código irá enfatizar certas coisas e não enfatizar outras. Você deve se esforçar para fazer essas escolhas conscientemente (incluindo a escolha de escrever código menos legível por razões técnicas às vezes), com base no que você realmente quer enfatizar. Especialmente pense no que servirá aos leitores que precisam apenas "obter a essência" de seu código (em vários níveis), já que isso acontecerá com muito mais frequência do que uma leitura expressão por expressão muito próxima.