07-01. Debit card

This programme will be a simple routine to validate the details on a bank card.

Typically when the numbers on the card are entered into an online form, some basic checking before the data is sent to the server ensures fewer failed transactions.

A bank card has 16 digit numbers, but this may be entered with a space after each set of four digits, meaning that either 16 or 19 characters might be entered and both would be valid.

Let's start with the boilerplate code.

The first function we'll write is one to validate the number.

This will return true if it's valid or false if not.

So static bool that means boolean true or false validatenumber.

This will require some data.

So open bracket and then the data we will give it.

That's the number on the card.

Close bracket.

The number will actually be a string because it may contain spaces between each of the four digits.

There are lots of ways we could write this programme, but we'll assume the number was entered correctly and then attempt to prove it wasn't.

You could of course write the programme the other way around.

So bool valid becomes true.

An integer for the number of characters becomes the length of the number on the card.

We need to know this to cheque if the number of digits was correct.

If the number of characters is equal to 16 or the number of characters is equal to 19, then we're good so far.

But we need to cheque if each character is actually a number or a space.

Because.

Because it could be a letter or symbol and that would be invalid to cheque each character, we can use a for loop for each character in number on card.

If not character isdigit.

This means if the individual character is not a number and character is not a space, then valid becomes false.

So to recap, the number on card is a string that will be passed into the function.

The character is an individual character or number from the number on card.

This is also a string, but we can use a string method called isdigit to cheque if it could be cast to a number.

If it can, then it's a digit.

That's our simple cheque done.

So if the number of characters on the number on card is not 16 or 19, then then it must be an invalid card.

So else valid becomes false.

Then we can return valid which will be either true for a valid card or false for an invalid card.

Next we'll write a simple subprogram to collect the 16 digit number from the user.

Static void inputcarddetails.

This subprogram, does not require data because it's collecting data, so open and close brackets.

This time we will assume the card is invalid so that we can keep asking the user to enter the number until a valid number is entered.

So validcard becomes false, while not validcard prompt the user to enter their number and store this in a variable called numberinput.

We should probably have declared this outside of the loop rather than defining its data type continually in the loop.

But it doesn't matter either way.

Then validcard becomes the result or return value from our validatenumber function and we need to pass it the number input.

So open bracket number input.

Notice here how we have a subprogram calling another subprogram.

The code in InputCarddetails calls the ValidNumber subprogram.

Breaking the problem down into smaller chunks and building it back up again makes the overall problem easier to solve.

You just need to take one step at a time.

Okay, that's the subprograms written so the main programme.

Now we just need to call our InputCardDetails subprogram.

And we know that must return a valid card number before it completes.

So we can finish with a simple output to tell the user the card was accepted, give the programme a run and cheque that it works for a variety of situations.

That's both valid and, invalid inputs.