Ide per php per analizzare il funzionamento di un pattern

[giannino1995]

Mi consigliate un ide per php che mi permette di analizzare il funzionamento di un pattern? Vorrei capire il criterio con cui php passa da un metodo all'altro in un pattern che sto analizzando.

Attualmente sto provando dreamweaver ma non mi pare abbia questa funzione, ho anche provato netbeans ma neppure lui ha questa opzione.

[Alhazred]

Dreamweaver...
Quello è buono solo per generare montagne di codice inutile pur di far fare la paginetta html a chiunque.

Non ho mai sentito dell'esistenza di ciò che cerchi, non essendomene mai interessato non te lo do per certo, ma al 99% te le devi studiare da solo dove vanno le varie chiamate (che poi basta vedere nel codice le varie funzioni chiamate e ritrovarle nei vari file).

[Reiuky]

Io uso eclipse.

Nasce per Java e funziona con Java, ma ha delle versioni per php (cercale nel sito della ecplipse).

Poi c'è anche net-beans che ha di positivo che è in C e quindi è più leggero. Per il resto ha le stesse funzioni, solo ci si accede in modo diverso e passare dall'uno all'altro non è intuitivo.

Per la cronaca, con eclipse, tasto destro su un metodo e ti apre tutti i metodi che potrebbero essere richiamati con quel nome. Sta a te poi scegliere quello giusto. Ma intanto la scelta è tra pochi metodi.

[giannino1995]

Dreamweaver...
Quello è buono solo per generare montagne di codice inutile pur di far fare la paginetta html a chiunque.

Non ho mai sentito dell'esistenza di ciò che cerchi, non essendomene mai interessato non te lo do per certo, ma al 99% te le devi studiare da solo dove vanno le varie chiamate (che poi basta vedere nel codice le varie funzioni chiamate e ritrovarle nei vari file).

