For convenience, it would be nice to have a method that can pluck the query string from a url:

var qs = require("query-string");
var url = "http://some.url/with?a=few&query=params";
var query = qs.getQuery(url); // "?a=few&query=params"
qs.parse(query); // { a : "few", query : "params" }

in 3.0.1, parse had the following behavior:

> qs.parse('my-param=my-val')
{ 'my-param': 'my-val' }
> qs.parse('my-param=my-val').hasOwnProperty
[Function: hasOwnProperty]
> qs.parse('h=j').hasOwnProperty
[Function: hasOwnProperty]
> qs.parse('').hasOwnProperty
[Function: hasOwnProperty]

in 3.0.2, the object returned no longer has the hasOwnProperty method:

> qs.parse('hbud-fixture=not-logged-in')
{ 'hbud-fixture': 'not-logged-in' }
> qs.parse('hbud-fixture=not-logged-in').hasOwnProperty
undefined
> qs.parse('hbudfixture=not-logged-in').hasOwnProperty
undefined
> qs.parse('hbudfixture=notloggedin').hasOwnProperty
undefined
> qs.parse('').hasOwnProperty
[Function: hasOwnProperty]
> qs.parse('h=j').hasOwnProperty
undefined

I am unsure whether this was considered part of the API, but some consumers rely on the behavior - https://github.com/mjackson/history/blob/master/modules/useQueries.js#L13

To eliminate unneeded params, preserve only needed

queryString.strip('http://example.com/?a=1&b=2', [ 'a' ] )
// result : http://example.com/?a=1

It would be helpful when page has many redudant params (like statistic params) and want to get a cleaner one

Better function names from @Uzlopak:

queryString.pick('http://example.com/?a=1&b=2', [ 'a' ] )
// result : http://example.com/?a=1


queryString.exclude('http://example.com/?a=1&b=2', [ 'a' ] )
// result : http://example.com/?b=2

Version: v7.1.1

Crash occured when # kun%ea%ba%5a%ba is parsed by queryString.parse This hash is valid and should be parsed correctly as { ' kun%ea%ba%5a%ba': null } For example in chrome's development tools' console the url https://google.com# kun%ea%ba%5a%ba can be parsed without problems:

const url = new URL("https://google.com#  kun%ea%ba%5a%ba");
url

Code to reproduce

const queryString = require('query-string');

const parsed = queryString.parse("#  kun%ea%ba%5a%ba");
console.log(parsed);

Results

TypeError: decodeComponents(...).join is not a function

Fixes #220

Add a new option parseFragment, which will provide the hash in the parseURL result. The new option is to prevent it from becoming a breaking change

Seems Fragment Identifier is the technical jargon for it, let me know if it's ok or hash seems like a better choice

cc\ @sindresorhus

Hi! If query string starts with &, result from parse will be { '': null, data: 'item' }

console.log(query.parse("&data=item")); //{ '': null, data: 'item' }

So, I've just a made more predictable behavior.

console.log(query.parse("&data=item")); //{ data: 'item' }

Using the following code snippet I am getting a type error in v8.0.0

import queryString from 'query-string';

queryString.parse(window.location.search);

Hello, I have an issue with stringifyUrl error. I couldn't find info about this anywhere so that's the reason i'm posting here.

So this is a piece of code i'm trying to implement and in gives me this error. It is imported in this file like import queryString from 'query-string'

The strange thing about this is when i paste the same code into online editor it all works as expected.

Version of query-string is '6.11.0'.

Thanks

For whatever reason, I need to send these kinds of query strings to a server:

_embed=1&settings[prefetch]=false&settings[expiry]=3600

I figured I'd use a similar data structure; a JavaScript object, and was a bit annoyed when stringifying {settings: { prefetch: false, expiry: 3600 }} resulted in an url encoded [object object].

This fixes that. I added a new arrayFormat option, key.

