please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).Низи
Почист и полокален преглед на PHP референцата, со задржана структура од PHP.net и подобра читливост за примери, секции и белешки.
Низи
Референца за `language.types.array.php` со подобрена типографија и навигација.
Низи
За листа на сите функции за низи, видете го поглавјето за функции за низи во документацијата.
Еден array во PHP е всушност подредена мапа. Мапа е тип што асоцира values to keys. Овој тип е оптимизиран за неколку различни употреби; може да се третира како низа, листа (вектор), хеш табела (имплементација на мапа), речник, колекција, стек, редица и веројатно повеќе. Бидејќи array вредностите можат да бидат други arrayи дрвја и повеќедимензионални arrayсе исто така можни.
Објаснувањето на тие структури на податоци е надвор од опсегот на овој прирачник, но барем еден пример е даден за секоја од нив. За повеќе информации, погледнете ја обемната литература што постои за оваа широка тема.
Синтакса
Специфицирање со array()
Еден array може да се креира со помош на array()
конструкција на јазикот. Таа зема кој било број на одделени со запирка
key => value парови како аргументи.
array(
key => value,
key2 => value2,
key3 => value3,
...
)
Запирката по последниот елемент на низата е опционална и може да се изостави. Ова обично се прави за низи во еден ред, т.е. array(1, 2) е претпочитано пред
array(1, 2, ). За низи во повеќе редови, од друга страна, запирката на крајот обично се користи, бидејќи овозможува полесно додавање нови елементи на крајот.
Забелешка:
Постои кратка синтакса за низи што ја заменува
array()with[].
Пример #1 Едноставна низа
<?php
$array1 = array(
"foo" => "bar",
"bar" => "foo",
);
// Using the short array syntax
$array2 = [
"foo" => "bar",
"bar" => "foo",
];
var_dump($array1, $array2);
?>На key може да биде int или stringќе треба да се прилагоди, и value може да биде од било кој тип.
Дополнително ќе се случат следните key кастирања:
-
Низаите што содржат валиден децимален intи, освен ако бројот не му претходи
+знак, ќе бидат кастирани во int тип. На пр. клучот"8"всушност ќе биде зачуван под8. Од друга страна"08"нема да биде кастиран, бидејќи не е валиден децимален цел број. -
Пловечкии исто така се кастираат во intи, што значи дека децималниот дел ќе биде скратен. На пр. клучот
8.7всушност ќе биде зачуван под8. -
Буловскии се кастираат во intи исто така, т.е. клучот
trueвсушност ќе биде зачуван под1и клучотfalseunder0. -
Види ќе бидат кастирани во празен стринг, т.е. клучот
nullвсушност ќе биде зачуван под"". -
Низаи objects не може да се користи како клучеви. Правењето на ова ќе резултира со предупредување:
Illegal offset type.
Ако повеќе елементи во декларацијата на низата користат ист клуч, само последниот ќе се користи бидејќи сите други се презапишани.
Ако повеќе елементи во декларацијата на низата користат ист клуч, само последниот ќе се користи бидејќи сите други се препишани.
<?php
$array = array(
1 => "a",
"1" => "b",
1.5 => "c",
true => "d",
);
var_dump($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(1) {
[1]=>
string(1) "d"
}
Пример #2 Пример за кастирање на тип и препишување 1Бидејќи сите клучеви во горниот пример се кастирани на "d" , вредноста ќе биде препишана при секој нов елемент и последната доделена вредност
е единствената што останува. int and string PHP низите можат да содржат
клучеви во исто време бидејќи PHP не прави разлика помеѓу индексирани и асоцијативни низи. int and string keys
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
100 => -100,
-100 => 100,
);
var_dump($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(4) {
["foo"]=>
string(3) "bar"
["bar"]=>
string(3) "foo"
[100]=>
int(-100)
[-100]=>
int(100)
}
На key Пример #3 Мешано int key.
е опционално. Ако не е специфицирано, PHP ќе го користи зголемувањето на најголемиот претходно користен
<?php
$array = array("foo", "bar", "hello", "world");
var_dump($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(4) {
[0]=>
string(3) "foo"
[1]=>
string(3) "bar"
[2]=>
string(5) "hello"
[3]=>
string(5) "world"
}
Пример #4 Индексирани низи без клуч
Можно е да се специфицира клуч само за некои елементи и да се изостави за други:
<?php
$array = array(
"a",
"b",
6 => "c",
"d",
);
var_dump($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(4) {
[0]=>
string(1) "a"
[1]=>
string(1) "b"
[6]=>
string(1) "c"
[7]=>
string(1) "d"
}
Пример #5 Клучеви не на сите елементи "d" Како што можете да видите последната вредност
7ѝ беше доделен клучот 6.
. Ова е затоа што најголемиот цел број пред тоа беше
Пример #6 Комплексен пример за кастирање на тип и препишување
<?php
$array = array(
1 => 'a',
'1' => 'b', // the value "a" will be overwritten by "b"
1.5 => 'c', // the value "b" will be overwritten by "c"
-1 => 'd',
'01' => 'e', // as this is not an integer string it will NOT override the key for 1
'1.5' => 'f', // as this is not an integer string it will NOT override the key for 1
true => 'g', // the value "c" will be overwritten by "g"
false => 'h',
'' => 'i',
null => 'j', // the value "i" will be overwritten by "j"
'k', // value "k" is assigned the key 2. This is because the largest integer key before that was 1
2 => 'l', // the value "k" will be overwritten by "l"
);
var_dump($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(7) {
[1]=>
string(1) "g"
[-1]=>
string(1) "d"
["01"]=>
string(1) "e"
["1.5"]=>
string(1) "f"
[0]=>
string(1) "h"
[""]=>
string(1) "j"
[2]=>
string(1) "l"
}
Овој пример вклучува сите варијации на кастирање на клучеви и препишување на елементи.
Пример #7 Пример за негативен индекс nПри доделување на негативен цел клучен n+1.
<?php
$array = [];
$array[-5] = 1;
$array[] = 2;
var_dump($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(2) {
[-5]=>
int(1)
[-4]=>
int(2)
}
Пред PHP 8.3.0, доделувањето на негативен клучен број n би доделило следниот клучен број на 0, претходниот пример затоа би прикажал:
array(2) {
[-5]=>
int(1)
[0]=>
int(2)
}
Пристап до елементите на низата со синтаксија со квадратни загради
Елементите на низата може да се пристапат со користење на array[key] syntax.
Пример #8 Пристап до елементите на низата
<?php
$array = array(
"foo" => "bar",
42 => 24,
"multi" => array(
"dimensional" => array(
"array" => "foo"
)
)
);
var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
string(3) "bar" int(24) string(3) "foo"
Забелешка:
Пред PHP 8.0.0, квадратни и кадрави загради можеа да се користат наизменично за пристап до елементите на низата (на пр.
$array[42]and$array{42}би правеле исто во горниот пример). Синтаксата со кадрави загради беше отфрлена од PHP 7.4.0 и повеќе не се поддржува од PHP 8.0.0.
Пример #9 Дереференцирање на низа
<?php
function getArray() {
return array(1, 2, 3);
}
$secondElement = getArray()[1];
var_dump($secondElement);
?>Забелешка:
Обидот за пристап до клучен елемент на низа што не е дефиниран е исто како пристап до која било друга недефинирана променлива: ќе се издаде порака за грешка од ниво
E_WARNING-ниво (E_NOTICE-ниво пред PHP 8.0.0) ќе се издаде, и резултатот ќе бидеnull.
Забелешка:
Дереференцирање на скаларна вредност што не е string yields
null. Пред PHP 7.4.0, ова не издаваше порака за грешка. Од PHP 7.4.0, ова издаваE_NOTICE; од PHP 8.0.0, ова издаваE_WARNING.
Креирање/модифицирање со синтаксија со квадратни загради
Постоечки array може да се модифицира со експлицитно поставување вредности во него.
Ова се прави со доделување вредности на array, наведувајќи го клучот во загради. Клучот исто така може да се изостави, што резултира со празен пар загради ([]).
$arr[key] = value; $arr[] = value; // key may be an int or string // value may be any value of any type
Враќа $arr сè уште не постои или е поставен на null or false, ќе биде креиран, така што ова е исто така алтернативен начин за креирање на array. Оваа практика, сепак, се обесхрабрува бидејќи ако $arr веќе содржи некоја вредност (на пр. string од променлива за барање) тогаш оваа вредност ќе остане на место и [] може всушност да значи оператор за пристап до низа. Секогаш е подобро да се иницијализира променлива со директно доделување.
Забелешка: Од PHP 7.1.0, примена на операторот за празен индекс на низа фрла фатална грешка. Претходно, низата беше тивко претворена во низа.
Забелешка: Од PHP 8.1.0, креирање нова низа од
falseвредност е депресирана. Креирање нова низа одnullи недефинирани вредности сè уште е дозволено.
За да промените одредена вредност, доделете нова вредност на тој елемент користејќи го неговиот клуч. За да отстраните пар клуч/вредност, повикајте го unset() функција на неа.
Пример #10 Користење квадратни загради со низи
<?php
$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // This is the same as $arr[13] = 56;
// at this point of the script
$arr["x"] = 42; // This adds a new element to
// the array with key "x"
unset($arr[5]); // This removes the element from the array
var_dump($arr);
unset($arr); // This deletes the whole array
var_dump($arr);
?>Забелешка:
Како што споменавме погоре, ако не е специфициран клуч, се зема максимумот од постоечките int индекси, а новиот клуч ќе биде тој максимум плус 1 (но најмалку 0). Ако нема int индекси постојат сè уште, клучот ќе биде
0(нула).Имајте предвид дека максималниот цел клуч што се користи за ова не мора моментално да постои во array. Мора да постоел само во array во одреден момент од последното време кога array беше повторно индексиран. Следниот пример илустрира:
<?php
// Create a simple array.
$array = array(1, 2, 3, 4, 5);
print_r($array);
// Now delete every item, but leave the array itself intact:
foreach ($array as $i => $value) {
unset($array[$i]);
}
print_r($array);
// Append an item (note that the new key is 5, instead of 0).
$array[] = 6;
print_r($array);
// Re-index:
$array = array_values($array);
$array[] = 7;
print_r($array);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 )
Деструктурирање на низи
Низите можат да се деструктурираат со користење на [] (од PHP 7.1.0) или
list() јазични конструкции. Овие конструкции можат да се користат за деструктурирање на низа во посебни променливи.
Пример #11 Деструктурирање на низи
<?php
$source_array = ['foo', 'bar', 'baz'];
[$foo, $bar, $baz] = $source_array;
echo $foo, PHP_EOL; // prints "foo"
echo $bar, PHP_EOL; // prints "bar"
echo $baz, PHP_EOL; // prints "baz"
?>
Деструктурирањето на низи може да се користи во foreach за деструктурирање на повеќедимензионална низа при итерација низ неа.
Пример #12 Деструктурирање на низи во Foreach
<?php
$source_array = [
[1, 'John'],
[2, 'Jane'],
];
foreach ($source_array as [$id, $name]) {
echo "{$id}: '{$name}'\n";
}
?>
Елементите на низата ќе бидат игнорирани ако променливата не е обезбедена. Деструктурирањето на низата секогаш започнува од индекс 0.
Пример #13 Игнорирање на елементи
<?php
$source_array = ['foo', 'bar', 'baz'];
// Assign the element at index 2 to the variable $baz
[, , $baz] = $source_array;
echo $baz; // prints "baz"
?>Од PHP 7.1.0, асоцијативните низи исто така можат да се деструктурираат. Ова исто така овозможува полесен избор на вистинскиот елемент во нумерички индексирани низи бидејќи индексот може експлицитно да се специфицира.
Пример #14 Деструктурирање на асоцијативни низи
<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];
// Assign the element at index 'baz' to the variable $three
['baz' => $three] = $source_array;
echo $three, PHP_EOL; // prints 3
$source_array = ['foo', 'bar', 'baz'];
// Assign the element at index 2 to the variable $baz
[2 => $baz] = $source_array;
echo $baz, PHP_EOL; // prints "baz"
?>Деструктурирањето на низи може да се користи за лесно менување на две променливи.
Пример #15 Менување на две променливи
<?php
$a = 1;
$b = 2;
[$b, $a] = [$a, $b];
echo $a, PHP_EOL; // prints 2
echo $b, PHP_EOL; // prints 1
?>Забелешка:
Операторот за ширење (
...) не е поддржан во доделувања.
Забелешка:
Обидот за пристап до клучен елемент на низа што не е дефиниран е исто како пристап до која било друга недефинирана променлива: ќе се издаде порака за грешка од ниво
E_WARNING-ниво (E_NOTICE-ниво пред PHP 8.0.0) ќе се издаде, и резултатот ќе бидеnull.
Забелешка:
Деструктурирањето на скаларна вредност доделува
nullдо сите променливи.
Корисни функции
Постојат доста корисни функции за работа со низи. Погледнете го функции за низи section.
Забелешка:
На unset() функцијата овозможува отстранување клучеви од array. Имајте предвид дека низата ќе биде not реиндексирана. Ако се посакува вистинско однесување „отстрани и помести“, тогаш array може да се реиндексира со помош на array_values() function.
Пример #16 Отстранување средни елементи
<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
/* will produce an array that would have been defined as
$a = array(1 => 'one', 3 => 'three');
and NOT
$a = array(1 => 'one', 2 =>'three');
*/
unset($a[2]);
var_dump($a);
$b = array_values($a);
// Now $b is array(0 => 'one', 1 =>'three')
var_dump($b);
?>
На foreach контролната структура постои специјално за arrayи. Обезбедува лесен начин за поминување низ array.
Што да правите и што да не правите со низите
Зошто е $foo[bar] погрешно?
Секогаш користете наводници околу индекс на низа од тип стринг литерал. На пример,
$foo['bar'] е точно, додека
$foo[bar] не е. Но зошто? Вообичаено е да се наиде на ваков вид синтакса во стари скрипти:
<?php
$foo[bar] = 'enemy';
echo $foo[bar];
// etc
?>
Ова е погрешно, но работи. Причината е што овој код има недефинирана константа (bar) наместо string ('bar' - забележете ги наводниците). Работи бидејќи PHP автоматски конвертира
гол стринг (нецитиран string што не одговара на ниту еден познат симбол) во string што го содржи само string. На пример, ако не е дефинирана константа наречена bar, тогаш PHP ќе го замени со
string 'bar' и ќе го користи тоа.
Падот за третирање на недефинирана константа како голем стринг издава грешка од ниво E_NOTICE. Ова е отфрлено од PHP 7.2.0 и издава грешка од ниво E_WARNING. Од PHP 8.0.0, тоа е отстрането и фрла
Грешка exception.
Ова не значи да always го цитирате клучот. Не ги цитирајте клучевите кои се constants or variables, бидејќи ова ќе го спречи PHP да ги толкува.
Пример #17 Клучни цитати
<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);
// Simple array:
$array = array(1, 2);
$count = count($array);
for ($i = 0; $i < $count; $i++) {
echo "\nChecking $i: \n";
echo "Bad: " . $array['$i'] . "\n";
echo "Good: " . $array[$i] . "\n";
echo "Bad: {$array['$i']}\n";
echo "Good: {$array[$i]}\n";
}
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
Checking 0: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 1 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 1 Checking 1: Notice: Undefined index: $i in /path/to/script.html on line 9 Bad: Good: 2 Notice: Undefined index: $i in /path/to/script.html on line 11 Bad: Good: 2
Повеќе примери за да се демонстрира ова однесување:
Пример #18 Повеќе примери
<?php
// Show all errors
error_reporting(E_ALL);
$arr = array('fruit' => 'apple', 'veggie' => 'carrot');
// Correct
echo $arr['fruit'], PHP_EOL; // apple
echo $arr['veggie'], PHP_EOL; // carrot
// Incorrect. This does not work and throws a PHP Error because
// of an undefined constant named fruit
//
// Error: Undefined constant "fruit"
try {
echo $arr[fruit];
} catch (Error $e) {
echo get_class($e), ': ', $e->getMessage(), PHP_EOL;
}
// This defines a constant to demonstrate what's going on. The value 'veggie'
// is assigned to a constant named fruit.
define('fruit', 'veggie');
// Notice the difference now
echo $arr['fruit'], PHP_EOL; // apple
echo $arr[fruit], PHP_EOL; // carrot
// The following is okay, as it's inside a string. Constants are not looked for
// within strings, so no error occurs here
echo "Hello $arr[fruit]", PHP_EOL; // Hello apple
// With one exception: braces surrounding arrays within strings allows constants
// to be interpreted
echo "Hello {$arr[fruit]}", PHP_EOL; // Hello carrot
echo "Hello {$arr['fruit']}", PHP_EOL; // Hello apple
// Concatenation is another option
echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple
?><?php
// This will not work, and will result in a parse error, such as:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// This of course applies to using superglobals in strings as well
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";
?>
Како што е наведено во syntax
секцијата, она што е внатре во квадратните загради ('[' и ']') мора да биде израз. Ова значи дека кодот како овој работи:
<?php
echo $arr[somefunc($bar)];
?>Ова е пример за користење на вратена вредност од функција како индекс на низа. PHP исто така знае за константи:
<?php
$error_descriptions[E_ERROR] = "A fatal error has occurred";
$error_descriptions[E_WARNING] = "PHP issued a warning";
$error_descriptions[E_NOTICE] = "This is just an informal notice";
?>
Имајте предвид дека E_ERROR е исто така валиден идентификатор, исто како
bar во првиот пример. Но, последниот пример е всушност исто како да напишете:
<?php
$error_descriptions[1] = "A fatal error has occurred";
$error_descriptions[2] = "PHP issued a warning";
$error_descriptions[8] = "This is just an informal notice";
?>
because E_ERROR equals 1Пример #2 Рестартирање на Apache откако ќе се инсталира PHP
Па зошто е тогаш лошо?
Во одреден момент во иднина, тимот на PHP можеби ќе сака да додаде друга константа или клучна реч, или константа во друг код може да се меша. На пример, веќе е погрешно да се користат зборовите empty and
default на овој начин, бидејќи тие се
резервирани клучни зборови.
Забелешка: За да повториме, внатре во двојно наводници stringАко повеќе елементи во декларацијата на низата користат ист клуч, само последниот ќе се користи бидејќи сите други се препишани.
"$foo[bar]"е валидно. Погледнете ги горните примери за детали зошто, како и делот за анализа на променливи во низи.
Конвертирање во низа
За кој било од типовите int, float,
string, bool and resource, валидно е да не се опкружуваат индексите на низата со наводници, така што array резултира со низа со еден елемент со индекс нула и вредноста на скаларот што беше претворен. Со други зборови, (array) $scalarValue е точно исто како
array($scalarValue).
Ако еден object се претвори во array, конвертирање на вредност во array чии елементи се objectсвојства. Клучовите се имињата на членовите на променливите, со неколку забележителни исклучоци: целобројните својства се недостапни; приватните променливи имаат името на класата пред името на променливата; заштитените променливи имаат '*' пред името на променливата. Овие додадени вредности имаат NUL бајти од двете страни. Неиницијализирани типизирани својства
се тивко отфрлаат.
Пример #19 Конвертирање во низа
<?php
class A {
private $B;
protected $C;
public $D;
function __construct()
{
$this->{1} = null;
}
}
var_export((array) new A());
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array ( '' . "\0" . 'A' . "\0" . 'B' => NULL, '' . "\0" . '*' . "\0" . 'C' => NULL, 'D' => NULL, 1 => NULL, )
Овие NUL може да резултираат во некои неочекувани однесувања:
Пример #20 Префрлање на објект во низа
<?php
class A {
private $A; // This will become '\0A\0A'
}
class B extends A {
private $A; // This will become '\0B\0A'
public $AA; // This will become 'AA'
}
var_dump((array) new B());
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
array(3) {
["BA"]=>
NULL
["AA"]=>
NULL
["AA"]=>
NULL
}
Горното ќе се појави со два клуча именувани 'AA', иако еден од нив всушност се вика '\0A\0A'.
Споредување
Можно е да се споредат низи со array_diff() функција и со оператори за низи.
Расклопување на низа
Низа претходена од ... ќе биде проширена на место за време на дефиницијата на низата. Само низи и објекти кои имплементираат Траверзабилно може да се прошират. Расклопување на низа со ... е достапно од PHP 7.4.0. Ова се нарекува и оператор за ширење.
Можно е да се прошири повеќе пати, и да се додадат нормални елементи пред или по ... операторот:
, резултатот е
<?php
// Using short array syntax.
// Also, works with array() syntax.
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; // [1, 2, 3]
$arr3 = [0, ...$arr1]; // [0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; // [1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; // [1, 2, 3, 1, 2, 3]
function getArr() {
return ['a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd']
var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6);
?>
Пример #21 Едноставно распакување на низа ... Распакување на низа со array_merge() операторот ги следи семантиките на
функцијата. Тоа е, подоцнежните клучни зборови препишуваат претходните, а целобројните клучни зборови се пренумерираат:
<?php
// string key
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]
// integer key
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// Which is [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// where the original integer keys have not been retained.
?>Забелешка:
Пример #22 Распакување на низа со дупликат клуч TypeErrorКлучовите што не се ниту цели броеви ниту низи фрлаат Траверзабилно object.
Забелешка:
. Таквите клучни зборови можат да се генерираат само од
<?php
$arr1 = [1, 2, 3];
$arr2 = ['a' => 4];
$arr3 = [...$arr1, ...$arr2];
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5
$arr4 = [1, 2, 3];
$arr5 = [4, 5];
$arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5]
?>
Примери
Пред PHP 8.1, распакувањето на низа што има клуч од тип string не е поддржано:
Типот на низата во PHP е многу разновиден. Еве неколку примери:
<?php
// This:
$a = array( 'color' => 'red',
'taste' => 'sweet',
'shape' => 'round',
'name' => 'apple',
4 // key will be 0
);
$b = array('a', 'b', 'c');
var_dump($a, $b);
// . . .is completely equivalent with this:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name'] = 'apple';
$a[] = 4; // key will be 0
$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// After the above code is executed, $a will be the array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4), and $b will be the array
// array(0 => 'a', 1 => 'b', 2 => 'c'), or simply array('a', 'b', 'c').
var_dump($a, $b);
?>Пример #23 Разновидност на низата
<?php
// Array as (property-)map
$map = array( 'version' => 4,
'OS' => 'Linux',
'lang' => 'english',
'short_tags' => true
);
var_dump($map);
// strictly numerical keys
// this is the same as array(0 => 7, 1 => 8, ...)
$array = array( 7,
8,
0,
156,
-10
);
var_dump($array);
$switching = array( 10, // key = 0
5 => 6,
3 => 7,
'a' => 4,
11, // key = 6 (maximum of integer-indices was 5)
'8' => 2, // key = 8 (integer!)
'02' => 77, // key = '02'
0 => 12 // the value 10 will be overwritten by 12
);
var_dump($switching);
// empty array
$empty = array();
var_dump($empty);
?>Пример #24 Користење на array()
<?php
$colors = array('red', 'blue', 'green', 'yellow');
foreach ($colors as $color) {
echo "Do you like $color?\n";
}
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
Do you like red? Do you like blue? Do you like green? Do you like yellow?
Пример #25 Колекција array Промена на вредностите на
директно е можно со нивно поминување по референца.
<?php
$colors = array('red', 'blue', 'green', 'yellow');
foreach ($colors as &$color) {
$color = mb_strtoupper($color);
}
unset($color); /* ensure that following writes to
$color will not modify the last array element */
print_r($colors);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
Array
(
[0] => RED
[1] => BLUE
[2] => GREEN
[3] => YELLOW
)
Пример #26 Промена на елемент во циклусот
Пример #27 Индекс базиран на еден
<?php
$firstquarter = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>Пример #1 Пример што покажува затворачка ознака што го опфаќа последниот нов ред
Array
(
[1] => January
[2] => February
[3] => March
)
Пример #28 Пополнување на низа
<?php
// fill an array with all items from a directory
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
$files[] = $file;
}
closedir($handle);
var_dump($files);
?>Низасе подредени. Редоследот може да се промени со користење на различни функции за сортирање. Погледнете го функции за низи делот за повеќе информации. На count() функцијата може да се користи за броење на бројот на елементи во array.
Пример #29 Сортирање на низа
<?php
sort($files);
print_r($files);
?>Бидејќи вредноста на една array може да биде било што, може да биде и друга array. Ова овозможува креирање на рекурзивни и повеќедимензионални arrays.
Пример #30 Рекурзивни и повеќедимензионални низи
<?php
$fruits = array ( "fruits" => array ( "a" => "orange",
"b" => "banana",
"c" => "apple"
),
"numbers" => array ( 1,
2,
3,
4,
5,
6
),
"holes" => array ( "first",
5 => "second",
"third"
)
);
var_dump($fruits);
// Some examples to address values in the array above
echo $fruits["holes"][5]; // prints "second"
echo $fruits["fruits"]["a"]; // prints "orange"
unset($fruits["holes"][0]); // remove "first"
// Create a new multi-dimensional array
$juices["apple"]["green"] = "good";
var_dump($juices);
?>Низа доделувањето секогаш вклучува копирање на вредноста. Користете го операторот за референца за копирање на array по референца.
Пример #31 Копирање на низи
<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 is changed,
// $arr1 is still array(2, 3)
$arr3 = &$arr1;
$arr3[] = 4; // now $arr1 and $arr3 are the same
var_dump($arr1, $arr2, $arr3);
?>Белешки од корисници 5 белешки
I think your first, main example is needlessly confusing, very confusing to newbies:
$array = array(
"foo" => "bar",
"bar" => "foo",
);
It should be removed.
For newbies:
An array index can be any string value, even a value that is also a value in the array.
The value of array["foo"] is "bar".
The value of array["bar"] is "foo"
The following expressions are both true:
$array["foo"] == "bar"
$array["bar"] == "foo""If you convert a NULL value to an array, you get an empty array."
This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.
<?php $values = search(...); ?>
Now you want to merge the array with another array. What do we do if $values is NULL? No problem:
<?php $combined = array_merge((array)$values, $other); ?>
Voila.Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:
<html>
<body>
<?php
printf("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<input type="hidden" name="Windows3.1" value="Sux">
<input type="submit" value="Click" />
</form>
</body>
</html>
Once you click on the button, the page displays the following:
POST: Array ( [Windows3_1] => Sux )Note that array value buckets are reference-safe, even through serialization.
<?php
$x='initial';
$test=array('A'=>&$x,'B'=>&$x);
$test=unserialize(serialize($test));
$test['A']='changed';
echo $test['B']; // Outputs "changed"
?>
This can be useful in some cases, for example saving RAM within complex structures.