When working with class or module sometimes you would need equal and opposite operations. The methods should be symmetric. Please make sure they are not added causally that would add not symmetric verbs.
If you are adding symmetric methods, then make sure they feel symmetric one.
?: is a ternary operator introduced to write elegant if-else clause.
It is a concise way of writing simple conditionals. However, those should be easily understandable by any human. It should not be used to write deeply nested complex conditionals that hamper the readability.
When to use?
When you have very simple if-else that could be covered in one line and returns value.
When NOT to use?
As said earlier, they are used to simplify the conditional so that they add value and make code simple and elegant.
However, that does not mean you should blindly rewrite ALL if-else clause with the ternary operator. Please avoid them when expression becomes complex and difficult to understand.
const output = number % 3 === 0 && number % 5 === 0 ? "FizzBuzz"
: number % 3 === 0 ? "Fizz"
: number % 5 === 0 ? "Buzz"
In my career, I have seen people writing deeply nested clauses using the ternary operator. I kept the above example to convey my thoughts.
The above snippet adds unnecessary mental mapping to remember and process each conditional and symbols ?: ?: ?: more like a machine.
Please don’t be a human code compressor.
Day by day, high-level languages are introducing more features so that developers could write more human-readable expressive code. We should keep this point in our mind and avoid a few things like writing deeply nested complex ternary conditionals. Instead, go for conventional control flow statements like if-else or if-return-early.
Thoughts mentioned in this post are based on my personal experience. It is just a guideline. IMO, we should be compassionate about our co-worker while writing the code and should avoid clever-complex clauses using ternary operators and rather should focus on elegance.
Programming languages divide their types mainly into two categories.
Primitive types (A built-in types like string, boolean, int, decimal…)
Objects (class/function): User-defined types using class-based/prototype-based objects.
A primitive data type is a data type for which the programming language provides built-in support. Example: number, string, boolean, date and so on.
There are situations when developers should represent their idea/concept using user-defined types (Abstraction or encapsulation).
Whereas they choose to use primitive types (inbuilt int, string…) to represents the concept.
“Talk is cheap. Show me the code.” ― Linus Torvalds
Consider the above API for scheduling meetup.
If you observe carefully, all the parameters: topic, description, date, location id, and max participants when they stand together represent the concept/idea called meetup.
Almost all the data types are primitive types (Built-in types: string, int, DateTime and so on).
Overutilization of these primitive types to solve a problem makes the code more verbose/procedural and logic to deal with them is scattered.
Since all method parameter stands together to represent the concept called Meetup.
Here, we could group all these parameters together to represent the idea/concept called meetup. So, introduce an object to gather these data values.
Upon replacing data values with an object API would look like:
This is how the API should have been. However, the developer chooses to go with all built-in types (segregated). IMO, this overutilization of primitive types in almost all cases can be treated as an obsession about primitives which can be called a primitive obsession.
I have explained only one scenario and there are other scenarios too.