switch(body.type){case'isBasic':constbasicEntry=getBasicEntry(body.id);console.log(`Processing basic entry "${basicEntry.name}"`);doBasicProcessing(basicEntry);break;case'isCustom':constcustomEntry=getCustomEntry(body.id);console.log(`Processing custom entry "${customEntry.name}"`);doCustomprocessing(customEntry);break;default:thrownewError(`Unknown flag ${myFlag}`);}
because different things warrant different variable names.
But if you cannot come up with different names, maybe these aren't actually different things and you should aim to solve the issue with a unified approach that doesn't even require a switch statement.
1) there are more possibilities than things are the same or are different. It’s also possible, as is the case here, that they are mostly, but not completely, the same
2) we use short-hand variables all the time that are repeated. How many callbacks have err as the first argument? Are these all the same thing? No. But we do it anyways and we consider that a best practice.
3) crafting a unified approach for this sort of case would require extra boilerplate, resulting in an over-engineered solution that obfuscates what’s actually going on.
1) Actually, that things are either handled the same or different is a literal dilemma without a middle ground. So in the context of their current handling they are either identical or different, regardless of their other similarities.
2) using the same shorthands twice in the same context is a recipe for confusion unless they actually mean the exactly same thing.
3) That's why I asked this as an open question. If things are actually so similar that you can handle them without too many extra cases, you should obviously do so – and if not, your variable names should reflect the difference.
I would actually write it like this:
because different things warrant different variable names.
But if you cannot come up with different names, maybe these aren't actually different things and you should aim to solve the issue with a unified approach that doesn't even require a switch statement.
I don’t agree with this, for three reasons:
1) there are more possibilities than things are the same or are different. It’s also possible, as is the case here, that they are mostly, but not completely, the same
2) we use short-hand variables all the time that are repeated. How many callbacks have
erras the first argument? Are these all the same thing? No. But we do it anyways and we consider that a best practice.3) crafting a unified approach for this sort of case would require extra boilerplate, resulting in an over-engineered solution that obfuscates what’s actually going on.
1) Actually, that things are either handled the same or different is a literal dilemma without a middle ground. So in the context of their current handling they are either identical or different, regardless of their other similarities.
2) using the same shorthands twice in the same context is a recipe for confusion unless they actually mean the exactly same thing.
3) That's why I asked this as an open question. If things are actually so similar that you can handle them without too many extra cases, you should obviously do so – and if not, your variable names should reflect the difference.
I still disagree, for the reasons I stated above. I think we’ll just have to agree to disagree, but thank you for sharing your perspective!
Thanks for taking your valuable time to raise and discuss this point.