Parsing numbers and ranges from a string in Javascript I would like to convert a string like "1 2 3-5" to an array of numbers [1, 2, 3, 4, 5].

Following the robustness principle, the list doesn't need to be separated by spaces, comma on any other separator is accepted. The only mandatory syntax is A-B to represent range from A to B (inclusive). Also, it's ok to ignore malformed input (like 1-3-5), it can be considered "undefined behavior" as long as it doesn't raise an exception.

My current code is a follow:

function parse(string) {
    let numbers = [];
    for (let match of string.match(/[0-9]+(?:\-[0-9]+)?/g)) {
        if (match.includes("-")) {
            let [begin, end] = match.split("-");
            for (let num = parseInt(begin); num &lt;= parseInt(end); num++) {
                numbers.push(num);
            }
        } else {
            numbers.push(parseInt(match));
        }
    }
    return numbers;
}


This seems quite convoluted for such a simple task. Is there any alternative more straightforward using "modern" Javascript (I'm targeting ES6)?
On modern environments that support it (which is pretty much all of them except Safari), you can make it a bit nicer by using matchAll instead of match, and use capture groups to capture the digits immediately, rather than having to use an .includes check and split afterwards:



function parse(string) {
    const numbers = [];
    for (const [, beginStr, endStr] of string.matchAll(/(\d+)(?:-(\d+))?/g)) {
        const [begin, end] = [beginStr, endStr].map(Number);
        numbers.push(begin);
        if (endStr !== undefined) {
            for (let num = begin + 1; num &lt;= end; num++) {
              numbers.push(num);
          }
        }
    }
    return numbers;
}

console.log(parse('11 14-16 18-20'));




(For older environments, you'll need a polyfill)

Also note that you should always use const to declare variables whenever possible - only use let when you need to warn readers of the code that you may have to reassign the variable in the future.