class URLSearchParams
implements Iterable<[string, string]>
Usage in Deno
```typescript import { URLSearchParams } from "node:node__url.d.ts"; ```The `URLSearchParams` API provides read and write access to the query of a `URL`. The `URLSearchParams` class can also be used standalone with one of the
four following constructors.
The `URLSearchParams` class is also available on the global object.
The WHATWG `URLSearchParams` interface and the `querystring` module have
similar purpose, but the purpose of the `querystring` module is more
general, as it allows the customization of delimiter characters (`&` and `=`).
On the other hand, this API is designed purely for URL query strings.
```js
const myURL = new URL('https://example.org/?abc=123');
console.log(myURL.searchParams.get('abc'));
// Prints 123
myURL.searchParams.append('abc', 'xyz');
console.log(myURL.href);
// Prints https://example.org/?abc=123&abc=xyz
myURL.searchParams.delete('abc');
myURL.searchParams.set('a', 'b');
console.log(myURL.href);
// Prints https://example.org/?a=b
const newSearchParams = new URLSearchParams(myURL.searchParams);
// The above is equivalent to
// const newSearchParams = new URLSearchParams(myURL.search);
newSearchParams.append('a', 'c');
console.log(myURL.href);
// Prints https://example.org/?a=b
console.log(newSearchParams.toString());
// Prints a=b&a=c
// newSearchParams.toString() is implicitly called
myURL.search = newSearchParams;
console.log(myURL.href);
// Prints https://example.org/?a=b&a=c
newSearchParams.delete('a');
console.log(myURL.href);
// Prints https://example.org/?a=b&a=c
```
new
URLSearchParams(init?: URLSearchParams
| string
| Record<string, string | readonly string[]>
| Iterable<[string, string]>
| ReadonlyArray<[string, string]>)
readonly
size: number
The total number of parameter entries.
[Symbol.iterator](): IterableIterator<[string, string]>
append(name: string,value: string,): void
Append a new name-value pair to the query string.
delete(name: string,value?: string,): void
If `value` is provided, removes all name-value pairs
where name is `name` and value is `value`.
If `value` is not provided, removes all name-value pairs whose name is `name`.
entries(): IterableIterator<[string, string]>
Returns an ES6 `Iterator` over each of the name-value pairs in the query.
Each item of the iterator is a JavaScript `Array`. The first item of the `Array` is the `name`, the second item of the `Array` is the `value`.
Alias for `urlSearchParams[@@iterator]()`.
forEach<TThis = this>(fn: () => void,thisArg?: TThis,): void
Iterates over each name-value pair in the query and invokes the given function.
```js
const myURL = new URL('https://example.org/?a=b&c=d');
myURL.searchParams.forEach((value, name, searchParams) => {
console.log(name, value, myURL.searchParams === searchParams);
});
// Prints:
// a b true
// c d true
```
get(name: string): string | null
Returns the value of the first name-value pair whose name is `name`. If there
are no such pairs, `null` is returned.
getAll(name: string): string[]
Returns the values of all name-value pairs whose name is `name`. If there are
no such pairs, an empty array is returned.
has(name: string,value?: string,): boolean
Checks if the `URLSearchParams` object contains key-value pair(s) based on `name` and an optional `value` argument.
If `value` is provided, returns `true` when name-value pair with
same `name` and `value` exists.
If `value` is not provided, returns `true` if there is at least one name-value
pair whose name is `name`.
keys(): IterableIterator<string>
Returns an ES6 `Iterator` over the names of each name-value pair.
```js
const params = new URLSearchParams('foo=bar&foo=baz');
for (const name of params.keys()) {
console.log(name);
}
// Prints:
// foo
// foo
```
set(name: string,value: string,): void
Sets the value in the `URLSearchParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,
set the first such pair's value to `value` and remove all others. If not,
append the name-value pair to the query string.
```js
const params = new URLSearchParams();
params.append('foo', 'bar');
params.append('foo', 'baz');
params.append('abc', 'def');
console.log(params.toString());
// Prints foo=bar&foo=baz&abc=def
params.set('foo', 'def');
params.set('xyz', 'opq');
console.log(params.toString());
// Prints foo=def&abc=def&xyz=opq
```
sort(): void
Sort all existing name-value pairs in-place by their names. Sorting is done
with a [stable sorting algorithm](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability), so relative order between name-value pairs
with the same name is preserved.
This method can be used, in particular, to increase cache hits.
```js
const params = new URLSearchParams('query[]=abc&type=search&query[]=123');
params.sort();
console.log(params.toString());
// Prints query%5B%5D=abc&query%5B%5D=123&type=search
```
toString(): string
Returns the search parameters serialized as a string, with characters
percent-encoded where necessary.
values(): IterableIterator<string>
Returns an ES6 `Iterator` over the values of each name-value pair.