Ինչպես ստեղծել բազմաչափ զանգված php. PHP-ում բազմաչափ զանգվածների օգտագործումը: Ինչ է PHP զանգվածը

Հաճախ դուք պետք է կրկնեք PHP զանգվածի բոլոր տարրերը և կատարեք որոշակի գործողություն յուրաքանչյուր տարրի վրա: Օրինակ, դուք կարող եք դուրս բերել յուրաքանչյուր արժեք HTML աղյուսակկամ յուրաքանչյուր տարրի տալ նոր արժեք:

Այս դասում մենք կանդրադառնանք foreach կառուցվածքին, երբ պտտվում ենք ինդեքսավորված և հարակից զանգվածների միջով:

Անցեք տարրերի արժեքների միջով

Foreach-ի օգտագործման ամենապարզ դեպքը ինդեքսավորված զանգվածի արժեքների վրա պտտելն է: Հիմնական շարահյուսություն.

Foreach ($array as $value) ( // Ինչ-որ բան արեք $value-ով ) // Այս կոդը գործարկվում է օղակի ավարտից հետո

Օրինակ, հետևյալ սցենարը կրկնվում է ինդեքսավորված զանգվածի դիրեկտորների ցանկի միջով և թողարկում յուրաքանչյուրի անունը.

$directors = զանգված («Ալֆրեդ Հիչքոք», «Սթենլի Կուբրիկ», «Մարտին Սկորսեզե», «Ֆրից Լանգ»); foreach ($directors as $director) (echo $director ։"
"; }

Վերոնշյալ կոդը դուրս կգա.

Ալֆրեդ Հիչքոք Սթենլի Կուբրիկ Մարտին Սկորսեզե Ֆրից Լանգ

Շրջում բանալիների և արժեքների վրա

Ի՞նչ կասեք կապված զանգվածների մասին: Այս տեսակի զանգված օգտագործելիս հաճախ անհրաժեշտ է լինում մուտք ունենալ յուրաքանչյուր տարրի բանալին, ինչպես նաև դրա արժեքը: Foreach կոնստրուկցիան ունի առաջադրանքն իրականացնելու միջոց.

Foreach ($array as $key => $value) ( // Ինչ-որ բան արեք $key-ով և/կամ $value-ով) // Այս կոդը գործարկվում է օղակի ավարտից հետո

Ֆիլմերի մասին տեղեկությունների հարակից զանգվածի վրա պտտվելու օրինակ, ելքավորում է յուրաքանչյուր տարրի բանալին և դրա արժեքը html ցուցակսահմանումներ:

$movie = array ("title" => "Rear Window", "director" => "Alfred Hitchcock", "year" => 1954, "minutes" => 112); արձագանք»

$key:: $արժեք

Այս սցենարը կարտադրի.

Վերնագիր՝ Հետևի պատուհանի ռեժիսոր՝ Ալֆրեդ Հիչքոք տարի՝ 1954 րոպե՝ 112

Փոխել տարրի արժեքը

Բայց ի՞նչ կասեք օղակի ընթացքում տարրի արժեքը փոխելու մասին: Դուք կարող եք փորձել այս կոդը.

Foreach ($myArray որպես $value) ($value = 123; )

Այնուամենայնիվ, եթե գործարկեք այն կատարման համար, ապա կտեսնեք, որ զանգվածի արժեքները մի փոխիր. Պատճառն այն է, որ foreach-ն աշխատում է պատճենելզանգվածի արժեքները, ոչ բնօրինակի հետ: Այսպիսով, սկզբնական զանգվածը մնում է անձեռնմխելի:

Զանգվածի արժեքները փոխելու համար ձեզ հարկավոր է հղումարժեքին։ Դա անելու համար դուք պետք է դրեք «&» արժեքի փոփոխականի դիմաց foreach կառուցվածքում.

Foreach ($myArray որպես &$value) ($value = 123;)

Օրինակ՝ հետևյալ սկրիպտը պտտվում է $directors զանգվածի յուրաքանչյուր տարրի միջով (ռեժիսորի անունը) և օգտագործում է PHP explode() ֆունկցիան և ցուցակի կառուցվածքը՝ անունն ու ազգանունը փոխելու համար.

$directors = զանգված («Ալֆրեդ Հիչքոք», «Սթենլի Կուբրիկ», «Մարտին Սկորսեզե», «Ֆրից Լանգ»); // Փոխեք անվան ձևաչափը յուրաքանչյուր տարրի համար foreach ($directors որպես &$director) (list($firstName, $lastName) = explode(" ", $director); $director = "$lastName, $firstName"; ) չսահմանված ($տնօրեն); // Արտադրեք վերջնական արդյունքը foreach ($directors որպես $director) (echo $director ։"
"; }

Սցենարը դուրս կգա.

Հիչքոք, Ալֆրեդ Կուբրիկ, Սթենլի Սկորսեզե, Մարտին Լանգ, Ֆրից

Նկատի ունեցեք, որ սկրիպտը կանչում է unset() ֆունկցիան՝ հեռացնելու $director փոփոխականը առաջին օղակի ավարտից հետո: Սա լավ պրակտիկա է, եթե դուք նախատեսում եք փոփոխականն օգտագործել ավելի ուշ սկրիպտում այլ համատեքստում:

Եթե դուք չեք հեռացնում հղումը, ապա վտանգ կա, որ կոդի հետագա կատարումը պատահաբար կվերաբերի զանգվածի վերջին տարրին («Lang, Fritz»), եթե այնուհետև օգտագործեք $director փոփոխականը, որը կհանգեցնի անկանխատեսելի հետևանքների:

Ամփոփում

Այս ձեռնարկում մենք նայեցինք, թե ինչպես օգտագործել PHP foreach կոնստրուկցիան՝ զանգվածի տարրերը պտտելու համար: Քննարկվել են հարցեր.

Ինչպես շրջանցել զանգվածի տարրերը
Ինչպես մուտք գործել յուրաքանչյուր տարրի բանալին և արժեքը
Ինչպես օգտագործել հղումը շրջագծման ընթացքում արժեքները փոխելու համար

$arr [ 1 ] = "PHP" ;
$arr [ 2 ] = "MySQL" ;
$arr [ 3 ] = "Apache" ;
?>

Զանգվածի տարրերը կարող են օգտագործվել կրկնակի մեջբերումներինչպես սովորական փոփոխականները, այնպես որ կոդը

echo " $arr [ 1 ] $arr [ 2 ] $arr [ 3 ] " ;
?>

$arr [ "first" ] = "PHP" ;
$arr [ "second" ] = "MySQL" ;
$arr [ "third" ] = "Apache" ;
?>

Այս դեպքում զանգվածը կոչվում է ասոցիատիվ, և նրա ինդեքսները կոչվում են բանալիներ. Զանգվածի տարրը տողի մեջ դուրս բերելու համար պետք է օգտագործվեն չակերտները (ոչ կրկնակի, ոչ միայնակ).

echo " $arr [ first ] $arr [ second ] $arr [ երրորդ ] " ;
?>

Քանի որ ասոցիատիվ զանգվածները չունեն ինդեքսներ, դրանք շրջանցելու համար ներդրվել է օղակի հատուկ տեսակ. առաջ:

foreach ($arr որպես $key => $value)
{
echo " $key = $value
" ;
}
?>

Շրջանակի արդյունքում կցուցադրվեն երեք տող

Առաջին = PHP
երկրորդ = MySQL
երրորդ = Apache

«$key =>» կոնստրուկցիան, որը թույլ է տալիս մուտք գործել զանգվածի ստեղն յուրաքանչյուր օղակի վրա, կամընտիր է և կարող է բաց թողնել.

foreach ($arr որպես $value)
{
echo " $value
" ;
}
?>

Մի շարք գործառույթներ թույլ են տալիս նաև վերադարձնել զանգվածներ, օրինակ՝ ֆունկցիան ֆայլ (), որը կարդում է ֆայլը և վերադարձնում դրա բովանդակությունը որպես զանգված։ Զանգվածի յուրաքանչյուր տարր համապատասխանում է մեկ տողի։

$arr = ֆայլ ("text.txt");
for($i = 0; $i< count ($arr ); $i ++)
{
echo $arr[$i]. «
" ;
}
?>

Մեկ այլ օգտակար հատկությունֆունկցիա է պայթել (), որը թույլ է տալիս տողը բաժանել մի քանի հատվածների, որոնցից յուրաքանչյուրը տեղադրվում է զանգվածի առանձին տարրում՝

$str = "345|[էլփոստը պաշտպանված է]|http://www.site|մուտքի|գաղտնաբառ»;
$arr = պայթել ("|" , $str );
for($i = 0; $i< count ($arr ); $i ++)
{
echo $arr[$i]. «
" ;
}
?>

Սցենարի արդյունքը կարող է այսպիսի տեսք ունենալ.

345
[էլփոստը պաշտպանված է]
http://www.site
մուտք
գաղտնաբառը

Կա նաև հակադարձ ֆունկցիա՝ implode (), որը միավորում է զանգվածի տարրերը տողի մեջ՝ օգտագործելով տրված տարանջատիչը դրա համար.

$arr = "345" ;
$arr = " [էլփոստը պաշտպանված է]" ;
$arr = "http://www.site" ;
$arr = "մուտք" ;
$arr = "գաղտնաբառ" ;
$str = implode ("##", $arr);
արձագանք $str ; //345##[էլփոստը պաշտպանված է]##http://www.
?>

Մեկնաբանություն

Ընդհանրապես, կան բազմաթիվ գործառույթներ, որոնք փորում են լարը, դրանց բոլորի քննարկումը դուրս է այս հոդվածի շրջանակներից:

Դուք կարող եք հեռացնել զանգվածի առանձին տարր՝ օգտագործելով ֆունկցիան unset (), և ֆունկցիայի միջոցով կարող եք ստուգել զանգվածի առկայությունը isset (). Եկեք սահմանենք 10 տարրերից բաղկացած զանգված և ոչնչացնենք յուրաքանչյուր զույգ տարրը:

unset ($arr [0], $arr [2], $arr [4], $arr [6], $arr [8]);
// Ստուգեք, արդյոք առկա են զանգվածի տարրեր
for($i = 0; $i< 10 ; $i ++)
{
if(isset($arr [ $i ])) echo «Սահմանված է $arr [ $i ] տարրը
" ;
else echo «Element $arr [$i] անորոշ
" ;
}
?>

Սկսած սցենարի արդյունքը կլինի հետևյալ տողերը

$arr տարրը սահմանված չէ
Սահմանված է $arr տարր
$arr տարրը սահմանված չէ
Սահմանված է $arr տարր
$arr տարրը սահմանված չէ
Սահմանված է $arr տարր
$arr տարրը սահմանված չէ
Սահմանված է $arr տարր
$arr տարրը սահմանված չէ
Սահմանված է $arr տարր

Օգտագործելով գործառույթը unset ()դուք կարող եք միանգամից ոչնչացնել ամբողջ զանգվածը:

$arr = զանգված(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
unset ($arr);
if(isset($arr )) արձագանք «Զանգվածը սահմանված է»;
արձագանք «Զանգվածը սահմանված չէ»;
?>

Նախկինում զանգվածները թափվում էին օղակի միջոցով, սակայն PHP-ն հատուկ գործառույթ է տրամադրում զանգվածը թափելու համար: print_r (). Ֆունկցիան կենտրոնացած է կոնսոլային հոսքի ելքի վրա, ուստի արդյունքները դիտարկիչի պատուհանում դուրս բերելիս ավելի լավ է այն շրջանակել պիտակներով:

ԵՎ

$arr = "345";
$arr = " [էլփոստը պաշտպանված է]";
$arr = «http://www.site»;
$arr = «մուտք»;
$arr = «գաղտնաբառ»;
արձագանք»

";
print_r ($arr);
արձագանք "";
?>

Սցենարի արդյունքը հետևյալն է.

զանգված
=> 345
=> [էլփոստը պաշտպանված է]
=> http://www.site
=> մուտք
=> գաղտնաբառը
)

Բազմաչափ զանգվածներ

Զանգվածի տարրերը կարող են լինել ոչ միայն սկալյար արժեքներ, այլ նաև զանգվածներ: Այս դեպքում, այսպես կոչված բազմաչափզանգվածներ.

Եկեք ստանանք այսպիսի աղյուսակ.

Դա անելու համար ստեղծեք երկչափ զանգված.

$arr = զանգված (զանգված ('Vasya' , 'locksmith' , 2500),
զանգված ('Misha' , 'builder' , 3000 ),
զանգված ('Andrey', 'driver', 2700));
?>

Այժմ աղյուսակը կարող է ցուցադրվել՝ օգտագործելով հետևյալ կոդը.

համար ($i = 0; $i< 3 ; $i ++)
{
համար ($j = 0; $j< 3 ; $j ++)
{
արձագանք « |» . $arr [ $i ][ $j ];
}
արձագանք»
" ;
}
?>

Արդյունք:

Կարող եք նաև օգտագործել 3D, 4D և այլն: զանգվածներ.

Գործողություններ զանգվածների վրա (բաղադրատոմսերի հավաքածու)

1) զանգվածի տարրերի քանակի որոշում հաշվել ():

Եկեք ստեղծենք զանգված $name:

Զանգվածի տարրերի քանակը որոշելու համար կարող եք անել հետևյալը.

արձագանք «Զանգվածի տարրերի քանակը- '. count ($name);
?>

Արդյունք:

Զանգվածի տարրերի թիվը՝ 8

2) զանգվածների միություն

ա) Ստեղծեք երկու ասոցիատիվ զանգված $a և $b.

