Can I include code into a PHP class?

问题:

I want to make a PHP class, lets say Myclass.php. Now inside that class I want to define just the class itself and some instance variables. But all the methods must come from a Myclass_methods.php file. Can I just include that file into the class body?

I have good reasons why I want to seperate this. In short, I\'ll have a backend in which I can change the business logic of a class, while all other things must remain untouched. The system maintains all the ORM and other stuff for me.

But if this is a bad idea, it might be better to re-generate the whole class file after editing the business logic (so, the user-defined methods in this case).

Performance question: If during one request Myclass.php is included just once, actually that Myclass_methods.php should also be included just once. Might be wrong. Experts?

回答1:

No. You cannot include files in the class body.
In a file defining a class, you may only include files in a method body or outside the class body.

From your description I take you want this:

<?php // MyClass.php
class MyClass
{
    protected $_prop;
    include \'myclass-methods.php\';
}

<?php // myclass-methods.php
public function myMethod()
{
   $this->$_prop = 1;
}

Running this code will result in

Parse error: syntax error, unexpected T_INCLUDE, expecting T_FUNCTION

What is possible though is this

<?php // MyClass.php
class MyClass
{
    protected $_prop;
    public function __construct() // or any other method
    {
        include \'some-functions.php\';
        foo($b); // echoes \'a\';
    }
}

<?php // some-functions.php
$b = \'a\';
function foo($str)
{
   echo $str;
}

Doing it this way, will import the contents of the include file into the method scope, not the class scope. You may include functions and variables in the include file, but not methods. You could but should not put entire scripts into it as well and change what the method does, e.g.

