Sending an array of values through the query parameters of a GET request

One option is using a JSON format.

http://server/url?array=["foo","bar"]

Server side

var arr = JSON.parse(req.query.array);

Or your own format

http://server/url?array=foo,bar

Server side

var arr = req.query.array.split(',');

Express exposes the query parameter as an array when it is repeated more than once in the request URL:

app.get('/', function(req, res, next) {
   console.log(req.query.a)
   res.send(200)
}

GET /?a=x&a=y&a=z:
// query.a is ['x', 'y', 'z']

Same applies for req.body in other methods.

You can encode an array in percent encoding just "overwriting" a field, formally concatenating the values.

app.get('/test', function(req,res){
    console.log(req.query.array);
    res.send(200);
});




localhost:3000/test?array=a&array=b&array=c

This query will print ['a','b','c'].

Using next code:

app.use('/', (req, res) => {
    console.log(req.query, typeof req.query.foo, Array.isArray(req.query.foo));
    res.send('done');
});

On backend, you have two standard approaches. For next requests:

1. /?foo=1&foo=2
2. /?foo[]=1&foo[]=2

your NodeJS backend will receive next query object:

1. { foo: [ '1', '2' ] } 'object' true
2. { foo: [ '1', '2' ] } 'object' true

So, you can choose the way you want to. My recommendation is the second one, why? If you're expect an array and you just pass a single value, then option one will interpret it as a regular value (string) and no an array.

[I said we have two standards and is not ok, there is no standard for arrays in urls, these are two common ways that exist. Each web server does it in it's own way like Apache, JBoss, Nginx, etc]

If you want to pass an array from url parameters, you need to follow the bellow example:

Url example:

https://website.com/example?myarray[]=136129&myarray[]=137794&myarray[]=137792

To retrieve it from express:

console.log(req.query.myarray)
[ '136129', '137794', '137792' ]

Express allows you to use either Node's built-in querystring module or the qs library for parsing query strings, as noted in the documentation. Let’s explore how we can send an array of values to them via query parameters.

Handling Repeated Query Parameters

You can repeat query parameters in the query string to produce an array on the server side. Both querystring and qs handle this use case effectively:

> querystring.parse('a=b&a=c')
[Object: null prototype] { a: [ 'b', 'c' ] }
> qs.parse('a=b&a=c')
{ a: [ 'b', 'c' ] }

Drawback

With this approach, you may end up with either an array (if the parameter is repeated) or a string (if the parameter appears only once):

> querystring.parse('a=b&a=c')
[Object: null prototype] { a: [ 'b', 'c' ] }
> querystring.parse('a=b')
[Object: null prototype] { a: 'b' }

Using Explicit qs Syntax for Arrays

The qs parser provides more explicit and reliable notations to ensure the result is always an array, even if there's only one value. These options include:

• Bracket Notation

  > qs.parse('a[]=b&a[]=c')
  { a: [ 'b', 'c' ] }
  

• Index Notation

  > qs.parse('a[1]=c&a[0]=b')
  { a: [ 'b', 'c' ] }
  

These notations are particularly useful because they guarantee an array is returned, even for a single value:

> qs.parse('a[]=b')
{ a: [ 'b' ] }
> qs.parse('a=b')
{ a: 'b' }

Drawback

These notations do not work with querystring:

> querystring.parse('a[]=b')
[Object: null prototype] { 'a[]': 'b' }

Summary

• Repeated Parameters: Work with both parsers but return an array only when the parameter is repeated.
• qs Array Syntax: Guarantees an array but doesn’t work with querystring.

Documentation Insights

The official documentation is not very explicit about arrays of values in query strings. That is why we relied mostly in experimentation here. That said, it provides some relevant information here and there.

The Node.js querystring documentation includes an example showing repeated parameters result in an array:

For example, the query string 'foo=bar&abc=xyz&abc=123' is parsed into:

{
  foo: 'bar',
  abc: ['xyz', '123']
}

The qs documentation doesn’t explicitly mention repeated parameters for parsing but does confirm their behavior during stringification. In practice, repeated parameters work as expected:

> qs.parse('a=b&a=c')
{ a: [ 'b', 'c' ] }

Express has a tool to check if your path will match the route you are creating : Express.js route tester.

As Jose Mato says you have to decide how to structure your url:

1. ?foo=1&foo=2
2. ?foo[]=1&foo[]=2

The http request should look like this, if you chose method 1:

http://baseurl/api/?foo=1&foo=2

Your route should have this logic:

app.get('/api/:person', (req, res) => {
    /*This will create an object that you can iterate over.*/
    for (let foo of req.params.foo) {
      /*Do some logic here*/
    }
});

Here use this, '%2C' is the HTML encoding character for a comma.

jsonToQueryString: function (data) {
   return Object.keys(data).map((key) => {
        if (Array.isArray(data[key])) {
            return encodeURIComponent(`${key}=${data[key].map((item) => item).join('%2C')}`);
        }
        return encodeURIComponent(`${key}=${data[key]}`);
    }).join('&');
}

To access the query params

const names = decodeURIComponent(req.query.query_param_name);
const resultSplit = names.split(',');

Theres a problem when the array param contains only one value, because then it behaves like a simple string. Or when it doesn't contain any value.

Eg.:

• ?arrayParam=5
• ?
• ?arrayParam=5&arrayParam=6

Here's a function that always extracts the param with the given name, as an array:

export function extractArrQueryParams(
  req: express.Request,
  paramName: string
) {
  let param = req.query[paramName];
  let returnArray = [];

  if (Array.isArray(param)) {
    for (let e of param) {
      returnArray.push(e);
    }
  } else {
    if (param) {
      returnArray.push(param);
    }
  }

  return returnArray;
}

You can pass array elements separated by slashes - GET /api/person/foo/bar/...

Define your route as '/api/person/(:arr)*'

req.params.arr will have the first parameter. req.params[0] will have the rest as string. You split and create an array with these two.

app.get('/api/person/(:arr)*', function(req, res) {
        var params = [req.params.arr].concat(req.params[0].split('/').slice(1));
        ...
});

GET /api/person/foo
params = ["foo"]

GET /api/person/foo/bar
params = ["foo", "bar"]

...