[PHP5] anomalia del metodo __toString

[andr3a]

ora, a prescindere dall'utilità ... qualcuno sa dirmi perchè sto diamine di PHP 5 non riesce a seguire un filo logico che è uno?

<?php
class DynamicFunction {
    private $callback;
    function __construct(){
        $this->callback = create_function('', 'return "Hello World!";');
    }
    function __toString(){
        return ''.$this->callback;
    }
}

$f = new DynamicFunction();
$s = ''.$f;
echo $s(); // Hello World!
echo $f(); // Fatal Error ... 
?>

ogni consiglio sul come emulare il comportamento senza errori è bene accetto (considerando che ovviamente il call_user_func(_array)? sull'istanza ovviamente va ma non è quello che cerco)

Il succo è questo:
perchè se assegno ad una variabile il nome di una funzione posso usarla "come per magia" stile shortcut di funzione mentre se esplicito un __toString per avere un nome funzione questo non è il reale valore letto/usato dal parser?

// pure questo funziona, nonostante il notice
$s = str_replace;
echo $s('a', 'z', 'abc'); 

[piero.mac]

non suggerisco nulla, e manco ti preciso nulla .... personalmente sono un "gnunu" col php... ma...

ma quel $f non dovrebbe contenere un oggetto??? e non una stringa da leggere con echo....

hai provato con un var_dump($f) ????

[andr3a]

il problema piero è che quando usi una variabile come se fosse una funzione, il parser legge il contenuto della variabile e se è una funzione valida la usa ... perchè PHP praticamente è tutto una stringa ...

$replace = 'str_replace';
echo $replace('a', 'c', 'abc');
// "cbc"

Ora lo so che l'idiota sono io ad aspettarmi che con un linguaggio di scripting si riesca un pò "a giocare" al punto da costringere il parser a leggersi il contenuto "stringa" dell'oggetto e sfruttarlo come tale ... ma possibile che ogni volta che penso pensa se potessi fare questo puntualmente PHP non me lo permette?

Il post l'ho aperto perchè secondo me, dato che con call_user_func o call_user_func_array l'oggetto viene automaticamente convertito in stringa tramite il __toString, e dato che il Fatal Error è sul nome della funzione
Function name must be a string
mi domando perchè questi metodi definiti "magici" non riescano mai a sorpendere e si comportino in questo caso in questo modo, a mio avviso, anomalo ... ma magari sono io che ho mal interpretato quello che fa sempre, tranne in questo caso, il PHP quando sfrutti una var come funzione (cercare il suo valore stringa e sfruttare la funzione se esistente) ...

[andr3a]

giusto per fare un altro appunto ...

class A{}
$s = 'A';
$a = new $s;
var_dump($a);
// object(A)#1 (0) { }

... quindi continuo a non capire ...

[piero.mac]

// pure questo funziona, nonostante il notice
$s = str_replace;
echo $s('a', 'z', 'abc'); 

Qui scrivi una costante (che non esiste) e ricevi il notice, il php la converte di suo in una stringa. Ora $s contiene una stringa che verra' interpretata come funzione nel momento in cui accodi alla stringa delle istruzioni valide. Altrimenti e' e rimarra' una stringa. Gia' e' "magico" questo fatto e non sempre puo' essere utile e/o gradito.

Forse si dovrebbe prima provare e poi dire che non si puo' e trovare una soluzione, come gia' fai tu. D'altronde le migliorie ed i servizi arrivano quando qualcuno ne sente il bisogno e le fa, non un attimo prima.

Purtroppo molti sviluppatori (e non solo php) sono piu' tesi a difendere comunque il loro operato piuttosto che aprirsi a nuove indicazioni. Questo e' il vero problema.... troppo giovani e troppo alteri pensano di avere il mondo in tasca e non si accorgono di essere solo dei moderni scrivani.

[andr3a]

Originariamente inviato da piero.mac
Qui scrivi una costante (che non esiste) e ricevi il notice ...

si piero, ho detto perfino questa proprio perchè mi aspetterei meglio un fatal su queste schifezze che su quello che io tento di fare dando per assunto che php legge il valore "castato in stringa" in automatico se faccio ad esempio (senza notice)

$s = 'str_replace'; echo $s('.piero', '.mac', 'piero.piero');

come se faccio

new $s;

insomma, l'interprete cerca il valore contenuto nella variabile ... può non essere gradito, ma PHP l'ha sempre fatto ed è anche molto comodo in certi casi

$parameter = 'value';
echo $instance->$parameter;

PHP è scripting, è compilato runtime ... ha vincoli o comportamenti strani che non sono sempre identici ... questo è un caso, e a me da fastidio come caso perchè mi impedisce di cambiare comportamento, dove io lo ritengo necessario, e mi costringe ad usare un prolisso call_user_func



P.S. ... senza dimenticare cose tipo ...

$v1 = 'value';
$v2 = 'v1';
echo $$v2; // value

insomma, mi cade proprio sulle istanze nonostante la forzatura sul __toString ...