Refactoring string incrementing and duplicating function
You should consider using consistent indentation when writing code - it makes it much easier for people to read (not only for other maintainers, but for you as well). For example

let loop = 0;
for (; loop &lt; 155; loop++) {
let n = 00;
// ...
zz ="00";
        if (loop &gt; 0 ) {
        x+=loop;
    console.log('one loop ' + loop );


should be something like

let loop = 0;
for (; loop &lt; 155; loop++) {
  let n = 00;
  // ...
  zz ="00";
  if (loop &gt; 0 ) {
    x+=loop;
    console.log('one loop ' + loop );


Lots of IDEs provide an automatic tidying function.

In this section, since you aren't using str2, str3, or str4, you may as well remove those assignments from the inside of the loop here, since they aren't used and only add to cognitive overhead.

Best to always declare variables before you use them - you have a number of variables which are not declared, which will either assign to properties of the global object (in sloppy mode), or will throw an error (in strict mode). (Consider always using strict mode so that these sorts of potential bugs can be fixed early.) Specifically, lines like:

str1 = "https://site.com/content/2018/02/"; /* groups 1-155*/


where you use a variable for the first time should be prefixed with const, let, or var:

const str1 = "https://site.com/content/2018/02/"; /* groups 1-155*/


If you're going to use ES2015 syntax to declare some variables like let (which is great, you should), don't use var anywhere; var has numerous potential gotchas which can cause bugs, and doesn't really have anything positive going for it (other than compatibility with ancient browsers - but if you need that sort of compatibility, use Babel to transpile to ES5 automatically - best to keep source code in readable, pretty, modern syntax).

When you have a for loop, if you need to declare a variable at the beginning that's then used inside that loop, you should put the declaration inside the for loop declaration. That is:

let loop = 0;
for (; loop &lt; 155; loop++) {


should be

for (let loop = 0; loop &lt; 155; loop++) {


You have

let n = 00;
let x = 000;


Leading zeros have no effect in numeric literals. Those are equal to

let n = 0;
let x = 0;


You declare the zz variable 3 times, but you only have one binding for it - duplicate variable declarations with var are ignored. If you just want assignment, then only use the assignment operator with =.

The x variable starts at 0 and gets loop assigned to it once, on every iteration:

let x = 0;
// ...
if (loop &gt; 0) {
  x += loop;


So, it's equivalent to loop. Best to just remove that variable completely, since it isn't doing anything useful - use the one loop variable completely. The if (loop &gt; 0) { test is superfluous too, since the tests inside that block if(x &gt;= 9){ if(x &gt;= 99){ are only fulfilled if loop is greater than 0 anyway.

Use meaningful variable names. It is very difficult to tell at a glance what loop, n, x, z, or zz are meant to represent. Maybe call them group (the number that goes from 1 to 155) and subgroup (the number that goes from 1 to 11) instead.

The main block there is meant to ensure that the zz variable for padding the string has the right number of zeros. But there's a much easier way to do that, without creating extra variables: just use String.prototype.padStart. When you need to construct

000_01
154_12


from variables 0 and 1, and from variables 154 and 12, add the leading zeros by calling padStart(length, '0') on them:

`${String(group).padStart(3, '0')}_${String(subgroup).padStart(2, '0')}`


Or, without a template literal:

String(group).padStart(3, '0') + '_' + String(subgroup).padStart(2, '0')


The loop over subgroups (or n in your original code) assigns a variable and increments it every iteration, breaking after a condition. This is a prime spot to be refactored into a for loop instead:

for (let subgroup = 1; subgroup &lt;= 12; subgroup++) {


Since the str1 never changes, and nor does the ext, you may as well declare them outside of the loop, rather than re-declare them every time there's another iteration:

In full:



'use strict';

const str1 = "https://site.com/content/2018/02/"; /* groups 1-155*/
const ext = ".jpg"
for (let group = 0; group &lt; 155; group++) {
  console.log('one loop ' + group);
  for (let subgroup = 1; subgroup &lt;= 12; subgroup++) {
    console.log(`${str1}${String(group).padStart(3, '0')}_${String(subgroup).padStart(2, '0')}${ext}`);
  }
}