<?php // MyClass.php
    // ...
    public function __construct($someCondition)
    {
        // No No Code here
        include ($someCondition === \'whatever\') ? \'whatever.php\' : \'default.php\';
    }
    // ...

<?php // whatever.php
    echo \'whatever\';

<?php // default.php
    echo \'foo\';

However, patching the class this way to exhibit different behavior is not how you should do it in OOP. It\'s just plain wrong and should make your eyes bleed.

Since you want to dynamically change behavior, extending the class is also not a good option (see below why). What you really will want to do is write an interface and make your class use objects implementing this interface, thus making sure the appropriate methods are available. This is called a Strategy Pattern and works like this:

<?php // Meowing.php 
interface Meowing
{
    public function meow();
}

Now you got the contract that all Meowing Behaviors must obey, namely having a meow method. Next define a Meowing Behavior:

<?php // RegularMeow.php
class RegularMeow implements Meowing
{
    public function meow()
    {
        return \'meow\';
    }
}

Now to use it, use:

<?php // Cat.php
class Cat
{
    protected $_meowing;

    public function setMeowing(Meowing $meowing)
    {
        $this->_meowing = $meowing;
    }

    public function meow()
    {
        $this->_meowing->meow()
    }
}

By adding the Meowing TypeHint to setMeowing, you make sure that the passed param implements the Meowing interface. Let\'s define another Meowing Behavior:

<?php // LolkatMeow.php
class LolkatMeow implements Meowing
{
    public function meow()
    {
        return \'lolz xD\';
    }
}

Now, you can easily interchange behaviors like this:

<?php
require_once \'Meowing.php\';
require_once \'RegularMeow.php\';
require_once \'LolkatMeow.php\';
require_once \'Cat.php\';

$cat = new Cat;
$cat->setMeowing(new RegularMeow);
echo $cat->meow; // outputs \'meow\';
// now to change the behavior
$cat->setMeowing(new LolkatMeow);
echo $cat->meow; // outputs \'lolz xD\';

While you also could have solved the above with inheritance by defining an abstract BaseCat and meow method and then deriving concrete RegularCat and Lolkat classes from that, you have to consider what you want to achieve. If your cats will never change the way they meow, go ahead and use inheritance, but if your RegularCat and Lolkat is supposed to be able to do arbitrary meows, then use the Strategy pattern.

For more design patterns in PHP, check these resources:

• http://www.php.net/manual/en/language.oop5.patterns.php
• http://www.ibm.com/developerworks/library/os-php-designptrns/
• http://www.fluffycat.com/PHP-Design-Patterns/
• http://sourcemaking.com/design_patterns

回答2:

Might it not be an idea to create the core class with the relevant base functionality and then extend this with the required methods - it seems like a more logical approach.

回答3:

I\'ll start by saying I\'m not too clear why this problem is not best solved using a base class containing the methods, subclasses containing the data, and dynamic class loading. I\'ll assume you have a good reason.

Once your provider supports PHP 5.4 you can do what you want using traits.

Code File:

if ($pet === \'dog\') include \'dog.php\';
elseif ($pet === \'cat\') include \'cat.php\';
else die(\'Unknown pet\');

class Pet {
  use PetSounds;
}

$myPet = new Pet();
$myPet->speak();

File cat.php

trait PetSounds {
  function speak() { echo \'meow\'; }
}

File dog.php

trait PetSounds {
  function speak() { echo \'woof\'; }
}

You could make this even cleaner by naming both include files the same, putting them in different subdirectories, and using set_include_path() or defining an __autoload() function to select between them. Like I said though, this same problem could be solved better using inheritance. If you have a multiple-inheritance type problem though, if for instance you have four kinds of pets with five kinds of colors with three hair types and you need a different combination of methods for each of the 60 different classes, this is the right solution.

5.4 is currently just a Release Candidate (as of 2/24/2012) and even once released most hosts will not support it for many months - mine took 18 months after 5.3 was released before they would support it. Until then you must write entirely separate and complete class files. You can however format your classes with an eventual change to traits in mind.

Right now you can partially get what you want using magic methods and have an easy upgrade to traits when they are available.

Code File:

if ($pet === \'dog\') include \'dog.php\';
elseif ($pet === \'cat\') include \'cat.php\';
else die(\'Unknown pet\');

class Pet {
  public function __call($name, array $arguments)
  {
    array_unshift($arguments, $this);
    return call_user_func_array(\"TraitFunc_$name\", $arguments);
  }
}

$myPet = new Pet();
$myPet->speak();

File cat.php

function TraitFunc_speak(Pet $that) { echo \'meow\'; }

File dog.php

function TraitFunc_speak(Pet $that) { echo \'woof\'; }

You are limited however in that your functions can not access private and protected class properties and methods and you can not use this method to provide magic methods such as __get(). Traits will solve both of those limitations.

回答4:

What about using traits for this? Would that be an acceptable option? This is something I am currently experimenting with and it seems to work quite while.

A simplified version of what I am doing is basically like this. I have an application with shared core files and multiple projects. Within those projects i have modules. I want to have functions that are available for the entire project on a core level but only for that specific project.

My project controller

if(is_file(PROJECT_PATH.\'/project_extensions.trait.php\')){
  // additional functions for this specific project
  require_once(PROJECT_PATH.\'/project_extensions.trait.php\');
}else{
  // no additional functions
  trait Extensions{};
}


Class Project{
  USE Extensions;

  // default functions shared between all projects
  function shared_stuff(){

  }
}

Extensions file

trait Extensions{
  // project-specific extensions
  function this_project_only(){
    echo \'Project Only\';
  }
}

Module file in the project

class MyModule extends Modules{ // modules extends projects in a different class not relevant here

  function do_something(){
    echo $this->project_only();
  }
}

回答5:

Since PHP5.4 release you can create dynamic objects like this: https://github.com/ptrofimov/jslikeobject

But this is scarcely the best practice.

回答6:

Reviving an old question but this is a fairly simple solution. Do you need the common function calls to be exclusive to your class? If not, simply include your common function file(s) within the same scope as your class. You will need to create methods in your class but they will only need to call the common function. Here\'s a simple SOAP server example:

<?php

include \'post_function.php\';

$server = new SoapServer( null, array(\'uri\' => \"http://localhost/\") );
$server->setClass(  \'postsoapclass\' );
$server->handle();


class postsoapclass
{
    public function animalNoise( $animal )
    {
        return get_animal_noise($animal);
    }
}

?>

post_function.php

<?php

function get_animal_noise($animal)
{
    if(strtolower(trim($animal)) == \'pig\')
    {
        return \'Oink\';
    }
    else 
    {
        return \'This animal is mute\';
    }
}

?>

回答7:

I have had to do what you are describing in cases where I maintain a free version and a premium version of the same software. Because, as @Gordon noted, you cannot do exactly this:

class SomeClass {  

  premium_file = \"premium.php\";
  if (file_exists($premium_file)) {
    require($premium_file);
  }

Instead I do this:

  premium_file = \"premium.php\";
  if (file_exists($premium_file)) {
    require($premium_file);
  }

  class SomeClass {
    ...

For functions you want to reference, create class methods in the main class, and call the included file\'s method, passing the $this pointer as a parameter. So that I can tell at a glance where functions are, I will prefix the name of the included functions as shown below:

  class SomeClass {
    ... 
    // Premium functions
    public function showlist() {
      premium_showlist($this);
    }