square()

Prompt

JavaScript arrays do not have a native method for squaring each element. Your task is to implement a method called .square(), which creates a new array with each numeric element squared. Code your solution in JavaScript and include a brief discussion of your approach.

Playground

Solution

Explanation

Our implementation follows the principle that array methods like this should return a new array rather than modifying the original one. Let's break down how our solution works:

First, we extend the Array.prototype with our custom square method:

Array.prototype.square = function() {
  // Implementation goes here
};

Within the implementation, we create a new array to store our results:

const result = [];

Then, we iterate through each element of the original array, convert it to a number, square it, and add the result to our new array. We use this to refer to the array that the method is called on because we extended the Array.prototype.

for (let i = 0; i < this.length; i++) {
  result.push(Number(this[i]) * Number(this[i]));
}

Finally, we return the new array with the squared values:

return result;

Using map()

We can also implement the square method using map(), which is more concise and declarative:

return this.map(item => Number(item) * Number(item));

Type Conversion

It's important to note how JavaScript handles type conversion when performing mathematical operations:

• Numbers are squared as expected
• Strings that contain valid numbers are converted and squared
• Strings that don't contain valid numbers become NaN when squared
• null becomes 0 when converted to a number, so null squared equals 0
• undefined becomes NaN when converted to a number

Our solution handles these cases by explicitly converting each element to a number before squaring it. This approach ensures consistent behavior across different data types.

The square() method is particularly useful for data processing and mathematical operations on arrays, especially when working with numeric data sets that need to be transformed without modifying the original data.