This article takes a look at how to convert between the primitive values in JavaScript. Even if automatic type coercion is sometimes promoted as a way of doing type conversion “like a pro” or as being shorter and as such better, I consider the built-in String, Number, and Boolean functions to be better options.

Converting to Numbers

The automatic type conversion system, also called type coercion in JavaScript, converts values to numbers when using the - and + operators before a single value.

Here is the “one-liner” that is sometimes promoted as the smart way of converting strings to numbers:

+"1" //1typeof…

In this article, we will look at how to get a random value from an array. Basically, we are going to use the Math.random index to generate a random index and then return the element.

Let’s start.

Math.random

The Math.random utility returns a random number between 0 and 1. The random number is greater or equal to 0 but less than 1.

Here is an example.

console.log(Math.random());
//0.6168018976827372

Random Number in a Range

Before looking at how to generate a random index, we need to be able to generate a random integer number between 0 and a maximum number.

Math.random returns a number less than 1…

Have you ever wondered what happens when freezing the prototype of an object? Let’s find out together.

Objects

In JavaScript, objects are dynamic collections. Here is such an object created using the object literal syntax.

const counter = {
  count: 0,
  
  increment(){
    this.count += 1;
    return this.count;
  },
  
  decrement(){
    this.count -= 1;
    return this.count
  }  
}counter.increment();
//1

counter is an object with a field and two methods operating on it.

Prototypes

Objects can inherit properties from other objects called prototypes. They have a “hidden” property called __proto__ pointing to their prototype. As a matter of fact, the counter object already inherits…

This article will look at perhaps the most important utility functions for working with objects in JavaScript.

Object.freeze

Object.freeze() freezes an object. A frozen object cannot be changed anymore. It returns the same object that was passed in.

This is the simplest way to achieve immutability in JavaScript by freezing the object at creation.

const game = Object.freeze({
 name: 'Warcraft'
});game.developer = 'Blizzard';
//TypeError: Cannot add property developer, object is not extensible

The only thing to note is that Object.freeze() freezes only the immediate properties of an object doing what is called a “shallow freeze”. …

This post shows a different solution to the problem of computing the sum of the digits in a number.

The first step is to convert the number to an array of digits. To achieve this we first convert it to a string, then convert the string into an array of chars. In the end, the array of number characters is converted into an array of numbers.

The String built-in function can transform any value into a string. Below is an example of transforming a number into a string.

String(12345)
//"12345"

The split method splits a text into an array of…

In this post, we will take a look at how to count the number of occurrences of each letter in a word with both JavaScript and Elixir. In both cases, we are going to create a map with the result.

The algorithm will be pretty similar:

• split the text into an array of characters
• use the reduce method over the array to compute the counts

Here are the letter counts for the Hello word.

// { H: 1, e: 1, l: 2, o: 1 }
# %{"H" => 1, "e" => 1, "l" => 2, "o" => 1}

Count characters in JavaScript

We can…

Adding two numbers should be a simple operation, and in many cases it is.

1 + 2
//3

However, sometimes we get into unexpected issues because the plus operator (+) is both the addition and concatenation operator. When one of the operands is a string it becomes the concatenation operator.

1 + '2'
//'12'

In such cases, we need to make sure both operands are numbers. The Number built-in function can convert any value into a number.

1 + Number('2')
//3

There are cases when we need to add decimal numbers are we are surprised by the result.

0.1 +…

This article takes a deeper look at the NaN value read “Not-A-Number”.

1. NaN is a number

In JavaScript, invalid numbers are represented using the NaN value. NaN and Number.NaN both represent the same value.

Even if is called “Not-A-Number” is actually a number.
A better name would have been Not-A-Valid-Number.

typeof NaN
//number

2. NaN is not equal to NaN

NaN is not equal to itself. This can be a little strange. It is the only value in the language not equal to itself.

NaN === NaN
//false

That implies that a variable storing the NaN value is not equal to itself.

const x = NaN;x === x
//false

3. Invalid conversion results in NaN

The…