associative arrays (PHP) in javascript stijl schrijven
Loop al een tijd te zoeken maar heb nog niet echts iets gevonden wat me op weg helpt, ik zoek geen uitgewerkte codes ofzoiets, ik schrijf ze zelf wel, de vraag is:
Weet iemand hoe je eigen functies kan schrijven,
Met eigen functies bedoel ik dat je zelf de operator bepaald wat de key en value is, wat voor javascript ':' is in php '=>'.
bijvoorbeeld een associative array in php
$array = array(
key1 => 'blup',
key2 => 'bla',
etc => ..
);
te schrijven op javascript manier?
var array = {
key1 : 'blup',
key2: 'bla',
etc : ...
};
Ik had zoiets in gedachten, werkt alleen als alles een string is (in psuedo, laten we het functie p noemen)
function p($string) {
$array = array();
foreach(split(',', $string) as $line) {
list($key, $input) = split(':', $line
$array[$key] = $input;
}
return $array;
}
functie zou je dan zo kunnen gebruiken
$array = p("
key1 : bla,
key2: blup,
etc..
");
blijft het alleen voor data type strings,
bedankt..
Gewijzigd op 01/01/1970 01:00:00 door Fuzzie -
dan meot je objecten gaan gebruiken
http://www.javascriptkit.com/javatutors/object2.shtml
Denk dat je wel iets aan die tutorial hebt
de implementatie hiervan is op twee niveau's, numerical en associative (hash, map), de delemiter oftwel array_case_operator voor associative staat dus standaard op '=>', de linker operant (de key) en de rechter operant (de inhoud) bepalen de waardes van een associative array in PHP., elke waarde is gescheiden door een comma ','.
Het is mij wel duidelijk dat ik hiervoor een object moet schrijven (in PHP trouwens) maar niet hoe ik zelf de operator kan defineren en hoe ik de linker en rechter kant van de operator bepaal, in javascript weet ik dit wel, behalve PHP niet ..
De link is Javascript gebaseerd, maar bedankt voor je reply ;)
Gewijzigd op 01/01/1970 01:00:00 door fuzzie -
Bedankt
Ik heb 2 pagina's gemaakt omdat ik daar makkelijker mee werk.
Pagina: arraySplitsen.php
Code (php)
Pagina: test.php
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
<?
include_once("arraySplitsen.php");
$s = new Splitsen();
$sa = $s->splits("key1:bup,key2:ha,key3:etc");
foreach($sa as $key => $waarde){
echo "de $key is $waarde<br />";
}
?>
include_once("arraySplitsen.php");
$s = new Splitsen();
$sa = $s->splits("key1:bup,key2:ha,key3:etc");
foreach($sa as $key => $waarde){
echo "de $key is $waarde<br />";
}
?>
De uitkomst:
"de key1 is bup
de key2 is ha
de key3 is etc"
Als jij wil als jij naar een manier wil om
Code (php)
1
2
3
4
2
3
4
// hier is de => vervangen door :
foreach($sa as $key : $waarde){
echo "de $key is $waarde<br />";
}
foreach($sa as $key : $waarde){
echo "de $key is $waarde<br />";
}
te doen, moet ik je teleurstellen, dit is niet mogelijk in PHP. Elke taal heeft zo zijn eigen sintax.
Het blijven strings... Echt veel meerwaarde heeft het niet.
Gewijzigd op 01/01/1970 01:00:00 door Jelmer -
source:
http://ioreader.com/2007/08/17/11-cool-things-about-php-that-most-people-overlook/
-------------------------------------------------------------
They definitely don't compare to what Python offers but they can be pretty nifty. Couple these functions with the SPL and some pretty cool classes can be made.
__call()
The __call() magic function allows for a class to call functions that it doesn't necessarily have. For example, if there are a lot of redundant functions in a class that work in very similar ways but still require a slight amount of custom logic then maybe __call() would allow for a better implementation. Consider an associative array where the keys represent a white list of functions that __call should work with and their values would somehow allow __call to implement the slight differences between the functions.
If that example seems unlikely then let me detail two ways that I've used __call.
The first way was implementing filters for different MySQL data types. Data for VARCHAR, INT, CHAR, TEXT, et al. can all be handled in very similar ways but require slightly different type casts and regular expressions checks. Well, storing the unique checks in an array with function names for each data type dramatically reduced the amount of redundant code I had to write and made the system more maintainable for when I needed to add more data types to the list.
The second way that I implemented __call() was for credit card processing APIs. I recently made a library to interact with the Authorize.net API and it was expected of me that in the event that the processor was changed that the only thing that would need to be changed is the call to instantiate the appropriate class. If anyone has worked with payment processors before then they will know that the data they accept can be crytpic (eg: x_login, x_customer_cc). To make things simple, I used call to map an associative array of keys (function names) to the processor-specific variables that they modified. Instead of setting an x_login field, I could do: $AIM->login().
__get(), __set(), __isset(), __unset()
These act similarly to ArrayAccesses offsetGet, offsetSet, etc etc, except that these functions allow you to access non-existent instance variables.
__toString()
What happens when you try to echo a class instance? Normally the output will be the unhelpful Object id #1 (or another number). This can be changed though! Changing what is returned from an echo is as simple as defining a custom __toString() method and giving it a custom return value.
-------------------------------------
the offsets kan je dus zelf bepalen, maar ik merk al dat niemand hier echt
mee bezig is geweest dan meteen te zeggen "het kan niet", maar iig bedankt voor de reply's.
Later.
Verder kan je nog met de interface ArrayAccess en de interface Iterator de werking van de []-haakjes bij een object, en de werking van een foreach-lus op een object aanpassen. Maar je kan geen eigen syntax maken, zoals jij wilt. Je kan hooguit hier en daar wat truucjes uithalen.
$obj1 implementeert __toString
$obj2 implementeert __toString
$obj1 . $obj2 = string, en niet een object... Dus je kan er niet verder mee. PHP is helaas geen Javascript. Persoonlijk mis ik vooral de functie-syntax en de closures van Javascript.
Gewijzigd op 01/01/1970 01:00:00 door Jelmer -
Gewijzigd op 01/01/1970 01:00:00 door Jelmer -
Sgoed, bedankt ;)