$a = զանգված (“a” => ”aa” , “b” => “bb”);
$b = զանգված (“c” => ”cc” , “d” => “dd”);
?>

Թող անհրաժեշտ լինի ստեղծել $c զանգված, որը կպարունակի $a և $b զանգվածի տարրերը.

$a = զանգված("a" => "aa" , "x" => "xx" );
$b = զանգված ("c" => "cc" , "d" => "dd" );
$c = $a + $b ;
արձագանք»

"
;

print_r ($c); 
արձագանք»

" ;
?>

Արդյունք:

զանգված
[a] => աա
[x] => xx
[c] => դդ
[d] => դդ
)

բ) Ստեղծեք երկու թվային զանգված $a և $b.

$a = զանգված (10, 20);
$b = զանգված (100, 200, 300, 400, 500);
?>

Դրանք այլևս չեն կարող միավորվել՝ օգտագործելով $c = $a + $b; շինարարությունը: Դրանք համատեղելու համար անհրաժեշտ է օգտագործել ֆունկցիան զանգված_միաձուլում ():

$c = array_merge ($a, $b);
?>

3) Զանգվածի տեսակավորում

Եկեք օգտագործենք $name զանգվածը.

$name = array("Boss", "Lentin", "NAV", "Endless", "Dragons", "SiLeNT", "Doctor", "Lynx");
?>