I tried giving a shot at parse, but we need one way conversion only at this point, and I couldn't figure it out in 10 minutes, so I gave up. Regular expressions are incomprehensible to me.

When stringifying an object where a value is undefined, previously the value would be passed along as 'undefined'. Now we remove it from the resulting query string entirely. This makes qs.stringify() more consistent with JSON.stringify().

The idea behind this format is to gain the advantages of short query strings that you have with comma and separator formats while marking a field as explicitly an array via a postfixed [] syntax.

import queryString from 'query-string'

queryString.stringify({ foo: ['one'] }, { arrayFormat: 'bracket-separator' })
// => foo[]=one

queryString.stringify({ foo: ['one', 'two', '', 'four' ] }, { arrayFormat: 'bracket-separator' })
// => foo[]=one,two,,four

queryString.stringify({ foo: ['one', 'two', '', 'four'] }, { arrayFormat: 'bracket-separator', arrayFormatSeparator: '|' })
// => foo[]=one|two||four

queryString.parse('?foo[]=one', { arrayFormat: 'bracket-separator' })
// => {foo: ['one']

queryString.parse('?foo[]=one,two,,four', { arrayFormat: 'bracket-separator' })
// => {foo: ['one', 'two', '', 'four']}

queryString.parse('?foo[]=one|two||four', { arrayFormat: 'bracket-separator', arrayFormatSeparator: '|' })
// => {foo: ['one', 'two', '', 'four']}

There are still are 2 question in regards to implementation:

What should happen for {foo: []}? Currently, it would drop the parameter from the stringified query which is the same as {foo: null}

This is undesirable personally. I feel like {foo: []} should produce ?foo[] unless I specify a flag to drop it. This would be a deviation from the ?bar&biz that non-arrays get the treatment of when they are null (no trailing =), but I feel like it makes sense as we have enough information to say, explicitly, that this is an array. Whereas if it were {foo: null} we don't know, explicitly, that this is an array, so it would produce ?foo which would mean that it would roundtrip correctly. However, the only way to produce this would be to change how the system is using Array.prototype.reduce as the reducer function is not ever invoked when the array is empty.

What should happen for {foo: ['one', null, 'three']}. Currently it will drop the null and produce foo[]=one,three

~I haven't a strong opinion on this as it matches the functionality of separator. The only deviation from the separator functionality in regards to value dropping is that bracket-separator does not drop empty strings.~

[Edit]: This has been changed to follow the skipNull and skipEmptyString options. As such, by default, null and '' will not be dropped. See https://github.com/sindresorhus/query-string/pull/304 for details. Thus, the following are true: | Input | Options | Output | | ------------- | ------------- | ------------ | | {foo: ['one', '', null, 'four']} | default settings | foo[]=one,,,four | | {foo: ['one', '', null, 'four']} | skipNull: true | foo[]=one,,four | | {foo: ['one', '', null, 'four']} | skipEmptyString true | foo[]=one,,four | | {foo: ['one', '', null, 'four']} | skipEmptyString true, skipNull: true | foo[]=one,four |

When I am using queryString.stringify({foo: [1, 2, 3]}, {arrayFormat: 'comma'}); the result is 'foo=1,2,3', is there a way to get the entire string encoded to 'foo%3D1%2C2%2C3', which is a result of encodeURIComponent('foo=1,2,3')?

I am trying to clean a URL and only keep some parameters that I need in order to parse them so I was using pick method providing it the url, and the filter which is a regex test method here I am testing to check if the key in the query parameter matches the regular expression

const groupRegex = new RegExp('^(GRP_)[a-zA-Z0-9/-]','g');
export const parseGroups= (url:string)=>{
    let pickedURL = qs.pick(url,(key,value)=>groupRegex.test(key));
    console.log(pickedURL);
}
var url=`http://localhost:3000/tat?GRP_Bob[]=SW&GRP_sa[]=QW&GRP_sa[]=AA&projects[]=MP,PM&releases[]=2021.4,2022.1`
parseGroups(url)

