Vous appelez une fonction dans une méthode de classe?

J'ai essayé de comprendre comment procéder, mais je ne sais pas trop comment.

Voici un exemple de ce que j'essaye de faire:

class test {
     public newTest(){
          function bigTest(){
               //Big Test Here
          }
          function smallTest(){
               //Small Test Here
          }
     }
     public scoreTest(){
          //Scoring code here;
     }
}

Voici la partie avec laquelle j'ai des problèmes, comment appeler bigTest ()?

Essaye celui-là:

class test {
     public function newTest(){
          $this->bigTest();
          $this->smallTest();
     }

     private function bigTest(){
          //Big Test Here
     }

     private function smallTest(){
          //Small Test Here
     }

     public function scoreTest(){
          //Scoring code here;
     }
}

$testObject = new test();

$testObject->newTest();

$testObject->scoreTest();

L'exemple que vous avez fourni n'est pas valide en PHP et présente quelques problèmes:

public scoreTest() {
    ...
}

n'est pas une déclaration de fonction correcte - vous devez déclarer des fonctions avec le mot-clé 'function'.

La syntaxe devrait plutôt être:

public function scoreTest() {
    ...
}

Deuxièmement, encapsuler les fonctions bigTest () et smallTest () dans public function () {} ne les rend pas privées - vous devez utiliser le mot clé private sur les deux individuellement:

class test () {
    public function newTest(){
        $this->bigTest();
        $this->smallTest();
    }

    private function bigTest(){
        //Big Test Here
    }

    private function smallTest(){
           //Small Test Here
    }

    public function scoreTest(){
      //Scoring code here;
    }
}

De plus, il est conventionnel de mettre en majuscule les noms de classe dans les déclarations de classe («Test»).

J'espère que cela pourra aider.

class test {
    public newTest(){
        $this->bigTest();
        $this->smallTest();
    }

    private  function bigTest(){
        //Big Test Here
    }

    private function smallTest(){
       //Small Test Here
    }

    public scoreTest(){
      //Scoring code here;
    }
 }

Je pense que vous cherchez quelque chose comme celui-ci.

class test {

    private $str = NULL;

    public function newTest(){

        $this->str .= 'function "newTest" called, ';
        return $this;
    }
    public function bigTest(){

        return $this->str . ' function "bigTest" called,';
    }
    public function smallTest(){

        return $this->str . ' function "smallTest" called,';
    }
    public function scoreTest(){

        return $this->str . ' function "scoreTest" called,';
    }
}

$test = new test;

echo $test->newTest()->bigTest();

Vous devez appeler newTestpour rendre les fonctions déclarées à l'intérieur de cette méthode «visibles» (voir Fonctions dans les fonctions ). Mais ce ne sont alors que des fonctions normales et aucune méthode.

Pour avoir une "fonction dans une fonction", si je comprends ce que vous demandez, vous avez besoin de PHP 5.3, où vous pouvez profiter de la nouvelle fonctionnalité de fermeture.

Vous pourriez donc avoir:

public function newTest() {
   $bigTest = function() {
        //Big Test Here
   }
}

Pour appeler n'importe quelle méthode d'un objet instancié à partir d'une classe (avec l'instruction new), vous devez "pointer" vers elle. De l'extérieur, vous utilisez simplement la ressource créée par la nouvelle instruction. A l'intérieur de tout objet PHP créé par new, enregistre la même ressource dans la variable $ this. Donc, dans une classe, vous DEVEZ pointer vers la méthode par $ this. Dans votre classe, pour appeler smallTestdepuis l'intérieur de la classe, vous devez indiquer à PHP lequel de tous les objets créés par la nouvelle instruction que vous souhaitez exécuter, écrivez simplement:

$this->smallTest();

Exemple 1

class TestClass{
public function __call($name,$arg){
call_user_func($name,$arg);
}
}
class test {
     public function newTest(){

          function bigTest(){
               echo 'Big Test Here';
          }
          function smallTest(){
               echo 'Small Test Here';
          }

$obj=new TestClass;

return $obj;
     }

}
$rentry=new test;
$rentry->newTest()->bigTest();

exemple2

class test {
     public function newTest($method_name){

          function bigTest(){
               echo 'Big Test Here';
          }
          function smallTest(){
               echo 'Small Test Here';
          }

      if(function_exists( $method_name)){    
call_user_func($method_name);
      }
      else{
          echo 'method not exists';
      }
     }

}
$obj=new test;
$obj->newTest('bigTest')

Vous pouvez également utiliser self::CONSTau lieu de $this->CONSTsi vous souhaitez appeler une variable statique ou une fonction de la classe actuelle.

  class sampleClass
    { 
        public function f1()
        {
           return "f1 run";
        }

        public function f2()
        {
           echo ("f2 run" );
           $result =  $this->f1();
           echo ($result);
        }   

    f2();  

    }

production :

course f2 course f1