PHP Action each function preforms

I have the following situation.

I have a class with a lot of functions. Each function starts with executing the same method. Is there a way that I can like implement this method into the function so that it is executed automatically?

He开发者_StackOverflowre is an example:

class test
{
 static function_1($param) {some_method($param); other stuff....} 
 static function_2($param) {some_method($param); other stuff then function 1....} 
 static function_3($param) {some_method($param); other stuff then function 1 and function 2....} 
}

So is there a way to execute some_method(); automaticly without declaring it in each function?

Thanks in advance!

Whole code:

<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
/*
 * The Assets Library
 * 
 * This class let's you add assets (javascripts, stylesheets and images) way easier..
 */


class Assets {
    private $css_url;
    private $js_url;
    private $img_url;

    public function __construct()
    {
        $CI =& get_instance();
        $CI->config->load('assets');

        $asset_url = base_url() . $CI->config->item('assets_dir');
        $this->css_url = $asset_url . $CI->config->item('css_dir_name');
        $this->js_url = $asset_url . $CI->config->item('js_dir_name');
        $this->img_url = $asset_url . $CI->config->item('img_dir_name');
    }

    // Returns the css html link
    public function css_html_link($filename)
    {
        // Check whether or not a filetype was given
        $filename = $this->_add_filetype($filename, 'css');

        $link = '<link type="text/css" rel="stylesheet" href="' . $this->css_url . $filename . '" />';
        return $link;
    }

    // Returns the css link
    public function css_link($filename)
    {
        $filename = $this->_add_filetype($filename, 'css');

        return $this->css_url . $filename;
    }

    // Returns the js html link
    public function js_html_link($filename)
    {
        $filename = $this->_add_filetype($filename, 'js');

        $script = '<script type="text/javascript" src="' . $this->js_url . $filename . '"></script>';
        return $script;
    }

    // Return the js link
    public function js_link($filename)
    {
        $filename = $this->_add_filetype($filename, 'js');

        return $this->js_url . $filename;
    }

    // Returns the image html tag
    public function img_html_link($filename, $rel = NULL)
    {
        // Get the filename without the filetype
        $alt_text = substr($filename, 0, strpos($filename, '.')+1);
        $alt_text = 'alt="'.$alt_text.'"';

        // If relation is giving, use it
        $img_rel = ($rel !== FALSE) ? 'rel="' . $rel . '"' : '';

        $image = '<img src="' . $this->img_url . $filename . '" '.$rel.' ' . $alt_text . '/>';
        return $image;
    }

    // Return the image link
    public function img_link($filename)
    {
        return $this->img_url . $filename;
    }

    // Check whether or not a filetype was specified in $file, if not, it will be added
    private function _add_filetype($file, $type)
    {
        if(strpos($file, '.' . $type) === FALSE)
        {
            $file = $file . '.' . $type;
        }
        return $file;
    }
}

/* End of file assets.php */
/* Location: ./application/libraries/assets.php */

every time you initiate the class, it calls the __construct() function, or in PHP 4 (I hope you are not using php 4) it uses the function with the same name as the class

If you do this, it should work for every initiate of the class:

function __construct($param){
    some_method($param);
}

if you call multiple functions in the same initiation of the class, you could do this:

var $param;

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

function doMethod(){
    some_method($this->param);
}

function function_1()
{
    $this->doMethod();
}

Calling the class multiple times, with different params. Perhaps try this approach:

function __call($function, $param){
    some_method($param);
    switch ($function){
         case 'function1':
         $this->function1($param);
         break;
         /// etc..
    }
}

I'm afraid that in this case the answer is 'no'.

You're not 'declaring' some_method() each time, you are calling it. If you don't call it, it can't run, so you have to call it each time.

Cut & paste.....

Why not paste your actual code here, some refactoring may help.

Edit after seeing actual code

I can't see the problem with your existing code. It is clear and you will know what it does in a year's time. I would keep it as it is. The answer you accepted will work, but it is obfuscating your code. You will have problems working out what you did and why you did it in when you come back to maintain your code in the future.

You could create a class containing an instance of the class test (composition) and implement its __call magic method. Something akin to:

class testWrapper
{
    private $test;

    function __construct()
    {
        $this->test = new Test();
    }

    function __call($name, $args)
    {
        call_user_func_array(array($this->test, 'some_method'), $args);
        call_user_func_array(array($this->test, $name), $args);
    }
}

You then call methods from the test class on the instance object of testWrapper. You can further refine the logic in the __call method to only call some_method() based on the passed-in method name, etc.