Quem é o mais otimizado, construtor ou manual?

[Micilini Roll 49]

Galera gostaria de saber em orientação a objetos qual das duas opções abaixo é mais otimizada e executa mais rapido pelo compilador (qual a melhor opção?)

 

Atraves de um metodo contrutor:

$class = new Classe("Nome","Idade","Rua","sexo");

Ou manualmente:

$class = new Classe;

$class->setNome("Nome");
$class->setIdade("Idade");
$class->setRua("Rua");
$class->setSexo("Sexo");

Minha Resposta: Na minha opnião, acredito que a primeira opção é a mais otimizada pelo compilador, e provavelmente é executada mais rapidamente (talvez questões de milisegundos comparada a segunda opção), mas porque? Ao meu ver:

 

• O primeiro economiza algumas linhas de codigos, e a fadiga de setar muitos dados (Escrevendo setNome, setIdade ....)
• Quando setamos via construtor os dados são enviados para o metodo construtor existente na outra classe e esses dados já sao atribuidos dentro de suas variaveis dentro de um mesmo metodo

 

Acredito que a segunda opção seja menos otimizada pois:

 

• Primeiro instanciamos a classe, depois nos pegamos a instancia dessa classe e executamos os seus metodos um de cada vez, nesse caso estamos chamando 4 metodos separadamente.
• Quando chamamos via manual, os dados são enviados para metodos diferentes seta-los separadamente o que acredito que puxe mais recursos.

 

Construtor -> Instancia (Ja com os dados) -> dados recebidos pela classe -> Dados setados pela classe -> Sucesso

 

Manual -> Instancia -> Pega a instancia acessa o metodo e envia o parametro -> Metodo pega o parametro e coloca dentro da variavel -> -> Pega a instancia acessa o metodo e envia o parametro -> Metodo pega o parametro e coloca dentro da variavel -> ........ -> Sucesso

 

Possa ser que eu esteja errado, mas isso me gerou essa duvida, alguem pode dar uma clareada?

[Beraldo 864]

Meu palpite é o mesmo que o seu
E por um motivo bem mais simples: quando o código é compilado para assembly (ou uma linguagem de máquina semelhante), toda chamada de função gera um jump (goto). E isso consome clock da CPU. Então, 3 chamadas de métodos devem demorar mais que um construtor

Aí fui fazer um teste simples

<?php

class Person {
    private $name;
    private $age;
    private $gender;

    public function __construct($name, $age, $gender) {
        $this->name = $name;
        $this->age = $age;
        $this->gender = $gender;
    }
}


$start = microtime(true);
$Person1 = new Person('Beraldo', 27, 'm');
$end = microtime(true);

$diff = number_format($end - $start, 20, ',', '.');

printf("Com Construtor: %s%s", $diff, PHP_EOL);



class Person_NoConstruct {
    private $name;
    private $age;
    private $gender;

    public function setName($name) {
        $this->name = $name;
    }

    public function setAge($age) {
        $this->age = $age;
    }

    public function setGender($gender) {
        $this->gender = $gender;
    }
}

$start = microtime(true);
$Person2 = new Person_NoConstruct();
$Person2->setName('Beraldo');
$Person2->setAge(27);
$Person2->setGender('m');
$end = microtime(true);

$diff = number_format($end - $start, 20, ',', '.');

printf("Sem Construtor: %s%s", $diff, PHP_EOL);

Fiz um loop pra rodar isso 10 vezes no terminal. E o resultado me surpreendeu:

$ for ((i = 0; i < 10; i++ )) ; do php test.php; echo ""; done
Com Construtor: 0,00003194808959960938
Sem Construtor: 0,00002098083496093750

Com Construtor: 0,00002789497375488281
Sem Construtor: 0,00002098083496093750

Com Construtor: 0,00002694129943847656
Sem Construtor: 0,00001502037048339844

Com Construtor: 0,00002884864807128906
Sem Construtor: 0,00001192092895507812

Com Construtor: 0,00003004074096679688
Sem Construtor: 0,00001096725463867188

Com Construtor: 0,00003004074096679688
Sem Construtor: 0,00001192092895507812

Com Construtor: 0,00002813339233398438
Sem Construtor: 0,00001192092895507812

Com Construtor: 0,00003099441528320312
Sem Construtor: 0,00001311302185058594

Com Construtor: 0,00003004074096679688
Sem Construtor: 0,00001215934753417969

Com Construtor: 0,00002789497375488281
Sem Construtor: 0,00001311302185058594

Nas 10 vezes, a versão sem construtor foi mais rápida.

A diferença é insignificante, pensando em tempo para humano. Mas achei bem curioso a versão sem construtor ser mais rápida.

Dei uma pesquisada rápida no Google e não encontrei explicações sobre isso, infelizmente

Provavelmente uma classe com construtor exige mais trabalho da CPU na hora de instanciá-la.

[Gabriel Heming 766]

Quando estudei Orientações à objetos em java, por possuir um melhor suporte a overload, é indicado se use as duas formas.

 

Hoje em dia, com a grande força de processamente, eu vejo essa discussão relativamente desnecessária.

 

Mas não me compreenda errado, é importante saber o que é mais rápido ou menos custoso. Mas na orientação à objetos, é ainda mais importante a clareza da impementação.

 

Ao meu ver, a leitura do segundo código é mais claro por se referir a uma entidade.