Ենթադրենք, որ ցանկանում եք դասավորել զանգվածը այբբենական կարգով, դրա համար կարող եք օգտագործել հետևյալ կոդը.

տեսակավորում ($name);
արձագանք»

"
;

print_r ($name); 
արձագանք»

" ;
?>

Արդյունք:

զանգված
=> Բոս
=> Բժիշկ
=> Դրակոններ
=> Անվերջ
=> Լենտին
=> Lynx
=> NAV
=> Լուռ
)

Թող անհրաժեշտ լինի $name զանգվածից ընտրել ամենակարճ տարրը (որն ունի ամենաքիչ թվով նիշ), այս դեպքում կարող եք օգտագործել կոդը.

$name = array("Boss", "Lentin", "NAV", "Endless", "Dragons", "SiLeNT", "Doctor", "Lynx");
$min = strlen($name [0]);
$nam = $name [ 0 ];
համար ($i = 1; $i< count ($name ); $i ++)
{
$len = strlen ($name [ $i ]);
եթե ($len< $min )
{
$nam = $name [ $i ];
$min = strlen($nam );
}
}
արձագանք «Ամենափոքր երկարությունը -». $nam ;
?>

4) Շարժվել զանգվածի ներսում

Եկեք ստեղծենք զանգված $num:

