Witam

Fragment przykładowej klasy:

[PHP] pobierz, plaintext 
class Parse_Data
{
    public $data = array();
    /**
     * Create an instance of Parse_Data
     *
     * @staticvar empty $instance
     * @return object
     */
    public static function instance()
    {
        static $instance;
        empty( $instance ) AND $instance = new Parse_Data;
        return $instance;
    }
    /**
     *
     * @param array $post
     * @param array $data
     * @return boolean
     */
    public function check( $post, array $data )
    {
        $this->data = new Validation( $post );
        $this->data->pre_filter( 'trim' );
        foreach( $data as $k => $v )
        {
            $this->data->add_rules( $k, $v );
        }
        return $this->data->validate();
    }
}
[PHP] pobierz, plaintext 

i sposób w jaki chcę jej użyć:

[PHP] pobierz, plaintext 
 if( Parse_Data::check( $_POST, array( 'art_title' => 'required',
                                                 'art_content' => 'required',
                                                 'art_teen' => 'numeric' ) ) )
[PHP] pobierz, plaintext 

i teraz kilka pytań:
1. Dlaczego nie zwraca to błędu mimo iż check() nie jest statyczna?
2. W jaki sposób mogę dostać się do zmiennej $data z zewnątrz czyli coś w ten deseń Parse_Data::instance()->data ? ( oczywiście to nie działa tylko dlaczego )
3. Czy jedyny sposób do utworzenie zmiennej $data jako statycznej i odwołanie się do niej w postaci Parse_Data::$data czy pozostawienie jej zwykłą ( nie statyczną ) i utworzenie metody dzięki której będzie do niej dostęp ?

Dlatego, że takie odwołanie do metody klasy (publicznej) jest również składniowo poprawne, mimo, iż nie jest ona metodą statyczną.
Natomiast na pewno zwraca Ci błąd w tym miejscu:

[PHP] pobierz, plaintext 
$this->data = new Validation( $post );
$this->data->pre_filter( 'trim' );
[PHP] pobierz, plaintext 

a czemu, wyjaśniam Ci poniżej.


Podany przez Ciebie sposób nie zadziała z prostej przyczyny: -> to operator dostępu do składowej z obiektu klasy, a Ty wywołujesz po prostu metodę klasy bez tworzenia obiektu. Więc zaprezentowany przez Ciebie przykład jest totalnie pozbawiony sensu: Parse_Data::instance() nie jest obiektem, lecz odwołaniem do metody instance() w klasie Parse_Data.


Jedyny sposób to:

[PHP] pobierz, plaintext 
 static $data
 print_r Parse_Data::data;  
[PHP] pobierz, plaintext 

Nie zwrócisz składowej niestatycznej jako wyniku wywołania metody (czyli return $this->skladowa;), bo wywali Ci parse errora, że używasz $this na czymś, co nie jest obiektem, a tak by się stało w tym przypadku:

[PHP] pobierz, plaintext 
<?php
 
class Parse_Data
{
    public $data = array('1' , '2');
 
    public function getData($var_name) {
       return $this->$var_name;
    }
}
 
 
 
$a = Parse_Data::getData('data');
 
[PHP] pobierz, plaintext 

rezultat:
Fatal error: Using $this when not in object context in /var/www/test/index.php on line 8

To sporo mi wyjaśniło
przekształcenie metody w następujący sposób sprawia, że jest ok

[PHP] pobierz, plaintext 
public function check( $post, array $data )
    {
        self::$data = new Validation( $post );
        self::$data->pre_filter( 'trim' );
        foreach( $data as $k => $v )
        {
            self::$data->add_rules( $k, $v );
        }
        return self::$data->validate();
    }
[PHP] pobierz, plaintext 

z tym że wydaje mi się trochę dziwny ( dziwnie wygląda to self ) wiem że to jest sposób aby odwoływać się to zmiennych statycznych ale czy to jest właściwy sposób rozwiązania tego problemu?

