Mastering Booleans with is.true and is.not_true in JavaScript: Your Guide to True Values
Tags: typescript, javascript, coding, security
Published: 2023-11-08 10:42:30

JavaScript is like a grand adventure filled with hidden treasures, and one of the most sought-after gems is the boolean value `true`. This value is at the heart of decision-making in your code. But how can you be sure that a value is truly `true`, or conversely, make sure it's anything but `true`? That's where the `is.true` and `is.not_true` methods from the 'thiis' package come into play. In this article, we'll take you on a journey to explore these powerful tools and their potential in JavaScript.

## The Magic of `true` in JavaScript

Before we embark on our adventure, let's understand what `true` is in JavaScript. It's like a magic wand, representing the "true" or "yes" in decision-making. Recognizing it is crucial for precise and confident programming.

## Meet `is.true` - Your Truth Detector
[Documentation link](https://karbashevskyi.github.io/thiis/docs/API/Boolean/is.true)

Imagine you're on a quest to uncover the truth in your code. The `is.true` method acts as your trusty truth detector, ensuring that a value is indeed `true`. Let's see it in action:

```javascript
import { is } from 'thiis'; // Import the "is" object from the "thiis" package

const myValue = true;
const result = is.true(myValue);

console.log(result); // true
```

In this example, we import the "is" object from the "thiis" package and use the `is.true` method to confirm that `myValue` is indeed `true`. As expected, it returns `true` because the value is indeed `true`.

## The Journey of Examples

Now, let's embark on an adventure and explore six practical scenarios that demonstrate the versatility of `is.true` and its companion, `is.not_true`. We'll cover a range of use cases, including some exciting ones.

### 1. **Discovering True Values with `is.true`**

The primary role of `is.true` is to identify `true` values. It helps you determine when a value is indeed `true`, which can be useful for celebrating success:

```javascript
import { is } from 'thiis';

const success = someFunctionThatMayReturnTrue();

if (is.true(success)) {
  // Celebrate the triumph!
} else {
  // Keep working towards victory.
}
```

### 2. **Guarding Against `true` with `is.not_true`**

On the flip side, `is.not_true` serves as your guardian against `true`. It's handy when you want to ensure that a value isn't `true` before proceeding:

```javascript
import { is } from 'thiis';

const importantValue = someFunctionThatShouldNotBeTrue();

if (is.not_true(importantValue)) {
  // Your guardian prevents "true" mishaps!
} else {
  // Time to explore other possibilities.
}
```

### 3. **User Validation with `is.true`**

When dealing with user input, you may want to validate if the input is indeed `true`. Use `is.true` to make sure users are giving you the "true" story:

```javascript
import { is } from 'thiis';

function validateUserInput(input) {
  if (is.true(input)) {
    return 'You've made a true choice!';
  } else {
    return 'Interesting, tell me more!';
  }
}
```

### 4. **Making Confident Decisions with `is.not_true`**

In decision-making scenarios, you might want to ensure that a value is not `true` before executing specific actions. `is.not_true` helps you make choices with confidence:

```javascript
import { is } from 'thiis';

const userChoice = getUserInput();

if (is.not_true(userChoice)) {
  // Execute actions for valid choices.
} else {
  // Handle scenarios involving 'true' with grace.
}
```

### 5. **Stream of Truth with `is.true`**

Now, let's dive into a scenario involving `stream$` from RxJS. Using `filter` and `is.true`, we can ensure that the stream processes only `true` values:

```javascript
import { is } from 'thiis';
import { from } from 'rxjs';
import { filter } from 'rxjs/operators';

const stream$ = from([false, 'not true', null, 'a value', true, 'another value']);

stream$
  .pipe(
    filter(is.true)
  )
  .subscribe(value => {
    console.log(value); // Only "true" values will be part of the stream's story.
  });
```

In this example, the `filter(is.true)` ensures that only `true` values get processed by the stream.

### 6. **Array Exploration with `is.not_true`**

Arrays are another exciting playground for `is.not_true`. You can use `every()` to confirm that all elements are not `true` and `some()` to check if at least one isn't:

```javascript
import { is } from 'thiis';

const notTrueArray = [false, 'not true', 0];
const mixedArray = [null, 'not true', true, undefined];

const allElementsNotTrue = notTrueArray.every(is.not_true); // true
const someElementsNotTrue = mixedArray.some(is.not_true); // true

console.log(allElementsNotTrue);
console.log(someElementsNotTrue);
```

In this scenario, `allElementsNotTrue` checks if all elements in `notTrueArray` are not `true`, and `someElementsNotTrue` checks if at least one element in `mixedArray` is not `true`.

## The Adventure Continues

The `is.true` and `is.not_true` methods from the 'thiis' package are your reliable companions on your JavaScript adventure. They make type checking precise and fun, ensuring your code interacts with `true` values exactly as intended. By adding the 'thiis' package to your JavaScript toolkit and exploring its documentation for more tips and examples, you can navigate the JavaScript landscape with confidence and a touch of excitement.

So, keep coding, and remember that the world of JavaScript is full of exciting discoveries!

🎗 ChatGPT & DALL·E 3