$num = զանգված (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
?>

Թող պահանջվի ցուցադրել զանգվածի տարրերը հակառակ հերթականությամբ, այս դեպքում կարող եք օգտագործել կոդը.

$ end = վերջ ($num );
Մինչդեռ ($end )
{
արձագանք $վերջ . «-»;
$վերջ = նախորդ ($num );
}
?>

Արդյունք:

10 - 9 - 8 - 7 - 6 - 5 - 4 - 3 - 2 – 1

Վերոնշյալ կոդը կարող է փոփոխվել.

$num = միջակայք (1, 10);
print_r(array_reverse ($num));
?>

Գործառույթ միջակայք (1,10)ստեղծում է զանգված (1,2,3,4,5,6,7,8,9,10) պատահական տարրերով։ Գործառույթ զանգված_հակադարձ ()վերցնում է զանգված և տարրերը դնում հակառակ հերթականությամբ (10,9,8,7,6,5,4,3,2,1)

Գործառույթներ հաջորդը (), յուրաքանչյուրը ()ցուցիչը տեղափոխեք մեկ տարր առաջ: Գործառույթ զրոյացնել ()վերադարձնում է ցուցիչը զանգվածի 1 տարրին: Եկեք օգտագործենք $num զանգվածը:

Այս կարճ հոդվածում մենք կդիտարկենք զանգվածների հետ աշխատելու մի քանի եղանակներ: Հարկ է նշել, որ սա տվյալների ամենակարևոր տեսակներից մեկն է, և առանց դրանց նույնիսկ դժվար է պատկերացնել ժամանակակից ծրագրավորման լեզուները: Ի՞նչ է զանգվածը:
Զանգվածը տվյալների կառուցվածքային հավաքածու է:
Դա կարելի է որոշել դրանց կառուցվածքից պարզ զանգվածկամ ասոցիատիվ. Անհնար է հստակ ասել, թե որն է ավելի լավը, քանի որ. այս կամ այն տեսակը պետք է օգտագործվի ըստ իրավիճակի:

Ինչպես ստեղծել պարզ զանգված PHP-ում

Ահա թե ինչ տեսք ունի պարզ զանգվածը.

Ես ուզում եմ անմիջապես ձեր ուշադրությունը հրավիրել տվյալների վրա (այո, ես դա դիտմամբ եմ գրել 🙂): Լարային տվյալներ, կամ լարմիշտ չակերտներով գրիր, ինչ էլ որ լինի, կգնան և՛ մենակ, և՛ կրկնակի (գլխավորն այն է, որ տողը սկսվում և փակվում է նույն չակերտով): Թիվ 29-ն ունի տեսակ ամբողջ թիվ, կամ համարներ - այս տվյալների տեսակների համար չակերտները անհրաժեշտ չեն:
Եկեք ստուգենք, թե ինչպես է $my_array զանգվածը նման.

"; print_r ($my_array); echo "«; /* ստանալ Array ( => Աթոռ => Cloud => 29) */ ?>

ահա թե ինչ տեսք ունի պարզ զանգվածը:
0,1,2 մեր զանգվածի ինդեքսներն են։ Ինդեքսների օգնությամբ մենք կարող ենք որոշակի բան եզրակացնել զանգվածից։

Բացի այդ, մենք կարող ենք ստեղծել նույն զանգվածը, եթե գրենք.

Եվ կա երրորդ ճանապարհ.

«Աթոռ», 1 => «Ամպ», 2 => 29);?>