No raczej tak, tylko może zrób z tego normalną metodę statyczną, zadeklaruj $data jako static, no i odwołuj się do niej self::$data w każdym odwołaniu. A generalnie mam pytanie: nie da się tej klasy Parse_Data tak napisać, żeby utworzyć normalny jej obiekt i móc do jej metod odwoływać się poprzez $Parse_Data_Object->metoda() ?

Hmm metoda tej klasy jest wywoływana wiele razy w różnych plikach. Uznałem, że lepiej zrobić ją statyczną niż za każdym razem tworzyć jej obiekt. Chyba, że jest inny sposób na taki przypadek niż metody statyczne?

W takim razie zrób z Parse_Date singletona. Obiekt utworzysz raz, a będziesz mógł sobie używać normalnych metod wszędzie, gdzie będzie to potrzebne.

a czy właśnie metoda instance() nie jest singletonem?
i odwoływanie się w taki sposób Parse_Data::instance()->check(); przykładowo?

nie jest singeltonem: Wzorce projektowe - singleton - niżej masz inne dosyć dobrze opisane...
zrób tak jak radzi Blooregard,

lub całkiem inaczej bez singeltona: jeśli masz problem z zasięgiem to weź na uwagę, że przypisując dalej już utworzoną klasę nie kopiujesz jej domyślnie a domyślnie w php5 przekazujesz referencję do niej... tak więc:
$a=new klasa();
$b=$a;// i tu jest przekazana referencja - w php4 to tak jak z zmiennymi $b=&$a;

więc jeśli przekażesz klasę jako parametr funkcji przekażesz referencję do niej...
jeśli w jakimś konstruktorze bądź metodzie przypiszesz klasę do zmiennej prywatnej, publicznej (i na upartego statycznej) to masz też odwołanie przez referencję z wewnątrz tej klasy... więc jeśli chcesz mieć tą samą klasę w innych klasach, ale tą samą instancję to utwórz tą instancję klasy przed tworzeniem następnych i przekaż ją konstruktorowi bądź przypisz ją przez jakąś metodę - nie twórz instancji wtedy klasy w konstruktorze przez new - chyba, że chcesz mieć nową instancję - nie zależny inny obiekt... jeszcze poczytaj o niuansie private i protected - zwłaszcza jesli będziesz miał rozszerzać klasy...

function cos($x){$x->metoda();};
//użycie:
cos($a); //itd...

w manualu:
Objects and references

po przeczytaniu wyżej podlinkowanego arta zmodyfikowałem nieco i teraz jest:

[PHP] pobierz, plaintext 
class Parse_Data
{
    public static $data = array();
    private static $_instance = null;
 
    private function __construct(){}
    /**
     * Create an instance of Parse_Data
     *
     * @return object
     */
    public static function instance()
    {
        if( is_null( self::$_instance ) )
        {
            self::$_instance = new Parse_Data();
        }
        return self::$_instance;
    }
    /**
     *
     * @param array $post
     * @param array $data
     * @return boolean
     */
    public function check( $post, array $data )
    {
        self::$data = new Validation( $post );
        self::$data->pre_filter( 'trim' );
        foreach( $data as $k => $v )
        {
            self::$data->add_rules( $k, $v );
        }
        return self::$data->validate();
    }
}
[PHP] pobierz, plaintext 

na moje oko ( niezbyt jeszcze wprawione ) wydaję się ok i spełnia swoje zadanie.
Co do drugiego sposobu to nie chcę ładować tworzenia instancji klasy do nadrzędnego konstruktora bo nie będzie ona na każdej podstronie wykorzystywana, więc singleton wydaje mi się lepszym rozwiązaniem.

ok - ale drobny szczegół - jak już tak zrobiłeś to w metodzie check mogłeś zamiast self użyć $this i zmienna $data nie musi być statyczna ;p

i tak tez zrobiłem