Condivido ma non su tutto. Dreamweaver fa abbastanza cagare però se studi un modello di questo tipo qui sotto una funzione di questo tipo (matlab per esempio ce l'ha) può essere davvero utile.

<?php
// start previous
abstract class Expression {
    private static $keycount=0;
    private $key;
    abstract function interpret( Context $context );

    function getKey() {
        if ( ! isset( $this->key ) ) {
            self::$keycount++;
            $this->key=self::$keycount;
        }
        return $this->key;
    }
}

class LiteralExpression extends Expression {
    private $value;

    function __construct( $value ) {
        $this->value = $value;
    }

    function interpret( Context $context ) {
        $context->replace( $this, $this->value );
    }
}

class Context {
    private $expressionstore = array();
    function replace( Expression $exp, $value ) {
        $this->expressionstore[$exp->getKey()] = $value;
    }

    function lookup( Expression $exp ) {
        return $this->expressionstore[$exp->getKey()];
    }
}

class VariableExpression extends Expression {
    private $name;
    private $val;

    function __construct( $name, $val=null ) {
        $this->name = $name;
        $this->val = $val;
    }

    function interpret( Context $context ) {
        if ( ! is_null( $this->val ) ) {
            $context->replace( $this, $this->val );
            $this->val = null;
        }
    }

    function setValue( $value ) {
        $this->val = $value;
    }

    function getKey() {
        return $this->name;
    }
}

// end previous


abstract class OperatorExpression extends Expression {
    protected $l_op;
    protected $r_op;

    function __construct( Expression $l_op, Expression $r_op ) {
        $this->l_op = $l_op;
        $this->r_op = $r_op;
    }

    function interpret( Context $context ) {
        $this->l_op->interpret( $context );
        $this->r_op->interpret( $context );
        $result_l = $context->lookup( $this->l_op );
        $result_r = $context->lookup( $this->r_op  );
        $this->doInterpret( $context, $result_l, $result_r );
    }

    protected abstract function doInterpret( Context $context, 
                                             $result_l, 
                                             $result_r );
}


class EqualsExpression extends OperatorExpression {
    protected function doInterpret( Context $context, 
                                        $result_l, $result_r ) {
            $context->replace( $this, $result_l == $result_r );
    }
}

class BooleanOrExpression extends OperatorExpression {
    protected function doInterpret( Context $context, 
                                        $result_l, $result_r ) {
        $context->replace( $this, $result_l || $result_r );
    }
}

class BooleanAndExpression extends OperatorExpression {
    protected function doInterpret( Context $context, 
                                        $result_l, $result_r ) {
        $context->replace( $this, $result_l && $result_r );
    }
}

$context = new Context();
$input = new VariableExpression( 'input' );
$statement = new BooleanOrExpression( 
    new EqualsExpression( $input, new LiteralExpression( 'four' ) ),
    new EqualsExpression( $input, new LiteralExpression( '4' ) ) 
);

foreach ( array( "four", "4", "52" ) as $val ) {
    $input->setValue( $val ); 
    print "$val:\n";
    $statement->interpret( $context );
    if ( $context->lookup( $statement ) ) {
        print "top marks\n\n";
    } else {
        print "dunce hat on\n\n";
    }
}

?>

Sono d'accordo con te, se ne può fare a meno ma in casi come questo si risparmiano 5 minuti, almeno per me che non sono abituato a lavorare con classi così complesse.

[W Thunderbird]

matlab per esempio ce l'ha

Cos'è che ha ?
Matlab non ha un linguaggio ad oggetti.

[giannino1995]

Cos'è che ha ?
Matlab non ha un linguaggio ad oggetti.

Sbagli ma qui non si sta a fare un confronto. Sopra ho scritto una frase che non riesco neppure io a decifrare, perdonatemi! Devo assolutamente andare dormire. Comunque ribadisco che può essere una cosa utile per velocizzare la lettura di un modello e l'individuazione di eventuali malfunzionamenti dovrebbero introdurla. Alhazred è molto preparato se dice che al 99% non c'è posso evitare di cercare. Un'occhiata ad Eclipse la do comunque per scrupolo.

[W Thunderbird]

E' vero, da matlab 2008 è possibile una programmazione ad oggetti. Adesso devo vedere se anche nella 2007 che abbiamo si può fare qualcosa.

[Grino]

Per carità non mi toccate NetBeans...

NetBeans è l'IDE Java open source della ex SunMicrosystem. Java ed il progetto NetBeans sono di proprietà della Oracle ora. NetBeans è scritto in Java e sviluppato con NetBeans stesso. Oracle promuove NetBeans come IDE ufficiale di Java, anche se può non piacere. D'altra parte se il produttore del linguaggio è lo stesso dell'IDE, un piccolo vantaggio lo ha. NetBeans supporta vari linguaggi e compilatori tramite plugin. Alcune di queste estensioni sono ufficiali di NetBeans e quindi gondono di un supporto, stabilità e caratteristiche d'integrazione significativo. Altre estensioni sono della community, e potrebbero avere qualche lacuna o perdersi con il tempo. Al momento del dowload puoi scaricare una versione qualunque, tanto poi gli altri plugin li scarichi direttamente da dentro NetBeans e ti ritrovi ciò di cui hai bisogno.

Oggigiorno IntelliSense (ctrl+space) lo hanno tutti gli ide degni di questo nome, altrimenti sono dei blocco note evoluti.

Detto questo, non mi è chiaro cosa intendi per "capire il criterio con cui php passa da un metodo all'altro in un pattern" dato che PHP non adotta alcun criterio se non quello previsto dal pattern stesso e programmato in un (quasi) qualunque linguaggio. Ciò che puoi fare, installando netbeans (penso anche eclipse) ed xdebug è eseguire il debug dello script php impostando i breakpoint nell'IDE e vedendo l'esecuzione una riga per volta in "step in", "step out" e "step over" o riprendendo l'esecuzione, il tutto dentro l'ide stesso. In tal modo puoi osservare il contenuto delle variabili, compresi gli oggetti, di tuo interesse e le varie chiamate entrando di volta in volta nel metodo da eseguire ed eseguendolo una riga per volta (step in). Ciò non di meno il comportamento del pattern, e quindi il criterio alla base delle invocazioni di metodi, è quello descritto dalla teoria alla base del pattern stesso.

Puoi anche integrare nell'IDE APIGen per ottenere la documentazione dal codice, sempre che ci siano i commenti di documentazione nel codice e non puro codice come quello che hai postato ceh produrrebba una documentazione relativamente utile.

Comunque il codice che hai postato incuriosice... se ho tempo lo guardo.

[giannino1995]

Ciò che puoi fare, installando netbeans (penso anche eclipse) ed xdebug è eseguire il debug dello script php impostando i breakpoint nell'IDE e vedendo l'esecuzione una riga per volta in "step in", "step out" e "step over" o riprendendo l'esecuzione, il tutto dentro l'ide stesso. In tal modo puoi osservare il contenuto delle variabili, compresi gli oggetti, di tuo interesse e le varie chiamate entrando di volta in volta nel metodo da eseguire ed eseguendolo una riga per volta (step in).

Ecco, allora spiegami come fare perché è proprio quello che mi interessa!

Comunque il codice che hai postato incuriosice... se ho tempo lo guardo.

Lo script non fa assolutamente nulla di informaticamente utile, prova a digitarlo e vedrai, è un modello che aiuta a capire la programmazione ad oggetti. Ovviamente se ti interessa studiarlo non azionarlo prima di decifrarlo altrimenti non ci sarebbe gusto. Io prima di leggere la soluzione provo a scriverla.

[giannino1995]

Se creo un progetto e poi ci copio dentro lo scrip inserendo ad esempio vicino al ciclo for finale i quadratini rossi a lato quando faccio girare il programma non si ferma e mi da il risultato.