Եվ չորրորդը 🙂

ինդեքսները լրացվելու են 0-ից։

PHP ինչ է ասոցիատիվ զանգված

Մենք արդեն հասկացել ենք, թե ինչ է պարզ զանգվածը: Ասոցիատիվ զանգվածը դրանով տարբերվում է ստեղներ՝ ինդեքսների փոխարեն. Այսինքն՝ արժեքներ մուտք գործելու համար մենք այլևս չենք օգտագործի 0,1 կամ 2: Եկեք գրենք մեր պարզ զանգվածը որպես ասոցիատիվ.

Աթոռ => Ամպ => 29) */ ?>

Իսկ զանգի համար մենք կօգտագործենք

Թվի փոխարեն ( ցուցանիշը) մենք սահմանել ենք իմաստալից անուն (ասոցիացիա) և մեր ինդեքսն այժմ կարելի է անվանել զանգվածի բանալի(հատ, երկինք, համար): Ասոցիատիվ զանգվածի ամենատարածված և, հավանաբար, ամենահարմար նշումը հետևյալն է.

«Աթոռ», «երկինք» => «Ամպ», «համար» => 29); ?>

բազմաչափ զանգված

Ընդամենը մի քանի խոսք այս հսկայի մասին 🙂

զանգված ("color" => "կարմիր", "տարի" => "2010", "mark" => "M5"), "audi" => զանգված ("color" => "սև", "տարի" = > "2011", "mark" => "TT")); print_r ($ auto); // զանգվածի ելքային echo $auto["bmw"]["mark"]; // M5 ?>

