Php arrays key value pairs

PHP arrays tutorial: Understand PHP arrays in 5 minutes

In computer science, an array is a data structure that stores multiple values in a single variable. Think of this like a list of values. Arrays are a powerful tool for storing variables that you can access easily, as you access values by referring to their index number.

In this tutorial, we will introduce you to PHP arrays. We’ll show you how to write them and work with them. We’ll wrap up with a few hands-on problems.

Today’s tutorial at a glance:

Learn one of the most popular languages in the world.

This highly interactive course introduces you to fundamental programming concepts in PHP, all in one place.

What are arrays in PHP?

Simply put, an array in PHP is a list, much like how in In JavaScript, an array is a list of values. For example, you could create an array of integers, like [1, 2, 3, 4, 5] or of a mixed data types, like [false, 40, ‘purple’, $object, ‘puppy’] .

This makes it possible to hold multiple values under a shared name that can be accessed by referring to an index number, with the first element at index 0.

As you can see, the total number of elements in an array is the length of an array. With arrays, length is dynamic and can be changed over time.

PHP treats arrays a bit differently than you might be used to. In PHP, there are multiple kinds of arrays that keep different data types. PHP offers more structured arrays where we can keep sets of “key-value” pairs.

Here are three types of arrays we can use in PHP:

• Indexed/numeric arrays: arrays with a numeric index
• Associative arrays: arrays with named keys
• Multidimensional arrays: arrays that hold one or more arrays

Associative arrays in PHP give us more context and information, making it very useful for web development and other programming needs. All PHP arrays are associative in nature, and you may already be used to this style.

In Python, for example, these are called dictionaries, and in JavaScript, we could code the same behavior with objects.

Источник

Php arrays key value pairs

// Before php 5.4
$array = array(1,2,3);

// since php 5.4 , short syntax
$array = [1,2,3];

// I recommend using the short syntax if you have php version >= 5.4

Used to creating arrays like this in Perl?

Looks like we need the range() function in PHP:

$array = array_merge (array( ‘All’ ), range ( ‘A’ , ‘Z’ ));
?>

You don’t need to array_merge if it’s just one range:

There is another kind of array (php>= 5.3.0) produced by

$array = new SplFixedArray(5);

Standard arrays, as documented here, are marvellously flexible and, due to the underlying hashtable, extremely fast for certain kinds of lookup operation.

Supposing a large string-keyed array

$arr=[‘string1’=>$data1, ‘string2’=>$data2 etc. ]

when getting the keyed data with

php does *not* have to search through the array comparing each key string to the given key (‘string1’) one by one, which could take a long time with a large array. Instead the hashtable means that php takes the given key string and computes from it the memory location of the keyed data, and then instantly retrieves the data. Marvellous! And so quick. And no need to know anything about hashtables as it’s all hidden away.

However, there is a lot of overhead in that. It uses lots of memory, as hashtables tend to (also nearly doubling on a 64bit server), and should be significantly slower for integer keyed arrays than old-fashioned (non-hashtable) integer-keyed arrays. For that see more on SplFixedArray :

Unlike a standard php (hashtabled) array, if you lookup by integer then the integer itself denotes the memory location of the data, no hashtable computation on the integer key needed. This is much quicker. It’s also quicker to build the array compared to the complex operations needed for hashtables. And it uses a lot less memory as there is no hashtable data structure. This is really an optimisation decision, but in some cases of large integer keyed arrays it may significantly reduce server memory and increase performance (including the avoiding of expensive memory deallocation of hashtable arrays at the exiting of the script).

When creating arrays , if we have an element with the same value as another element from the same array, we would expect PHP instead of creating new zval container to increase the refcount and point the duplicate symbol to the same zval. This is true except for value type integer.
Example:

$arr = [‘bebe’ => ‘Bob’, ‘age’ => 23, ‘too’ => 23 ];
xdebug_debug_zval( ‘arr’ );

(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=0, is_ref=0)int 23
‘too’ => (refcount=0, is_ref=0)int 23

but :
$arr = [‘bebe’ => ‘Bob’, ‘age’ => 23, ‘too’ => ’23’ ];
xdebug_debug_zval( ‘arr’ );

