Associative Array in PHP

An associative array in PHP is a collection of key-value pairs where each unique key is associated with a specific value. Keys can be strings or integers, while values can be of any data type.

Unlike numerically indexed arrays, where you access elements using numeric indices, associative arrays allow you to access elements or values using meaningful keys.

Associative array is particularly useful when you want to create dictionaries or mappings. For example, if you want to store the salaries of your employees in an array, a numerically indexed array would not be the best choice.

Instead, you can use the employees’ names as keys in an associative array, with their respective salaries as values. This approach enhances readability and makes it easier to manage the data.

Syntax of Creating Associative Array in PHP

You can create an associative array by defining both keys and values for each element in the array. You can define associative array using the array() function or the short array syntax [] introduced in PHP 5.4. The general syntax to create associative array in PHP using array() function is as follows:

$array_name = array (
   "key1" => "value1",
   "key2" => "value2",
   "key3" => "value3",

 // ... more key-value pairs
);

In the above syntax, $array_name is the name of the array. Keys can be either strings or integers, and the corresponding values can be of any data type, such as strings, integers, floats, arrays, or objects. The symbol (=>) is used to associate a key with its corresponding value.

Example 1:

$student_scores = array(
   "John" => 85,
   "Alice" => 90,
   "Bob" => 78
);

In this example, $student_scores is an associative array with three elements. Each element has a string key (‘John’, ‘Alice’, ‘Bob’) and a corresponding value (85, 90, 78).


This is older way of defining an array in PHP using array() function. However, it is fully supported by PHP. For PHP 5.4 and later, the short hand [] syntax is preferred to create an associative array for simplicity and readability.

Shorthand Syntax to Create Associative Array

The general syntax of defining an associative array in PHP using square brackets is as follows:

$array_name = [
   "key1" => "value1",
   "key2" => "value2",
   "key3" => "value3",

// ... more key-value pairs
];

This syntax is generally considered more modern and clean. Therefore, you can use it to create an array in PHP.

Example 2:

$salaries = [
   "Alice" => 50000,
   "Bob" => 45000,
   "Charlie" => 60000
];

Accessing Elements in Associative Array in PHP

To access an element in the associative array, you would use the key associated with the value that you want to access. The general syntax to access an associative array element in PHP is as follows:

$value = $array_name["key"];

In this syntax, $array_name is the name of the associative array. “key” represents the key of the element you want to access. It must match the key defined in the array. The $value specifies the variable to store the retrieved value. However, it is an optional.

Example 3:

<?php
// Creating an associative array.
$person = [
    "name" => "Jane Smith",
    "age" => 25,
    "email" => "janesmith@example.com"
];

// Accessing values.
echo $person["name"] . "\n";
echo $person["age"]  . "\n";
echo $person["email"];
?>

Output:
      Jane Smith
      25
      janesmith@example.com

If you try to access a key that doesn’t exist in the array will result an error:

echo $person["address"]; // PHP Warning: Undefined array key "address"

Modifying Elements in Associative Arrays

You can modify or update an existing element in the associative array by assigning a new value to it, using its key. Let’s take an example on it.

Example 4:

<?php
// Creating an associative array.
$person = [
    "name" => "Jane Smith",
    "age" => 25,
];

// Modifying an existing element in associative array.
$person["name"] = "Jane Doe";
echo $person["name"];
?>

Output:
      Jane Doe

Adding Elements in Associative Arrays

To add a new element in an associative array, we would define a new key-value pair.

Example 5:

<?php
$person = [
    "name" => "Jane Smith",
];

// Adding elements in associative array.
$person["age"] = 23;
$person["Address"] = "123 Main Street";

// Displaying array elements.
echo $person["name"] . "\n";
echo $person["age"] . "\n";
echo $person["Address"];
?>

Output:
      Jane Smith
      23
      123 Main Street

Iterating over Associative Arrays in PHP

You can iterate over elements of an associate arrays in PHP by using a foreach loop. Here’s an example of how you can do it.

Example 6:

<?php
$person = [
   "name" => "Bob",
   "age" => 35,
   "email" => "bob@example.com",
   "Address" => "1234 London Street"
];
// Iterating over elements of an associative array.
foreach ($person as $key => $value) {
   echo "$key: $value\n";
}
?>

Output:
      name: Bob
      age: 35
      email: bob@example.com
      Address: 1234 London Street

Passing Associative Array in PHP Functions

PHP also allows you to pass an associative array as an argument to a function and return them as well. Let’s take an example on it.

Example 7:

<?php
function getEmployeeDetails($employee) {
   $empDetail = "Name: " . $employee["name"] . ", Position: " . $employee["position"] . ", Salary: " . $employee["salary"];
   return $empDetail;
}
// Create an associative array.
$employee = [
   "name" => "Sophia",
   "position" => "Designer",
   "salary" => 35000
];
// Calling function.
echo getEmployeeDetails($employee);
?>

Output:
      Name: Sophia, Position: Designer, Salary: 35000

Common Operations on Associative Arrays

Checking a Key Exists

You can use the array_key_exists() function to check if a key exists in an array or not.

Example 8:

<?php
$person = ["name" => "Saanvi", "age" => 20];

if (array_key_exists("email", $person)) {
    echo "Email exists.";
} else {
    echo "Email does not exist.";
}
?>

Output:
      Email does not exist.

Getting All Keys and Values

PHP provides the array_keys() and array_values() functions to retrieve all keys or values from an associative array.

Example 9:

<?php
$person = ["name" => "Shanvika", "age" => 21, "email" => "shanvika@example.com"];

print_r(array_keys($person));
print_r(array_values($person));
?>

Output:
      Array
     (
        [0] => name
        [1] => age
        [2] => email
     )
     Array
     (
       [0] => Shanvika
       [1] => 21
       [2] => shanvika@example.com
     )

Sorting Associative Arrays in PHP

You can sort associative arrays by keys or values using various PHP functions:

  • asort(): Sorts by values.
  • ksort(): Sorts by keys.
  • arsort(): Sorts by values in reverse order.
  • krsort(): Sorts by keys in reverse order.

Example 10:

<?php
$person = ["name" => "Deep", "age" => 35, "email" => "deepak@example.com"];

// Sorting by keys
ksort($person);
print_r($person);

// Sorting by values
asort($person);
print_r($person);
?>

Output:
      Array
      (
        [age] => 35
        [email] => deepak@example.com
        [name] => Deep
      )
      Array
      (
        [age] => 35
        [name] => Deep
        [email] => deepak@example.com
      )

Example 11:

<?php
$person = [2 => "Deep", 1 => "John", 4 => "Saanvi", 3 => "Mark"];

// Sorting by keys
ksort($person);
print_r($person);

// Sorting by values
asort($person);
print_r($person);
?>

Output:
      Array
      (
        [1] => John
        [2] => Deep
        [3] => Mark
        [4] => Saanvi
      )
      Array
      (
        [2] => Deep
        [1] => John
        [3] => Mark
        [4] => Saanvi
      )

Best Practices for Associative Arrays

There are some key points that you should keep in mind while using associative array in PHP. They are as follows:

  • Use descriptive and meaningful keys that reflect the data being stored.
  • Avoid duplicate keys to prevent overwriting values. All keys must be unique.
    Keep data type for keys consistent. However, PHP allows mixed data types for keys, but it’s best to keep them uniform. For example, all strings or all integers.
  • Use isset() or array_key_exists() functions to avoid errors when accessing undefined keys.

Advantages of Associative Arrays over Indexed Arrays

There are the following advantages of using associative arrays over indexed arrays in PHP. They are as:

  • Associative arrays use meaningful keys instead of numeric indices, making the code easier to understand.
  • They allow direct access to values using keys, making them ideal for scenarios where you want a logical mapping of data. For example, name-to-value.
  • Keys can be strings or integers, which allow more descriptive and meaningful identifiers compared to fixed numeric indexes. For example, you can use “username”, “email”, or “id” as keys, which isn’t possible with indexed arrays.
  • An associative array helps to group related information logically. For instance, we can store an employee’s details using meaningful keys like “name”, “age”, “position”, etc.
  • Associative array is an excellent choice in PHP for handling dynamic data, like JSON responses or form submissions, where key-value pairs are often used.
  • This is perfect for creating mappings or dictionaries.
  • Since keys are descriptive in the associative array, modifying or updating the array later is easier and less error-prone compared to an indexed array, where numeric indexes can become confusing.

When to Use Associative Arrays?

You can use associative arrays when:

  • You need to represent data in the form of key-value pairs.
  • You want to improve code readability and maintainability.
  • You are working with structured data like user profiles, product details, or mappings.

 

Associative arrays in PHP are a powerful and versatile data structure that allows you to store and manage data efficiently using key-value pairs. By understanding their syntax, usage, and best practices, you can write clean, efficient, and error-free PHP code when working with arrays.

Related Posts

Trending now

What Is Cybersecurity Risk Management
Variadic Functions in PHP
PHP Arrays
Indexed Array in PHP