Ինչպես հասկանում եք, արժեքի փոխարեն, որը նախկինում տող կամ թիվ էր, այժմ կա տվյալների նման տեսակ, որպես զանգված ( Ես ձեզ զանգված կդարձնեմ զանգվածի մեջ, որպեսզի զանգվածը կանչելիս լինի մեկ այլ զանգված :)).

Առաջադրանք
Անհրաժեշտ է հերթով անցնել և մշակել բոլոր կամ որոշ տարրեր:
զանգված ոստիկաններ.

Լուծում
Օգտագործեք foreach հայտարարությունը.

Foreach ($array որպես $value) (
// Գործողություն $value-ով
}

Կամ զանգվածի բանալիներն ու արժեքները ստանալու համար.

Foreach ($array որպես $key => $value) (
// Գործողություն II
}

Մեկ այլ միջոց է օգտագործել for հայտարարությունը.
համար ($key = 0, $size = count ($array); $key // Գործողություն III
}

Վերջապես, դուք կարող եք օգտագործել every() ֆունկցիան՝ ցուցակի () ֆունկցիայի և while հայտարարության հետ համատեղ.

Reset($array) // վերականգնել ներքին ցուցիչը զանգվածի սկզբին
մինչդեռ (list($ key, $value) = յուրաքանչյուրը ($array)) (
// վերջնական գործողություն
}

Քննարկում
foreach հանգույց է ամենապարզ ճանապարհըկրկնվող զանգվածով.

// foreach հայտարարություն արժեքներով
foreach ($ items որպես $cost) (
...
}
// foreach հայտարարություն բանալիներով և արժեքներով
foreach ($items որպես $item => $cost) (
...
}

Foreach հայտարարության մեջ PHP-ն կրկնում է ոչ թե բնօրինակ զանգվածի, այլ դրա պատճենի վրա:

Ի հակադրություն, յուրաքանչյուր() ֆունկցիան և for հայտարարությունը օգտագործելիս PHP-ն կրկնում է սկզբնական զանգվածի վրա։ Հետևաբար, եթե զանգվածը փոփոխվում է օղակի ներսում, ապա դուք կարող եք ստանալ (կամ չեք կարող ստանալ) սպասված վարքագիծը:

Եթե Ձեզ անհրաժեշտ է փոխել զանգվածը, ապա օգտագործեք դրա ուղղակի հղումը.

վերակայել ($ items);
մինչդեռ (ցուցակ ($ item, $cost) = յուրաքանչյուրը ($ item)) (
եթե (! in_stock ($item)) (
unset ($ item [$ item]); // ուղղակի զանգվածի հասցեավորում
}
}

Յուրաքանչյուր() ֆունկցիայի կողմից վերադարձված փոփոխականները չեն վերաբերում սկզբնական զանգվածի արժեքներին
դրանց պատճեններն են, ուստի դրանց փոփոխությունը չի արտացոլվում զանգվածում: Ահա թե ինչու դուք պետք է փոփոխեք $items[$item] փոփոխականը՝ $item փոփոխականի փոխարեն։

Յուրաքանչյուր() ֆունկցիան օգտագործելիս PHP-ն հետևում և հիշում է օղակի դիրքը: Առաջին անցումից հետո օղակը նորից սկսելու համար հարկավոր է կանչել reset() ֆունկցիան, որպեսզի ցուցիչը վերադարձնի հանգույցից առաջ դիրքը: Հակառակ դեպքում
Յուրաքանչյուր() ֆունկցիան կվերադարձնի false:

For հանգույցն աշխատում է միայն հաջորդական ամբողջ ստեղներով զանգվածների համար: Եթե զանգվածի երկարությունը չի փոխվում, ապա ամեն անգամ անարդյունավետ է count() ֆունկցիան նորից կանչել օղակի միջոցով՝ $items փոփոխականը հաշվարկելու համար։

Հետևաբար, զանգվածի երկարությունը պահելու համար միշտ օգտագործեք $size փոփոխականը՝

($item = 0, $size = count($items); $item ...
}

Եթե նախընտրում եք, հանուն ողջամիտ տնտեսության, օգտագործեք մեկը
փոփոխական, այնուհետև հաշվել ետ՝
համար ($item = count($items) - 1; $item >= 0; $item--) (
...
}

Ասոցիատիվ տարբերակ հանգույցի համար:

