Day 77 / 100 Days of Code: Credit Card Validator Challenge

Sun, September 15, 2024

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 credit card errors and adjacent transpositions like 90 > 09. Coding the Luhn algorithm is quite attainable; let’s walk through my implementation.

First, let’s take a moment to understand what Functional Programming (FP) is all about. Instead of having an imperative function where you queue up credit card numbers to test, credit card number verification can be a method you apply directly to credit card number variables. This modular approach increases the value of your code because it can be used in more ways without rewriting. One side effect in FP is that data becomes the star--not functions, which looks very streamlined.

To start, we’ll use an arrow function in keeping with the FP paradigm. This is more important in one-line functions, but it’s still practical.

• Set Aside the Last Digit: The first step in the Luhn algorithm is to set aside the last digit into a variable we’ll name lastDigit. This follows a standard method to access array elements using the array length - 1 since arrays start element numbering at 0. JavaScript nicely provides this feature natively for arrays.

• Reverse the Array: The Luhn algorithm works on credit card digits from right-to-left. To keep things simple, we’ll reverse the array. JavaScript provides two methods to simplify this operation: slice to select the first to the second-to-last elements, and reverse to reverse the order of the elements in the array. We’ll assign this to a new array named allExceptLastReversed.

• Double Every Other Element: The next step requires finer control of array element iteration than JavaScript’s iterative methods provide, so we’ll use a traditional for loop. This step involves doubling every other array element, and if the value is higher than 9, subtracting 9.

• Sum the Elements and Validate: Now we’re almost done. We want to sum all of the array elements and verify that they’re divisible by 10. JavaScript has an iterative method named reduce that applies a function, typically sum or product, to every element in an array and accumulates the result. Here we’ll sum the reversed, sliced array elements, add the lastDigit, and check if the sum modulo 10 is 0.

JavaScript also provides logical comparisons, to evaluate as true or false, called Boolean values, which are the function return values. JavaScript almost makes programming artful.

This challenge was a fantastic way to dive deeper into both functional and imperative programming paradigms. It highlighted the importance of writing modular, reusable code. As I continue my 100 Days of Code journey, I’m excited to tackle more challenges and expand my understanding of different programming concepts. Each day brings new opportunities to learn and grow, and I can’t wait to see where this journey takes me next.

Stay tuned for more updates, and happy coding! 🚀

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);
};

Cross posted: Dev https://dev.to/jacobsternx and LinkedIn https://www.linkedin.com/in/jacobsternx