vraagje over JSON
Ik heb 2 vraagjes over JSON en objecten.
Ik heb een JSON bestand, dat kan ik in php gebruiken als object.
Code (php)
1
$oMyObject = json_decode($json);
Maar voor OOP zou ik functies moeten kunnen toevoegen aan het object. Daarvoor moet je een class aanmaken begrijp ik. Maar kan ik mijn $oMyObject ook aan een class koppelen? Zo ja, hoe?
Tweede vraag:
Is het ook mogelijk, ik kan me niet voorstellen dat het niet kan ;-) , om vanuit een formulier waarden retour te sturen, bijvoorbeeld door het opsturen van een JSON? Zo ja, hoe zou ik dat moeten doen?
Je tweede vraag snap ik niet echt. Kan je een voorbeeld geven?
json_decode maakt automatisch een object. Wanneer je hier 'true' aan toevoegt krijg je een array.
Misschien heb je hier iets aan?
Gewijzigd op 16/01/2020 01:26:16 door Michael -
Persoonlijk snap ik dan ook niet zo goed waarom de PHP developers gekozen hebben voor de constructie om de JSON standaard te verwerken naar een "standaard PHP object". Ik gebruik dan ook altijd zoals Michael ook aangeeft de optie om de data als associatieve array binnen te halen door als tweede parameter TRUE op te geven.
Ik maak zelf vaak een fromArray() en toArray() method in een class als ik data van een array naar een object wil kopiëren of visa versa
Gewijzigd op 16/01/2020 05:49:13 door Frank Nietbelangrijk
@Ariën: Kan het zijn dat je bedoelde te schrijven dat je uit json_decode juist wel een stdClass object krijgt en dat die niet uit te bereiden is? Ik haal tenminste uit de documentatiedocumentatie dat het naar een stdClass object wordt omgezet.
@Michael: dank je voor de links, ik kende ze, maar ik kan nog niet de verbinding maken met als ik data heb in objectvorm (json) en daar een "echt" object van te maken. Wat ik feitelijk wil is dat ik onderzoek hoe OOP nu precies werkt en hoe ik het praktisch kan toepassen. Maar aangezien ik een hobbyist en geen echte programmeur ben, is het soms moeilijk grip te krijgen op mijn gedachten en de mogelijkheden en wat ik nu precies wil. En probeer ik soms iets te veel iets perfect te programmeren terwijl er vaak meerdere wegen zijn die naar Rome leiden. Indien nodig probeer ik het wel verder te verduidelijken, maar ik denk dat ik met de huidige reacties al aardig op weg ben.
@Frank: Dank je voor je duidelijke en heldere uiteenzetting. Ik denk dat je gelijk hebt en dat ik de json beter als array kan zien en de data in een echt object moet inlezen. Heb je een voorbeeld van die fromArray() en toArray() methoden bij de hand? Ik kan me voorstellen dat het gewoon een loop wordt of is er iets snellers? Ik neem aan dat dat object weer als json weg te schrijven is?
Ten aanzien van mijn andere vraag, zijn er andere methoden om informatie uit een form via POST terug te sturen naar de server? Of moet het gekoppeld zijn aan een <input> tag?
Gewijzigd op 16/01/2020 11:24:59 door j opla
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
<?php
class Child {
protected $name;
public function getName() {
return $this->name;
}
public function setName($name) {
$this->name = $name;
}
public function toArray() {
return [
'name' => $this->name
];
}
public function fromArray(array $array) {
$this->name = $array['name'];
}
}
class Test {
protected $childs;
public function __construct() {
$this->childs = [];
}
public function addChild(Child $child) {
$this->childs[] = $child;
}
public function toArray() {
$childs = [];
foreach($this->childs as $child) {
$childs[] = $child->toArray();
}
return [
'childs' => $childs
];
}
public function fromArray(array $array) {
$this->childs = [];
foreach($array['childs'] as $child) {
$object = new Child();
$object->setName($child['name']);
$this->addChild($object);
}
}
}
$test = new Test();
$c = new Child();
$c->setName('child1');
$test->addChild($c);
$c = new Child();
$c->setName('child2');
$test->addChild($c);
$json = json_encode($test->toArray());
echo $json; // {"childs":[{"name":"child1"},{"name":"child2"}]}
$test->fromArray(json_decode($json, true));
print_r($test);
?>
class Child {
protected $name;
public function getName() {
return $this->name;
}
public function setName($name) {
$this->name = $name;
}
public function toArray() {
return [
'name' => $this->name
];
}
public function fromArray(array $array) {
$this->name = $array['name'];
}
}
class Test {
protected $childs;
public function __construct() {
$this->childs = [];
}
public function addChild(Child $child) {
$this->childs[] = $child;
}
public function toArray() {
$childs = [];
foreach($this->childs as $child) {
$childs[] = $child->toArray();
}
return [
'childs' => $childs
];
}
public function fromArray(array $array) {
$this->childs = [];
foreach($array['childs'] as $child) {
$object = new Child();
$object->setName($child['name']);
$this->addChild($object);
}
}
}
$test = new Test();
$c = new Child();
$c->setName('child1');
$test->addChild($c);
$c = new Child();
$c->setName('child2');
$test->addChild($c);
$json = json_encode($test->toArray());
echo $json; // {"childs":[{"name":"child1"},{"name":"child2"}]}
$test->fromArray(json_decode($json, true));
print_r($test);
?>
>> Ten aanzien van mijn andere vraag, zijn er andere methoden om informatie uit een form via POST terug te sturen naar de server? Of moet het gekoppeld zijn aan een <input> tag?
Met AJAX kun je zelf de post data samenstellen (al dan niet uit een formulier) en anders wordt het een <input type="hidden" name="myName" value="hidden value">
Gewijzigd op 16/01/2020 13:03:29 door Frank Nietbelangrijk
Heb je misschien ook een voorbeeld hoe ik met AJAX iets terug stuur en het op vang met php? Mag ook een goede verwijzing zijn naar een tutorial of zo hoor?
Toevoeging op 16/01/2020 15:59:19:
Nog een andere vraag. Ik heb een aantal items, bijvoorbeeld 50, genummerd van 1 t/m 50. Dus Item1, Item2 ... Item50. De items zijn verdeeld over een aantal categorieën, bijvoorbeeld 5, cat1, cat2 ... cat5. Maar niet bij elke categorie zitten evenveel items:
voorbeeld:
cat1: item1 ... item12
cat2: item12 ... item18
cat3: item18 ... item32
etc.
Elk item kan 3 waarden hebben, 0, 1 of 2. Elke categorie kan ook en aantal waarden hebben, zoals een naam.
Ik wil in mijn html deel de items per categorie kunnen laten zien.
Voor mijn gevoel is het het handigste om de items onder de categorie onder te brengen, maar ik kan me ook voorstellen dat andersom misschien handiger kan zijn.
In een pure database zou ik 3 tabellen maken, een tabel met categorien, een tabel met items en een tabel die een item id aan een categorie id koppelt. Hoe zou ik dat met objecten moeten zien? Of denk ik nu te puriteins?
Je hebt het over json, objects, data naar een server? Dus gewoon opslaan?, database normalisatie, categorisatie?
Al die deze dingen hoeven geen verband met elkaar te hebben.
Misschien is het handig om te uitleggen wat je precies wilt bereiken.
"Voor mijn gevoel is het het handigste om de items onder de categorie onder te brengen, maar ik kan me ook voorstellen dat andersom misschien handiger kan zijn."
Hoe jij het wilt weergeven is helemaal aan jou. Maar zoals je de tabellen schetst zou dat in ieder geval prima kunnen.
Als een item altijd alleen maar 0, 1 of 2 bevat hoef je daar natuurlijk geen tabel voor te maken, behalve als dat makkelijker is.
Ik werk zelf met JQuery. Ik weet niet of je hier enigszins bekend mee bent?
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
$.ajax({
url: "test.php",
method: "post",
data: {"var1":"value1","var2":"value2"}
}).done(function(data) {
alert(data);
});
url: "test.php",
method: "post",
data: {"var1":"value1","var2":"value2"}
}).done(function(data) {
alert(data);
});
>> In een pure database zou ik 3 tabellen maken, een tabel met categorien, een tabel met items en een tabel die een item id aan een categorie id koppelt. Hoe zou ik dat met objecten moeten zien?
Dan maak je een ManyToMany relatie tussen producten en categorieën. Dit betekend dat een categorie meerdere producten kan bevatten maar ook dat een product in meerdere categorieën kan worden ingedeeld.
En dus kun je eigenlijk een beetje mijn Test class overnemen welke een array heeft naar een andere class (in mijn voorbeeld Child). Alleen zouden beiden classen dan een array kunnen hebben. Namelijk:
een class Categorie welke een array heeft met Product classes
een class Product welke een array heeft naar Categorie classes
Vervolgens hangt het van je weergave af wat de Hoofdclass wordt. Wil je
cat1: item1 ... item12
cat2: item12 ... item18
cat3: item18 ... item32
laten zien dan pak je een array van Category classes waarin je elke Category class vult met een array van Product classes. In je view hoef je dan alleen maar iets te doen als:
Dank je voor je heldere uitleg.
JQuery ken ik alleen van naam en AJAX vooral als voetbalclub, dus ik denk dat ik wat dat betreft iets minder ambieus moet gaan zijn op dit moment en het met een hidden input ga doen.
Nog even terug naar je eerdere voorbeeld:
op regel 32 staat:
Code (php)
1
public function addChild(Child $child) {
Betekent de (Child $child) dat de de opgeroepen variabele $child van het type class Child is? Net als dat op regel 20 en 48 de variabele $array van het type array is? Of heeft het een andere betekenis? Wat is de reden dat dat specifiek genoemd moet worden, want op regel 10 geef je niet aan dat het om een string gaat?
En wat zou je vervolgens met deze objecten willen doen wat je niet met arrays of array-functionaliteit zou kunnen doen?
En zelfs als je geneste arrays hebt, waarbij recursie (functies die zichzelf aanroepen) handig kunnen zijn dan zou je hiervoor een eenvoudige klasse kunnen bakken, maar dan heb je nog steeds enerzijds de OOP-code en anderzijds je data, initieel in array-vorm, en mogelijk een nieuwe datastructuur die je in deze klasse bouwt, maar die dan nog steeds een array is. Je gebruikt dan OOP als hulpmiddel, maar dat wil niet zeggen dat je overal maar een OOP-saus overheen hoeft te gooien.