For (reset ($array); $key = key ($array); next ($array)) (
...
}

Սա սխալ կառաջացնի, եթե որևէ տարր պարունակում է false արժեք ունեցող տող, ուստի թվացյալ նորմալ արժեքը, ինչպիսին 0-ն է, կարող է հանգեցնել հանգույցի վաղաժամ ավարտին:

Վերջապես, օգտագործեք array_map() ֆունկցիան յուրաքանչյուր տարր փոխանցելու մշակման ֆունկցիային.

// բոլոր բառերը վերածել փոքրատառերի
$lc = array_map ("strtolower", $words);

Array_map() ֆունկցիայի առաջին արգումենտը ֆունկցիայի անունն է, որը փոփոխում է առանձին տարրը, իսկ երկրորդ արգումենտը այն զանգվածն է, որի միջով անցվում է օղակ:

Այս գործառույթները, ընդհանուր առմամբ, համարվում են ավելի քիչ ճկուն, քան նախկինում քննարկված մեթոդները, սակայն դրանք լավ հարմար են բազմաթիվ զանգվածների մշակման և միացման համար:

Եթե չգիտեք, արդյոք տվյալները պետք է դիտարկվեն որպես սկալերներ, թե որպես զանգված, ապա դուք պետք է կանխեք foreach-ի կիրառումը ոչ զանգվածով: Ճանապարհներից մեկը is_array() ֆունկցիան օգտագործելն է.

Եթե (is_array ($items)) (
// կոդը foreach հանգույցով զանգվածի համար
) ուրիշ (
// կոդ սկալյար արժեքի համար
}

Մեկ այլ եղանակ է ստիպել բոլոր փոփոխականներին վերածել զանգվածի, օգտագործելով settype() ֆունկցիան.

settype ($items, «զանգված»);
// հանգույցի կոդը զանգվածների համար

Սա սկալյար արժեքը վերածում է մեկ տարրի զանգվածի և կոդն ավելի գեղեցիկ է դարձնում մի փոքր ավելորդ ծախսերի հաշվին:

Պարտադիր չէ, որ զանգվածը լինի ստեղների և պարզ արժեքների պարզ ցուցակ: Զանգվածի յուրաքանչյուր տարր կարող է որպես արժեք պարունակել մեկ այլ զանգված, որն իր հերթին կարող է պարունակել նաև զանգված և այլն։ Այս կերպ կարելի է ստեղծել երկչափ և եռաչափ զանգվածներ։

2D զանգվածներ

Երկչափ զանգված- զանգված, որը պահպանում է այլ զանգվածներ որպես արժեքներ: Մտածեք ստեղծել երկչափ զանգված՝ օգտագործելով array() կոնստրուկտորը՝

$flowers = զանգված (զանգված («վարդեր», 100 , 15), զանգված («կակաչներ», 60 , 25), զանգված («խոլորձներ», 180 , 7));

$flowers զանգվածը պարունակում է երեք զանգված: Ինչպես հիշում եք, միաչափ զանգվածի տարրերին մուտք գործելու համար պետք է նշեք զանգվածի անվանումը և բանալին: Նույնը վերաբերում է երկչափ զանգվածներին, մեկ բացառությամբ՝ յուրաքանչյուր տարր ունի երկու բանալի՝ առաջինը տող ընտրելու համար, երկրորդը՝ սյունակ ընտրելու համար։

Այս զանգվածի տարրերը ցուցադրելու համար կարող եք ձեռքով մուտք գործել դրանցից յուրաքանչյուրին, բայց ավելի լավ է օգտագործել nested loops.

Ձեռքով մուտք դեպի տարրեր
«; արձագանքել $ծաղիկներ»: գինը «.$flowers». քանակ «.$flowers».
«; արձագանքել $ծաղիկներ»: գինը «.$flowers». քանակ «.$flowers».
«; արձագանք»

Օգտագործելով Loops՝ իրերը ցուցադրելու համար

«; արձագանք»

Տողի համարը $ տող«; արձագանք»
- «.$flowers[$row][$col]»:
«; արձագանք»

"; ?>

Սյունակների համարների փոխարեն (նրանց լռելյայն հատկացված ինդեքսները) կարող եք տալ նրանց ցանկալի ստեղները: Այդ նպատակով օգտագործվում են ասոցիատիվ զանգվածներ: Հետևյալ զանգվածը կպահի նույն տվյալները, սակայն օգտագործելով ստեղներ՝ տեղեկատվության սյունակները անվանելու համար.