(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=0, is_ref=0)int 23
‘too’ => (refcount=1, is_ref=0)string ’23’ (length=2)
or :

$arr = [‘bebe’ => ‘Bob’, ‘age’ => [1,2], ‘too’ => [1,2] ];
xdebug_debug_zval( ‘arr’ );

(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=2, is_ref=0)
array (size=2)
0 => (refcount=0, is_ref=0)int 1
1 => (refcount=0, is_ref=0)int 2
‘too’ => (refcount=2, is_ref=0)
array (size=2)
0 => (refcount=0, is_ref=0)int 1
1 => (refcount=0, is_ref=0)int 2

This function makes (assoc.) array creation much easier:

function arr (. $array )< return $array ; >
?>

It allows for short syntax like:

$arr = arr ( x : 1 , y : 2 , z : 3 );
?>

Instead of:

$arr = [ «x» => 1 , «y» => 2 , «z» => 3 ];
// or
$arr2 = array( «x» => 1 , «y» => 2 , «z» => 3 );
?>

Sadly PHP 8.2 doesn’t support this named arguments in the «array» function/language construct.

Источник

PHP Arrays Tutorial

In this tutorial lesson we will learn about Arrays, and how they allow us to store multiple data elements in a single container.

What is an array?

An array in PHP is a data type that allows storage of many data elements in a single container, as key/value pairs. We can think of it as a container that can hold many variables.

As an example, let’s consider the word “Hello”. The word consists of 5 separate letters, combined into something that provides meaning.

Now consider a table with a single row and 5 columns, where each cell contains one letter.

To create the word “Hello” from this table, we would need to output the letters of the table in sequence.

A string is actually an array of single characters. In a language like C, there is no string data type and we would instead need to create a word or a sentence as an array.

PHP stores array elements as key/value pairs. Every letter in our array has a corresponding number, or word, that we can use to get access to the element value.

By default, the lowest number corresponds to the first element in the array.

Arrays with numerical indexes will always start at 0, not at 1.

It’s beneficial to use an array, instead of many variables, when working with larger amounts of data that we will access together.

Array elements get stored in memory together, in sequence. This means that lookup processing is faster, allowing the application to be more performant.

How to create an array

In PHP, there are three types of arrays:

• Indexed arrays are arrays with a numeric index.
• Associative arrays are arrays with named keys as key/value pairs.
• Multi-dimensional arrays are arrays that contain one or more arrays inside them.

We create, or define, arrays in one of two ways:

How to define an indexed array with square brackets

The easiest method to define an array is to assign multiple, comma separated values between square brackets to a variable.

This method of definition is also the most common, which is why we introduce it first.

 Example: 5.4+ array definition with square brackets

The syntax in the example above is only available in PHP 5.4 and up.

Another thing to note is that, unlike many other languages, like C, we can store different data types in the same array.

How to define an indexed array with the array() function

The original method to create an array is to use the array() function.

We specify the word array , immediately followed by parentheses. Inside the open and close parentheses, we specify a comma-separated list of values.

 Example: array definition with array() function

The definition of the array is almost identical to the shorthand, except for the function syntax.

How to access elements in an array

PHP provides us with two methods to access the values of an array:

• The Indexer, that can specify single specific elements.
• Loops, that can iterate over all the elements inside an array.

How to access array elements with the indexer

The indexer allows us to access a single value at a specific numerical index in the array. The indexer is a pair of open and close square brackets [ ] , with the index number between them.

 Example: access array with the indexer

The example above will print the value at index 0 (Hello), to the page.

If we try to use an index for a value that doesn’t exist, the interpreter would raise an error.

How to access array elements with a foreach loop

If you are a beginner, loops and iteration control may not make much sense at this point. We cover looping again in the Iteration Control: Foreach tutorial lesson, so it’s okay if you don’t understand them right now.

Because an array is a collection of many values, it makes sense to use a control structure that can access all those values in one execution. One of these structures is called a foreach loop.

In a foreach loop, the interpreter will go through the array, one value at a time, and store it in a temporary variable.

We then access each array element, with that temporary variable, inside the loop’s execution block.

Источник