Array key direct aan andere array met key toekennen
Als ik een array heb, en ik wil aan een array key direct een andere array met key toekennen, dan kan ik dit doen, en het werkt gewoon prima:
Wel vraag ik me af of dit juist is? Zou ik eigenlijk eerst moeten aangeven dat 'foo' en 'bar' arrays zijn? Of is dat niet nodig omdat $array al een array is? Dit is wat ik bedoel:
Code (php)
Of is dit niet nodig? Beide varianten werken prima, maar ik vraag me dus af of je binnen een array ook moet aangeven of het een array is, of dat je direct sub-keys mag toekennen. Iemand die dit weet?
- Aar -:
Gezien de wereld van array's erg breed is, zou het niet misstaan om een duidelijkere titel voor dit topic te gebruiken. Ik heb deze alvast voor je aangepast (was: 'array').
Zou je er voortaan zelf op willen letten?
Alvast bedankt!
Zou je er voortaan zelf op willen letten?
Alvast bedankt!
Gewijzigd op 24/03/2014 00:16:29 door - Ariën -
Code (php)
1
2
3
4
5
6
2
3
4
5
6
[0]
[0] => 'welkom'
[1] => 'hallo'
[1]
[0] => 'welkom'
[1] => 'dag
[0] => 'welkom'
[1] => 'hallo'
[1]
[0] => 'welkom'
[1] => 'dag
Nu wil ik dit doen:
Code (php)
De bedoeling is dat $new_array er dan als volgt uitziet:
Code (php)
1
2
3
4
2
3
4
[welkom]
[say_what]
[0] => 'hallo'
[1] => 'dag'
[say_what]
[0] => 'hallo'
[1] => 'dag'
Maar is het een juiste manier om in de foreach-loop direct die keys toe te wijzen op deze manier:
Code (php)
1
2
3
2
3
<?php
$new_array[$element[0]]['say_what'][] = $element[1];
?>
$new_array[$element[0]]['say_what'][] = $element[1];
?>
Of is het meer de bedoeling dat je in de foreach-loop zoiets gaat doen??
Code (php)
@Aar:
Mijn excuses, dat was inderdaad een vrij karige titel die er even tussendoor is geslipt. Mea culpa!
Het kan gewoon kortweg zo:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$configuration['database']['host'] = 'localhost';
$configuration['database']['username'] = 'root';
$configuration['database']['password'] = 'df3578GY8n47LG';
?>
$configuration['database']['host'] = 'localhost';
$configuration['database']['username'] = 'root';
$configuration['database']['password'] = 'df3578GY8n47LG';
?>
Hier besparen we dus twee keer op een lege = array() declaratie:
Code (php)
Een foreach zou ik vooral in de vrij letterlijke betekenis for each gebruiken: als je een array wilt doorlopen en daarin elk element een bepaalde behandeling wilt geven. In overige gevallen is een isset(), een array_key_exists() of een while vaak zowel logischer als efficiënter.
Dankjewel voor je reactie.
Ben ik als laatste nog even benieuwd... declareer jij dan ook geen array voordat je een loop in gaat?
Ik doe altijd dit:
Code (php)
Ik weet dat veel mensen dit doen (eerst een lege array declareren). Het zou zelfs kunnen zijn dat ik het hier geleerd heb. En sindsdien doe ik het zelf ook maar. Maar is dat dan eigenlijk overbodig?
Gewijzigd op 24/03/2014 09:43:03 door Ozzie PHP
Wat ik daarom ook niet doe, is zoiets:
Daarvoor zijn grofweg vier redenen aan te voeren:
• Je declareert lege integers, booleans, enzovoort ook niet, dus waarom dan wel een lege array declareren? Dat is niet consistent.
• In PHPDoc kun je met @type datatypen van alle properties aangeven. Dat kan voor integers, booleans, enzovoort, dus doe je dat ook voor arrays. Dat is wél consistent.
• Misschien wordt die array helemaal niet altijd gebruikt, dus waarom dan alvast een array aanleggen?
• Misschien is $data wel een meerdimensionale array, maar dat komt toch niet tot uitdrukking met een enkele $data = array(). De datastructuur is dan incompleet en het is half werk.
In meerdere opzichten vind ik het beter om het dan zo te doen:
De enige situatie die ik me zo kan bedenken waarin dat niet opgaat is deze:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
class A {
private $data;
public function __construct() {
$foo = ['foo'];
$this->data = array_merge($this->data, $foo);
var_dump($this->data);
}
}
$a = new A;
?>
class A {
private $data;
public function __construct() {
$foo = ['foo'];
$this->data = array_merge($this->data, $foo);
var_dump($this->data);
}
}
$a = new A;
?>
Nu krijg je een warning en $this->data zal NULL zijn.
Voor de rest met je eens. En inderdaad als je het zo bekijkt... waarom zou je een lege array declareren. Het geeft ook geen enkele foutmelding als je het niet doet.
Gewijzigd op 24/03/2014 10:19:28 door Ozzie PHP
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class Foo {
private $data;
function add($data) {
$this->data = array_merge($this->data, $data);
}
}
?>
class Foo {
private $data;
function add($data) {
$this->data = array_merge($this->data, $data);
}
}
?>
Hoe zorg jij er hier dan voor dat $this->data een array is?
Vraag wordt dan: wil je "zomaar" twee arrays mergen of is er meer aan de hand en moet $this->data aan een bepaalde datastructuur voldoen? Meestal het tweede, dus dan wil je (a) elders toch een setter hebben en (b) de methode add() uitbreiden met controles voor die datastructuur.
Nee, wat ik in dit voorbeeld bedoel is dat je simpelweg data kunt toevoegen aan het object.
Stel je hebt een class Paths en daar wil je een array met paden aan toevoegen. De class-property $paths is dan in 1e instantie leeg (er zijn nog geen paden toegevoegd). Via de add functie kun je een array met paden (of zoals in het voorbeeld hierboven 'data') toevoegen aan de class property. Maar voordat je iets toevoegt, zal die class property een array moeten zijn, anders gaat het fout. Direct declareren, dus zo:
... lijkt mij dan het handigst. Denk je niet?
Gewijzigd op 24/03/2014 11:05:00 door Ozzie PHP
Overigens, om misverstanden te voorkomen, ben ik niet tegen het declareren van properties. Het hangt immers helemaal af van wat je daarmee wilt doen. Er zijn situaties waarin het juist heel gewenst kan zijn, bijvoorbeeld: