# Bonfire: Repeat a String Solution

This time on the FreeCodeCamp Bonfire experience network, we’re going to Repeat a String by however many times have been fed into the properties of the function repeat(). Here’s what FreeCodeCamp has given us:

```function repeat(str, num) {
// repeat after me
return str;
}

repeat('abc', 3);```

We also have one upfront caveat to consider: if the number fed into repeat’s second property is a negative number, we must return an empty string. Funny enough, this is one of the easier Bonfires in my opinion to work with because you don’t really need to know any new methods. Let’s get started.

## Mapping Out the Problem

1. I know I’m going to end up using a loop for this, so the trick to determine which kind of loop is the most appropriate for this situation.
2. I need to weed out negative values while I’m at it and should probably do that in the loop, or to make things more efficient, weed out negative values before anything gets looped. That way, we’re not constantly checking for negatives while we count down.
3. I see FCC is planning to check the string for invalidate characters too. Fantastic, we’ll have to weed those out as well.
4. Strings are constants/immutable, whatever. I’ll need to create a variable to hold the string that gets outputted as a result.

## Using the Repeat() Approach

This is pretty straightforward if you choose to use the repeat() method like the Bonfire suggests. What you need to do first is ensure that the function doesn’t run for any negative values. That means you have to check to make sure num is greater than 0. If num is less than 0, then we need it to return an empty string. You can do that with a return and empty quotes:

```function repeat (str, num) {

if(num > 0) {
return str;
} else {
return '';
}
}

repeat('abc', 3);```

The above code will return the string, but it doesn’t repeat it. We need to use the repeat() method for that. And since repeat() is a new thing, let’s take a look at it first.

### A Foray Into Repeat()

Repeat() is a useful method in Javascript that takes a string and–you guessed it–repeats it however many times you indicate in the method’s parameters. It is typically used like this:

`myStr.repeat(4);`

Where whatever myStr is, you will see it repeated 4 times. Repeat(), handily enough, doesn’t take negative values all too well, and will round up floating point numbers to integers. This makes it the perfect candidate for our Bonfire solution. Here’s the finalized approach:

```function repeat (str, num) {

if(num > 0) {
return str.repeat(num);
} else {
return '';
}
}

repeat('abc', 3);```

Validates and passes you onto the next Bonfire. But we aren’t really done yet. What if you don’t want to use the repeat() method? We’ve actually already learned how to deal with situations where we have to repeat a string before. Possibly even in some of those JS lessons we took before we got to the Bonfires. Wouldn’t a simple loop perform the same thing that we just did using repeat()? Yep.

## The For Loop Approach

This is a case where a For Loop or any other kind of loop would resolve the problem. Here’s my approach with a For Loop.

```function repeat (str, num) {
var wordStr = '';
for (var i = num; i > 0; i--) {
wordStr += str;
}

return wordStr;
}

repeat('abc', 3);```

In the above code, I declare an empty variable called wordStr. This is going to be used to add the strings to it however many times specified by repeat()’s properties. Then I go into the For Loop. The loop identifies i as whatever num is. It then checks to make sure i (num) is greater than 0. Then decrements i (num) accordingly. If i is greater than 0, it concatenates whatever str is onto our wordStr variable. Then outside of the For Loop, wordStr, and all of the strings that were repeated, are returned for evaluation.

## The While Loop Alternative

I had said before that any loop could do this job. I have a particular affinity with the For Loop, but a While Loop is just as valid. Even a Do While Loop will evaluate for this Bonfire, but it really isn’t recommended to use a Do While for this.

Using a While Loop, though, is perfectly good. Here’s a While Loop solution:

```function repeat (str, num) {
var wordStr = '';
while ( num > 0) {
wordStr += str;
num--;
}

return wordStr;
}

repeat('abc', 3);

```

## A Really Inefficient Use for the Do While Loop

And while (I’m corny) we’re here, a Do While Loop is possible, but I’ve found that I needed to check for negative values before it even goes into the Do While Loop, where the negative value is checked again. This would, of course, invalidate this as a solution because though it works, it’s so far beyond inefficient, it’s not even worth mentioning. A Do While Loop is really only useful if we had to run the function through at least once before we evaluate it. This isn’t the case here with this Bonfire, but I would have felt bad leaving Do While out. Here it is in case anyone was curious:

```function repeat (str, num) {
var wordStr = '';

if (num > 0) {
do {
wordStr += str;
num--;
} while ( num > 0);
}

return wordStr;
}

repeat('abc', 3);
```

And there we have it, we’ve repeated a string for our Bonfire using a For Loop and a While Loop. And I even wrote out the world’s most inefficient Do While Loop while I was at it.

## Resources

MDN, String.prototype.repeat()
One of the easier to read MDNs explaining repeat() in detail.

## One comment on “Bonfire: Repeat a String Solution”

This site uses Akismet to reduce spam. Learn how your comment data is processed.