Chamando uma função dentro de um método de classe?

Tenho tentado descobrir como fazer isso, mas não tenho certeza de como.

Aqui está um exemplo do que estou tentando fazer:

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

Aqui está a parte com a qual estou tendo problemas. Como chamo bigTest ()?

Tente este:

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();

O exemplo que você forneceu não é um PHP válido e tem alguns problemas:

public scoreTest() {
    ...
}

não é uma declaração de função apropriada - você precisa declarar funções com a palavra-chave 'function'.

A sintaxe deve ser:

public function scoreTest() {
    ...
}

Em segundo lugar, envolver as funções bigTest () e smallTest () em função pública () {} não as torna privadas - você deve usar a palavra-chave privada em ambas individualmente:

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;
    }
}

Além disso, é convenção colocar nomes de classe em letras maiúsculas em declarações de classe ('Teste').

Espero que ajude.

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;
    }
 }

Acho que você está procurando por algo parecido com este.

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();

Você precisa chamar newTestpara tornar as funções declaradas dentro desse método “visíveis” (consulte Funções dentro das funções ). Mas isso são apenas funções normais e nenhum método.

Para ter uma "função dentro de uma função", se entendi o que você está perguntando, você precisa do PHP 5.3, onde pode aproveitar o novo recurso Closure.

Então você poderia ter:

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

Para chamar qualquer método de um objeto instanciado de uma classe (com a instrução new), você precisa "apontar" para ele. Do lado de fora, basta usar o recurso criado pela nova instrução. Dentro de qualquer objeto PHP criado por new, salva o mesmo recurso na variável $ this. Portanto, dentro de uma classe, você DEVE apontar para o método por $ this. Em sua classe, para chamar smallTestde dentro da classe, você deve dizer ao PHP qual de todos os objetos criados pela nova instrução você deseja executar, basta escrever:

$this->smallTest();

Exemplo 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();

exemplo 2

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')

Você também pode usar em self::CONSTvez de $this->CONSTse quiser chamar uma variável estática ou função da classe atual.

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

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

    f2();  

    }

resultado :

f2 run f1 run