for example http://localhost:3000/tat?GRP_Bob[]=SW&GRP_sa[]=QW&GRP_sa[]=AA&projects[]=MP,PM&releases[]=2021.4,2022.1 it should return http://localhost:3000/tat?GRP_Bob=SW&GRP_sa=QW&GRP_sa=AA yet it only tests for the first request parameter only and logs http://localhost:3000/tat?GRP_Bob%5B%5D=SW

I am trying to clean the url from any other parameters that doesn't match my regular expression so I can parse the URL and extract the object so it can be like this for example

{
       GRP_Bob:["SW"],
       GRP_sa:["QW","AA"]
 }

Instead of having other parameters parsed also which are not necessary. I know I can just parse the url normally, and then loop on the returned query object, and remove any key that doesn't match the regex, but is there anything wrong I am doing in the above snippet?

UPDATE: I changed the filter function to be (key,value)=>key.startsWith('GRP_'))

export const parseGroups= (url:string)=>{
    let pickedURL = qs.pick(url,(key,value)=>key.startsWith('GRP_'));
    console.log(pickedURL);
    let parsedURL = qs.parseUrl(pickedURL)
    console.log(parsedURL.query)
}
var url=`http://localhost:3000/tat?GRP_Bob[]=SW&GRP_sa[]=QW&GRP_sa[]=AA&projects[]=MP,PM&releases[]=2021.4,2022.1`
parseGroups(url)

and the pickedURL logged this http://localhost:3000/tat?GRP_Bob%5B%5D=SW&GRP_sa%5B%5D=QW&GRP_sa%5B%5D=AA which is likely to be correct. it came out like that

GRP_Bob[]: "SW"
GRP_sa[]: (2) ['QW', 'AA']

So I am confused actually what's going on with the regular expression approach, and why the keys in the second approach have [] in it?

I have an issue with array params url: 1. ?categoryIds=1&categoryIds=2 => categoryIds=['1', '2'] : Right 2. ?categoryIds=1 => categoryIds='1' : Wrong => Expect: categoryIds=['1'] Could you add regex option for arrayFormat ? Or everyone have a solution for this. Big thanks to you 🙇

Hello. I am trying to parse an array of elements separated by the pipe character '|'. The elements themselves might contain the pipe char, hence those should be encoded first (to %7C). With array of 2 elements or above it works just fine. However with array of one element it doesn't. My guess is that parse doesn't see explicitly pipe char, it decodes %7C into pipe char and creates array of 2 elements. (A side note: this method with other special characters works just fine.) please refer the following code example:

// begin of code
function TestQueryString(): void {
  const value1: string = encodeURIComponent('a|b'); 
  const twoElements = parse(`foo=${value1}|2`, {
    arrayFormat: 'separator',
    arrayFormatSeparator: '|',
  });
  console.log(twoElements); // Works as expected got: [ 'a|b', '2']

  const oneElement = parse(`bar=${value1}`, {
    arrayFormat: 'separator',
    arrayFormatSeparator: '|',
  });
  console.log(oneElement); // Here is the issue. Expected: 'a|b' but got [ 'a', 'b']
}
// end of code

Screenshot with '|'. Not expected behavior in one element case:

Screenshot with '%'. Expected behavior as another special characters:

Thanks,

It seems keys generated from arrays with arrayFormat: 'bracket' don't get urlEncoded:

stringify({ a: [1, 2, 3 ]}, { arrayFormat: 'bracket' }); => a[]=1&a[]=2&a[]=3

I want to exclude a value of an array from query string. How I can do this?

  const removeFilter = (filterKey, filterValue) => {
    const test = queryString.exclude(
      location.search,
      (key, value) => {
        return (
          key === filterKey &&
          (Array.isArray(value) ? value.includes(filterValue) : value === filterValue.toString())
        );
      },
      {
        arrayFormat: 'comma',
      }
    );
    history.push({ search: test });
  };