Typescript - Truthiness

What is truthiness?

Truthiness is a term coined by comedian Stephen Colbert to describe something that feels true, even if it is not based on facts or logic. In programming, truthiness refers to how a value is evaluated in a boolean context, such as an if statement or a logical operator.

In TypeScript, a value is either truthy or falsy, depending on whether it is considered equivalent to true or false. The following values are falsy in TypeScript:

• false
• 0 and -0
• "" (empty string)
• null
• undefined
• NaN (not a number)

All other values are truthy, including:

• true
• Any non-zero number, including Infinity and -Infinity
• Any non-empty string, including "0" and "false"
• Any object, array, function, or symbol
• [] (empty array)
• {} (empty object)

Why does truthiness matter?

Truthiness can lead to unexpected results and bugs when working with TypeScript. For example, consider the following code snippet:

let name = "";
if (name) {
  console.log("Hello, " + name);
} else {
  console.log("Please enter your name");
}
        

You might expect this code to print “Please enter your name” if the name variable is an empty string. However, since an empty string is falsy, the else branch is executed, and the code prints "Hello, " instead.

Another common source of confusion is the use of logical operators, such as &&, ||, and !. These operators do not always return a boolean value, but rather the value of the last operand that determines the outcome of the expression. For example:

let x = 0;
let y = 1;
let z = x || y; // z is 1, not true
let w = x && y; // w is 0, not false
let v = !x; // v is true
        

In the above example, x || y returns y because x is falsy, and x && y returns x because x is falsy. Only the ! operator returns a boolean value by negating the truthiness of its operand.

How to avoid truthiness pitfalls?

There are some best practices and tools that can help you avoid the pitfalls of truthiness in TypeScript. Here are some of them:

• Use strict equality operators (=== and !==) instead of loose equality operators (== and !=). The strict operators compare both the value and the type of the operands, while the loose operators perform type coercion and can lead to unexpected results. For example:

0 == false; // true
0 === false; // false
"1" == 1; // true
"1" === 1; // false
null == undefined; // true
null === undefined; // false
        

• Use the Boolean function or the !! operator to explicitly convert a value to a boolean. This can be useful when you want to store or return a boolean value based on the truthiness of another value. For example:

let name = "";
let hasName = Boolean(name); // false
let hasName = !!name; // false
        

• Use type annotations and type guards to narrow down the possible types of a variable or a parameter. This can help you avoid errors related to null and undefined values, as well as other types that are not compatible with your logic. For example:

function greet(name: string | undefined) {
  if (name) {
    // name is string
    console.log("Hello, " + name);
  } else {
    // name is undefined
    console.log("Please enter your name");
  }
}
        

• Use a linter, such as ESLint, to enforce code quality and consistency rules. A linter can help you detect and fix potential problems related to truthiness, such as the use of loose equality operators, the use of falsy values as defaults, and the use of ambiguous expressions in conditional statements. For example, the following rules can be useful to avoid truthiness pitfalls:eqeqeq: Require the use of strict equality operatorsno-implicit-coercion: Disallow the use of short-hand type conversionsno-eq-null: Disallow the use of == and != with nullno-unneeded-ternary: Disallow the use of ternary operators when a simpler alternative existsno-constant-condition: Disallow the use of constant expressions in conditional statements

Conclusion

Truthiness is a concept that can cause confusion and errors when working with TypeScript. By understanding how truthiness works, and by following some best practices and tools, you can write more reliable and maintainable TypeScript code.