$flowers = array(array("Name" => "վարդեր", "Price" => 100, "Quantity" => 15), array("Name" => "tulips", "Price" => 60, " Քանակ» => 25,), զանգված («Անուն» => «խոլորձներ», «Գին» => 180, «Քանակ» => 7));

Ստեղները լրացուցիչ հարմարավետություն են ապահովում զանգվածի հետ աշխատելու համար այն դեպքերում, երբ դուք պետք է ստանաք արժեքներից մեկը: Պահանջվող տվյալները կարելի է հեշտությամբ գտնել, եթե օգտվում եք ճիշտ բջիջից իմաստալից անուններտողեր և սյունակներ: Այնուամենայնիվ, դրանով մենք կորցնում ենք զանգվածը հաջորդաբար անցնելու ունակությունը՝ օգտագործելով for հանգույցը:

Մենք կարող ենք կրկնել for loop only child զանգվածների միջոցով: Քանի որ դրանք, իրենց հերթին, ասոցիատիվ են, իրենց տարրերի վրա կրկնելու համար անհրաժեշտ է օգտագործել foreach հանգույցը կամ ձեռքով կրկնել տարրերի վրա.

«վարդեր», «Գին» => 100, «Քանակ» => 15), զանգված («Անուն» => «կակաչներ», «Գին» => 60, «Քանակ» => 25,), զանգված («Անուն». " => "խոլորձներ", "Գին" => 180, "Քանակ" => 7)); արձագանք»

Ձեռքով հասանելիություն ասոցիատիվ զանգվածի տարրերին

«; համար ($ տող = 0; $ տող< 3; $row++) { echo $flowers[$row]["Название"]." цена ".$flowers[$row]["Цена"] ." количество ".$flowers[$row]["Количество"]; echo "
«;) արձագանք

Օգտագործելով foreach հանգույց՝ տարրեր մուտք գործելու համար

«; արձագանք»

Տողի համարը $ տող«; արձագանք»
- «.$value»:
«; արձագանք»

"; ?>

Երկչափ զանգված ստեղծելու համար պարտադիր չէ օգտագործել array() կոնստրուկտորը, կարող եք նաև օգտագործել կարճ շարահյուսությունը՝ քառակուսի փակագծեր.

$flowers = [ [ "Name" => "վարդեր", "Price" => 100, "Quantity" => 15 ], [ "Name" => "tulips", "Price" => 60, "Quantity" = > 25, ], [ "Անուն" => "խոլորձներ", "Գին" => 180, "Քանակ" => 7 ] ];

3D զանգվածներ

Պետք չէ սահմանափակվել միայն երկու չափերով. ինչպես զանգվածի տարրերը կարող են պարունակել զանգվածներ, այդ զանգվածներն էլ իրենց հերթին կարող են պարունակել նոր զանգվածներ:

Եռաչափ զանգվածը բնութագրում է լայնությունը, բարձրությունը և խորությունը: Եթե դուք երկչափ զանգվածը ներկայացնում եք որպես աղյուսակ, ապա եռաչափը շերտեր է ավելացնում այս աղյուսակին: Նման զանգվածի յուրաքանչյուր տարր վերաբերում է շերտին, տողին և սյունակին:

Եթե մի փոքր փոփոխենք մեր զանգվածը գույներով, ապա այն կարող ենք վերածել եռաչափի: Ստորև բերված կոդը ցույց է տալիս դա 3D զանգված- զանգված, որը պարունակում է զանգվածների զանգված.

$flowers = [ [ ["վարդեր", 100 , 15], ["կակաչներ", 60 , 25], ["խոլորձներ", 180 , 7] ], [ ["վարդեր", 100 , 15], ["կակաչներ", «, 60 , 25], [«խոլորձներ», 180 , 7], ], [ [«վարդեր», 100 , 15], [«կակաչներ», 60 , 25], [«խոլորձներ», 180 , 7] ] ];

Քանի որ այս զանգվածը պարունակում է միայն թվային ինդեքսներ, մենք կարող ենք օգտագործել nested loops այն ցուցադրելու համար.

«; համար ($layer = 0; $layer< 3; $layer++) { echo "

Շերտի համարը $layer"; echo "