How to Pass Arrays in a Query String in PHP and JavaScript

By the end of this page, you will understand how query strings represent repeated values, why arrays in URLs are not universally standardized, and which patterns are commonly used in PHP and JavaScript to send and read array-like query parameters safely.

A query string is the part of a URL after the ?, such as:

/search?q=books&page=2

It is made of key-value pairs separated by &:

• q=books
• page=2

The important idea is this:

• The URL standard clearly defines query strings as text data.
• It does not define a universal built-in "array type" for query parameters.
• That means arrays in query strings are usually represented by convention, not by a single official format understood identically everywhere.

Common conventions for arrays

Developers usually represent arrays in one of these ways:

1. Repeated parameter names

?tag=php&tag=javascript&tag=url

1. Bracket notation often used by PHP-style backends

?tag[]=php&tag[]=javascript&tag[]=url

1. Indexed bracket notation

?tag[0]=php&tag[1]=javascript&tag[2]=url

Think of a query string as a list of labeled sticky notes attached to a URL.

Each sticky note has:

• a label (tag)
• a value (php)

A query string does not inherently know what an array is. If you want to represent an array, you choose a pattern such as:

• attaching several sticky notes with the same label
• writing the label with brackets like tag[]
• putting several values into one sticky note separated by commas

So the browser just sends text. Your server or JavaScript code decides how to interpret that text as an array.

Common syntax patterns

1. Repeated parameter names

?myarray=value1&myarray=value2&myarray=value3

This is a very common and reasonable way to represent multiple values.

2. PHP-style bracket notation

?myarray[]=value1&myarray[]=value2&myarray[]=value3

This is especially convenient in PHP because PHP can parse this into an array automatically.

3. Indexed bracket notation

?myarray[0]=value1&myarray[1]=value2&myarray[2]=value3

Useful if the exact indexes matter.

PHP examples

Reading repeated parameter names

<?php
$query = 'myarray=value1&myarray=value2&myarray=value3';
parse_str($query, $result);
var_dump($result);

In plain PHP, parse_str() typically keeps the last value for duplicate keys unless bracket syntax is used. So this may become:

[
  'myarray' => 
]

Consider this JavaScript example:

const params = new URLSearchParams('?color=red&color=blue&page=2');

const firstColor = params.get('color');
const allColors = params.getAll('color');
const page = params.get('page');

console.log(firstColor);
console.log(allColors);
console.log(page);

Step by step

1. URLSearchParams reads the query string.
2. It sees three pairs:
   • color=red
   • color=blue
   • page=2
3. params.get('color') returns the first matching value:

"red"

1. params.getAll('color') returns values for that key:

Where this is used

Search and filtering

A shopping site may let users filter by multiple categories:

/products?category=books&category=tech

Tags or labels

A blog admin page may load posts with selected tags:

/posts?tag[]=php&tag[]=api

Multi-select form fields

A form with checkboxes often sends multiple values for the same field.

Batch operations

An admin tool may send multiple IDs:

/delete?ids[]=12&ids[]=18&ids[]=44

Frontend state in the URL

Single-page apps often store UI state in query parameters so links can be shared or bookmarked.

Why query strings are useful here

• They are easy to bookmark.
• They are visible and debuggable.
• They work well for read-only filtering and navigation.

For large or sensitive arrays, query strings are usually not ideal. In those cases, a POST body is often better.

In real projects, developers usually pick one convention based on the backend and framework.

Common patterns

1. Repeated keys for filters

APIs often accept repeated keys because they are simple and widely understood:

/users?role=admin&role=editor

In JavaScript:

const params = new URLSearchParams();
['admin', 'editor'].forEach(role => params.append('role', role));
console.log(params.toString());

2. PHP form handling with brackets

PHP developers often use bracket notation because it maps neatly into arrays:

?role[]=admin&role[]=editor

Then in PHP:

$roles = $_GET['role'] ?? [];

3. Validation and normalization

Real code often normalizes input before using it:

1. Assuming arrays are built into query strings

Beginners sometimes expect this to work universally:

?items=[1,2,3]

This is just a string unless your code explicitly parses it.

2. Expecting PHP and JavaScript to parse formats the same way

Broken assumption:

?myarray[]=a&myarray[]=b

• PHP treats myarray[] as an array pattern.
• JavaScript sees the key literally as myarray[] unless you add logic.

3. Using duplicate keys without checking parser behavior

Broken PHP expectation:

parse_str('x=1&x=2&x=3', $result);
var_dump($result);

You might expect an array, but plain PHP parsing often keeps only the last value.

4. Using comma-separated values without thinking about escaping

?tags=php,javascript,node,express

This works only if commas are safe separators for your data. If a value can contain commas, parsing becomes ambiguous.

5. Forgetting URL encoding

Broken example:

Quick reference

There is no universal query-string array type

A query string stores text key-value pairs. Arrays are represented by convention.

Common formats

?item=a&item=b&item=c
?item[]=a&item[]=b&item[]=c
?item[0]=a&item[1]=b
?item=a,b,c

PHP

Use bracket syntax if you want automatic array parsing:

$items = $_GET['item'] ?? [];

With URL:

?item[]=a&item[]=b

JavaScript

Use URLSearchParams:

const params = new URLSearchParams(location.search);
params.get('item');      // first value
params.getAll('item');   // all values

Recommended choices

• PHP app: item[]=a&item[]=b
• General web/API use:

Is there an official standard for arrays in query strings?

Not in a universal cross-language sense. Query strings are standardized as key-value text, but array representation is based on conventions.

Is repeating the same parameter name bad practice?

No. Repeating the same key, such as ?tag=php&tag=js, is a common and reasonable approach.

Should I use name=value1&name=value2 or name[]=value1&name[]=value2?

Use repeated keys for broad interoperability. Use bracket notation when working with PHP and you want automatic array parsing.

Does JavaScript automatically understand myarray[] as an array?

No. In JavaScript, URLSearchParams treats myarray[] as a literal parameter name unless you add your own parsing rules.

Does PHP automatically understand repeated keys as arrays?

Not usually with plain duplicate names alone. PHP reliably builds arrays when bracket notation like myarray[] is used.

Can I send complex nested arrays in a query string?

You can, but it becomes harder to read and maintain. For complex structured data, sending JSON in a request body is often better.

When should I avoid query strings for arrays?

Avoid them for large data, sensitive data, or deeply nested structures. Query strings are best for small, readable, shareable URL state.

• Query strings — The basic URL mechanism that carries key-value parameters.
• URL encoding — Important because special characters in query parameters must be encoded safely.
• GET vs POST — Helps decide whether data belongs in the URL or in the request body.
• PHP $_GET — Relevant for reading query parameters in PHP.
• JavaScript URLSearchParams — The standard browser API for reading and building query strings.
• Form submission — HTML forms often generate repeated query parameters for multi-value fields.
• Input validation — Needed to safely handle user-supplied query parameters.
• Serialization — Arrays must be converted into strings before they can travel in a URL.