Forem: Jacob Stern

Credit Card Validator Challenge

Jacob Stern — Mon, 16 Sep 2024 07:36:42 +0000

Sun, September 15, 2024

(Originally published as part of a 100 Days of Code series. Revised for clarity and purpose.)

This week has been all about code challenges, which has been glorious! One intriguing challenge was implementing a credit card validator using the Luhn algorithm, which prevents single-digit errors and adjacent transpositions like 90 → 09. Coding the Luhn algorithm is straightforward once you break it down—so let’s walk through my implementation.

It turned out to be a great excuse to lean into some Functional Programming (FP). Instead of an imperative function where you queue up credit card numbers to test, the verification becomes a method you apply directly to credit card number variables. This modular approach increases the value of your code because it can be reused in more contexts without rewriting. One side effect of FP is that data becomes the star—not functions—which ends up looking very streamlined.

I kicked things off with an arrow function to stay aligned with the FP paradigm. While arrow functions shine in one-liners, they’re still a solid choice for readability and modern style.

Set Aside the Last Digit: Starting with the example number 4539 1488 0343 6467, we isolate the last digit (7) and store it in a variable called lastDigit. This is done with the common pattern array.length - 1, which grabs the final element in a zero-indexed array.
Reverse the Array: With the last digit set aside, we take the rest of the number—4539 1488 0343 646—and reverse it. That gives us: 6463 3408 8841 9354, which we store in a new array named allExceptLastReversed.
Double Every Other Element: Starting from index 0, we double every other digit in the reversed array. So values like 6 → 12, 4 → 4, 6 → 12, 3 → 3, and so on. If a doubled number is greater than 9, we subtract 9 to keep it in single digits (e.g., 12 → 3). The array becomes something like [3, 4, 3, 3, ...].
Sum the Elements and Validate: Next, we sum all the adjusted digits using reduce, add back the lastDigit (7), and check if the total is divisible by 10. If it is, the number passes the Luhn check.

This challenge was a fun way to work with both functional and imperative styles. It also reinforced how nice it is when your code stays flexible and easy to reuse. I'm looking forward to tackling more of these bite-sized problems and seeing what new patterns and tricks pop up along the way.

Here’s the complete code:

const validateCred = (cardNumber) => {
  const lastDigit = cardNumber[cardNumber.length - 1];
  let allExceptLastReversed = cardNumber.slice(0, -1).reverse();
  for (let i = 0; i < allExceptLastReversed.length; i += 2) { 
    allExceptLastReversed[i] *= 2; 
    if (allExceptLastReversed[i] > 9) {
      allExceptLastReversed[i] -= 9; 
    }
  }
  const sum = allExceptLastReversed.reduce((acc, curr) => acc + curr, 0) + lastDigit; 
  // sum all digits
  return (sum % 10 === 0);
};

Iterating with Methods

Jacob Stern — Fri, 06 Sep 2024 07:44:58 +0000

Thu, September 5, 2024

(Originally published as part of a 100 Days of Code series. Revised for clarity and purpose.)

Iterators are yet another JavaScript power tool. Today’s assignment was titled Iterators: .forEach(), .map(), .findIndex(), .filter(), and .reduce(), but to be clear—these are methods that use iterators behind the scenes to do their work.

Here’s a quick rundown of what each one does:

.forEach(): Runs a function on each element (but doesn’t return anything)

.map(): Creates a new array by transforming each element

.findIndex(): Returns the index of the first element that matches a condition

.reduce(): Combines elements into a single value (like a sum or total)

.filter(): Returns a new array with only the elements that meet a condition

These methods are part of the Array prototype and handle the repetitive looping for you, letting you focus on the actual data instead.

After trying them all out, .filter() stood out the most for me. It’s clean, powerful, and super flexible—it lets you carve out subsets from an array based on any condition you want. For example, you can use it to pull all elements greater than a certain value, or to isolate all objects with a matching property. It reminds me a little of a factory function: same input shape, different outputs depending on the logic.


const bigNumbers = [148, 256, 384, 918, 512];

// Using filter() to get all elements above 200
const allAbove200 = bigNumbers.filter(num => num > 200);

console.log(allAbove200); // Output: [256, 384, 918, 512]

Destructured Assignment

Jacob Stern — Tue, 03 Sep 2024 22:12:34 +0000

Mon, Sep 2, 2024

(Originally published as part of a 100 Days of Code series. Revised for clarity and purpose.)

One key thing about most programming languages is that they’re backward compatible. This means old code usually keeps working years—even decades—after it was written. That’s important because we want proven, reliable code running critical systems like Air Traffic Safety Control. But just because languages protect legacy code doesn’t mean they stop evolving.

JavaScript is based on the ECMAScript standard, which gets updated every year or two. The biggest update so far was ES6 in 2016, and since 2017 all major browsers support it. JavaScript used to be just for browsers, but in 2009 Node.js brought it to app developers everywhere.

I’ve talked before about arrow functions and for..in / for..of loops, which changed how JavaScript handles data compared to traditional programming. But that’s just the beginning—JavaScript has some really powerful features under the hood. Remember, an object is a collection of properties and functions. Here’s an example featuring the Millennium Falcon (see footnote):

// Example: The Millennium Falcon, see Footnote

const millenniumFalcon = {
  modelNumber: "YT-1300F",
  yearOfProduction: "56 BBY", // Before the Battle of Yavin
  engineCapacity: "2 Girodyne SRB42 sublight engines",
  rateOfTravel: {
    atmosphericSpeed: "1,200 km/h",
    spaceSpeed: "3,000 G",
    hyperdrive: "0.5 HCR (Hyperdrive Class Rating)"
  },
  currentSpeed: "800 km/h", // Example current speed
  logCurrentSpeed() {
    console.log(`Current Millennium Falcon speed: ${this.currentSpeed}.`);
  }
};

millenniumFalcon.logCurrentSpeed();
// Output: Current Millennium Falcon speed: 800 km/h.

The this keyword lets a method access data from the specific object it belongs to. Without this, the method wouldn’t find currentSpeed and would return undefined. So this provides the right context.

Just like the Rebel Alliance needs a fleet of starships to fight the Galactic Empire, JavaScript helps us create lots of objects with Factory Functions. Here’s how you can make Starships in bulk. Note: Property Value Shorthand reduces how much you have to type.

// Factory function for creating Starships
function createStarship(type, model, name, speed) {
  return {
    type,
    model,
    name,
    speed,
  };
}

Lastly, JavaScript has Destructured Assignment, which makes pulling properties out of objects far easier. Compare:

const engineCapacity = millenniumFalcon.engineCapacity;
const { engineCapacity } = millenniumFalcon;

You can even grab nested properties like this:

const { hyperdrive } = millenniumFalcon.rateOfTravel;

These object features give JavaScript developers powerful tools to write cleaner, more efficient, and easier-to-maintain code. Keep exploring them as you code and see how they can help your projects.

Footnotes
The Millennium Falcon is an extensively modified Corellian YT-1300 light freighter. Known for its speed and agility, it was mainly used for smuggling before becoming a key asset for the Rebel Alliance.