Namespace

Você mesmo pode responder à essa pergunta. Imagina:

library.php

<?php

namespace Foo {

class Foo1 {}

class Foo2 {}
}

namespace Foo\Bar {

class FooBar1 {}

class FooBar2 {}
}

namespace Bar {

class Bar1 {}

class Bar2 {}
}

Como que você usaria? Assim (isso nem funcionar, funciona :P ):

<?php

require Foo;

$foo = new Foo2;

Ou assim:

<?php

require 'library.php';

$foo = new Foo2;

Resultado: o arquivo inteiro está sendo incluído.

Vamos verificar?

require 'library.php';

$namespaces = array();

// Listando todas as classes disponíveis

foreach( get_declared_classes() as $name ) {

/**
* Pegando apenas aquelas que estão dentro de um namespace
* caracterizado pela presença de uma barra invertida
*/
if( strpos( $name, '\\' ) !== FALSE ) {

// Separando...

 $temp = explode( '\\', $name );

 // Pegando o nome da classe (último elemento)

 $class = array_pop( $temp );

 // E registrando

 $namespaces[ implode( '\\', $temp ) ][] = $class;
 }
}

print '<pre>'; print_r( $namespaces );

Saída:

Array
(

 [Foo] => Array
 (
 [0] => Foo1
 [1] => Foo2
 )

 [Foo\Bar] => Array
 (
 [0] => FooBar1
 [1] => FooBar2
 )

 [bar] => Array
 (
 [0] => Bar1
 [1] => Bar2
 )

)

:grin:

Hum... Mas eu lembro que em C++, salvo engano, quando incluímos um arquivo de biblioteca e usamos UM namespace (

using namespace XXXX

), o compilador separa apenas o namespace usado na quando vai traduzir para linguagem de máquina. Não é?

Então, eu quero reunir classes, para nao ter q ficar incluindo um monte de arquivos e nem usar autoload, mas eu só quero que seja carregado o namespace que eu irei usar de fato. Tem como? Porque do contrário, o usuário vai esperar um tempão até que o arquivo que contém o conjunto de namespaces seja carregado. Ah, obrigado pela ajuda Bruno!

Bom, não posso te ajudar nisso porque não sei bulhufas de C++ :cry:

Mas quando você importa uma classe, que pertence à um namespace, através da keyword use, pressupõe-se que você vá usar aquela classe em algum momento da classe em que a importou.

Concorda?

Quanto a não ter que incluir vários arquivos, nesse tópico teve uma discussão acalorada nesse sentido onde foi apresentado com um pouquinho mais de detalhes (acredite, isso tudo é pouco) os Arquivos PHAR que permitem combinar múltiplos arquivos num só.

Assim, a exemplo de um Framework modular, como o Zend Framework, poderia ser ter vários arquivos PHAR, um para Controller, outro para DB e etc. e dentro de cada um, todas classes e interfaces necessárias.

O tópico morreu e dúvidas sucitadas, foram varridas para baixo do tapete infelizmente e desde então, acredito que ninguém tenha tocado mais no assunto.

A idéia parece boa mas não me convenceu por completo pois ao passo que um único arquivo contendo TODO o código produziria um arquivo imenso que seria carregado sempre por cada visitante do site, desperdiçando performance, para códigos simples é extremamente viável, sendo até 3 vezes mais rápido do que qualquer técnica de autoload.

Mas infelizmente o PHP tem um bug, reportado por mim mesmo que dificultaria essa "compilação" de várias classes num só arquivo, problema esse que não ocorrer com o PHAR.

Hum... Obrigado! Tem como fazer uns testes para saber qual o total de Bytes que o servidor está interpretando? Porque assim, saberíamos o quanto do arquivo com várias classes ele estaria interpretando, e o quanto ele estaria descartando.

Eu desconheço e posso estar redondamente enganado quanto à sugerir o uso de memory_get_peak_usage(), que retorna o pico de memória de forma mais acurada que memory_get_usage(), que retorna a mesma informação até o momento em que ela (a função) é invocada.

Se alguém souber de formas melhores, seria um assunto bem interessante, apesar de alguns considerarem perda de tempo esse tipo de estudo.

Roda o script em linha de comando e observe quanto de recurso vai sendo alocado a cada novo include... sei lá, concordo com a parte que diz "perda de tempo". Rs

nao acho perda de tempo, isso é um estudo de engenharia de software, para quem quer ultrapassar o limite das linhas de comando, esse é um assunto interessante de se estudar...

Taí parte para sua resposta...

Código utilizado nos testes:

<?php
include('conteúdo conforme especificado');

$i=0;

 print $i++;
 sleep(30);
}
?>

Resultados:

Sem include;

php.exe 11.180 K

Include da classe do PHPMailer (class.phpmailer.php);

php.exe 11.748 K

Include de um arquivo de 64MB, apenas com comentários;

php.exe 11.376 K

Include de um arquivo de 7.5MB, com uma classe inútil, sem instâncias do objeto;

php.exe 101.244 K

Include de um arquivo de 7.5MB, com uma classe inútil, com 1 instância do objeto;

php.exe 101.244 K

Include de um arquivo de 7.5MB, com uma classe inútil, com 4 instâncias do objeto;

php.exe 101.252 K

Esse K seria de KBytes mas de quê? Memória ou processamento?

E, curiosidade,como que você conseguiu criar 64 MB só com comentários :o

>
Esse K seria de KBytes mas de quê? Memória ou processamento?

E, curiosidade,como que você conseguiu criar 64 MB só com comentários :o

Sim. O K é de KB, uso de memória. O processamento foi sempre pequeno, até pq o script exige pouco mesmo.

Vale salientar que 100.000KB ≅ 100MB.

64MB num arquivo de comentários, peguei parte de um código fonte qualquer e criei um bloco de comentário em todo arquivo, daí foi só copia e cola várias vezes. Usando Notepad++ mesmo, nada sofisticado. rs

Ah, malandro. Me enganou direitinho.

Achei que você um arquivo criado manualmente com vááááários comentários.