Publicado em 19 de set.

Quem é o mais otimizado, construtor ou manual?

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?

Discussão (2)

Entre ou cadastre-se para participar da discussão

Entrar Criar conta

Beraldo· 19 de set.

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· 20 de set.

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.