class CarrinhoDeCompras {
  const SESSION_KEY = 'com.firma.ecommerce.carrinho';
  static function getFromSession() {
    if(isset($_SESSION[self::SESSION_KEY]))
      return $_SESSION[self::SESSION_KEY];
    return $_SESSION[self::SESSION_KEY] = new CarrinhoDeCompras();
  }
  ... // restante do código do carrinho
}

Este código encapsula dentro da classe CarrinhoDeCompras a obtenção de um objeto da sessão, com uma chave fixa chamada SESSION_KEY, declarada com a palavra-chave const. A variável self poderia ser substituída pelo próprio nome da classe, mas seu uso deixa o código mais independente, facilitando possíveis refactorings (e.g., renomeação da classe).

O acesso ao método estático do exemplo é feito através do operador ::, como a seguir:

$cestaDoUsuario = CarrinhoDeCompras::getFromSession();

Post atualizado em 5/4/2009, depois do comentário do Diego Sampaio (obrigado! ;).

https://usuario:senha@www.exemplo.com

Porém, há algumas bibliotecas (como a libcurl) que não aceitam receber usuário e senha pelo endereço. É preciso separá-los.

Seguem duas funções que fazem essa separação, retornando os trechos distintos da URL, são elas:

• extrair_User_Pass que retorna “usuario:senha”
• extrair_URL que retorna “https://www.exemplo.com”

function extrair_User_Pass($URL)
{
    // Inverte a string, pega tudo entre o primeiro
    // '@' e as '//' e joga no Array "$arr1"
    preg_match("'@.*\b//'",strrev($URL),$arr1);

    // Converte a String em "$arr1[0]" em um array,
    // inverte sua ordem e armazena em "$arr1"
    $arr1 = array_reverse(str_split($arr1[0]));

    // Retira o '@' e as '//'
    array_shift($arr1);
    array_shift($arr1);
    array_pop($arr1);

    return implode($arr1);
}

function extrair_URL($URL)
{
    return preg_replace("/".extrair_User_Pass($URL)."@/","",$URL);
}

O PHP tem uma função mágica chamada __call(). Se sua classe declarar um método com este nome, ele será invocado sempre que for feita uma chamada a um método não existente naquela classe.

Esta invocação receberá como parâmetro o nome do método chamado e os argumentos. É um mecanismo tradicional e simples, mas muito poderoso. Já existia no Smalltalk, através da mensagem doesNotUnderstand, que tinha exatamente a mesma semântica.

As aplicações são diversas: interceptação de chamadas, proxying, dynamic dispatching etc. Estas brincadeiras divertidas são muito úteis para a construção de bibliotecas e frameworks dinâmicos, por exemplo, para web ou mapeamento objeto-relacional.

Um exemplo para ilustrar:

class ClasseComTodosOsMetodosDoMundo
{
    public function __call($m, $a)
    {
        echo "Método invocado: $m\n";
    }
}

$o = new ClasseComTodosOsMetodosDoMundo();
$o->umMetodoQualquer();
$o->umMetodoAssimAssado();

Que vai ter a saída:

Método invocado: umMetodoQualquer
Método invocado: umMetodoAssimAssado

Algumas práticas podem melhorar a legibilidade de um código, e uma delas é o uso de interfaces fluentes ou encadeamento de objetos.

Normalmente, a maioria dos métodos setter de um objeto apresentam retorno do tipo void. Mas, em um objeto com interface fluente, os setters irão retornar um objeto, de modo que se possa encadeá-lo.

Vale lembrar que esta prática é apenas suportada no PHP 5, visto que o PHP 4 não suporta referência direta aos objetos retornados por métodos.

Vejamos o exemplo:

class A {

      private $_n = '';

      public function setA($n)
      {
            $this->_n = $n;
            return $this;
      }

      public function reverse()
      {
            $this->_n = strrev($this->_n);
            return $this;
      }

      public function getA()
      {
            return  $this->_n;
      }
}

$a = new A();

print $a->setA("codare")->reverse()->getA();

# Retorna: eradoc

?>

E lembre-se: interfaces fluentes requerem situações fluentes!

Quando programamos aplicações orientadas a objetos um dos aspectos importantes a se observar é a responsabilidade e a orientação à assunto. Isto quer dizer que cada classe deve ser responsável por um determinado assunto e ser responsável por ele, ou seja, protejer os aspectos internos de implementação.

Dessa forma, facilmente criamos aplicações com dezenas de classes, uma vez que cada classe irá cuidar de um aspecto bem específico. Teremos classes para botões, janelas, conexões com o banco de dados, etc.

Nestes casos, é comum encontrar no início de um arquivo, vários “include_once”, responsáveis por carregar as inúmeras classes necessárias no script, como:

<?php
include_once 'classes/Botao.class.php';
include_once 'classes/Cliente.class.php';
include_once 'classes/Fornecedor.class.php';

// ... código ...

?>

Em muitos casos, corremos inclusive o erro de esquecer um include, tantas são as classes utilizadas pelo nosso sistema. Para facilitar o carregamento das classes, o PHP5 introduz o método __autoload().

O método __autoload() é executado automaticamente na primeira vez que uma classe é instanciada. Nele podemos escrever algumas tarefas automáticas como o próprio carregamento da classe em memória.

<?php
function __autoload($classe)
{
   include_once "classes/{$classe}.class.php";
}

// ... código ...

new Cliente;

new Fornecedor;

?>

Desta forma, sempre que uma classe for instanciada pela primeira vez, o método __autoload é executado e a classe correspondente é carregada.

Um dos comandos mais utilizados nos nossos programas sem dúvida é o IF. Quando utilizamos o IF para tarefas simples como realizar um teste condicional para posterior atribuição de variáveis, podemos utilizar uma sintaxe simplificada.

A seguir, veja um exemplo onde atribuímos a variável $texto dependendo do conteúdo da variável $idade.

<?php
$idade =16;

if ($idade > 18)
{
   $texto = "maior idade";
}
else
{
   $texto = "menor idade";
}

echo $texto;
?>

O PHP nos oferece uma sintaxe onde podemos realizar uma atribuição condicional de variáveis, onde o IF acima pode ser substituído pela seguinte forma:

<?php
$idade =16;
$texto = $idade > 18 ? "maior idade" : "menor idade";
echo $texto;
?>

Um dos tipos de dados com mais recursos na linguagem PHP é sem dúvida as strings. A linguagem PHP possui inúmeras funções para manipulação de strings e uma das mais utilizadas é o substr.

O substr é responsável por retornar um pedaço da string. Para isto ele se utiliza de três parâmetros: a própria string, o índice inicial e a quantidade de caracteres a ser retornada.

Acontece que podemos utilizar também um índice negativo, desta forma o PHP analisa a string contando N caracteres a partir do final, e não a partir do início. Veja a seguir alguns exemplos:

<?php
$texto = "eu não sou besta pra tirar onda de herói";

echo substr($texto, 0, 16);  // eu não sou besta
echo "<br>\\n";
echo substr($texto, 11);     // besta pra tirar onda de herói
echo "<br>\\n";
echo substr($texto, 11, 9);  // besta pra
echo "<br>\\n";
echo substr($texto, -5);     // herói
echo "<br>\\n";
?>

Também podemos utilizar a substr() em combinação com a strpos(). A strpos detecta a posição que uma string ocorre dentro de uma expressão.

No exemplo seguinte, detectamos onde ocorre a palavra “http://” para retornar somente o domínio presente no texto:

<?php
$texto = "retornarei somente o domínio de http://www.pablo.blog.br";
$posicao = strpos($texto, 'http://');
echo substr($texto, $posicao+11); // pablo.blog.br
echo "\\n<br>";
?>

De todos os tipos de dados presentes nas linguagens de programação, arrays e strings certamente estão entre os mais utilizados. E em PHP isto não é diferente. Muitas vezes temos a necessidade de conversão de uma estrutura para outra. Aqui vamos ver como fazer a conversão de arrays para strings e vice-versa.

Primeiramente, temos uma string contendo uma lista de nomes separados por vírgula e iremos convertê-la em um array. Para tal, utilizamos a função explode especificando o caractere separador.

<?php
$string = "joão, maria, josé, pedro";
$array  = explode(',', $string);
print_r($array);
?>

Agora iremos fazer o contrário, ou seja, converter um array para uma string. Para tal, iremos utilizar a função implode(), passando o caractere que desejamos utilizar para separar os dados na string.

<?php
$array[] = "www.adianti.com.br";
$array[] = "www.pablo.blog.br";
$array[] = "www.php-gtk.com.br";

print_r(implode(':', $array))
?>

No PHP existem diversas formas de se descobrir informações a respeito de uma classe. Por exemplo, para saber quais os métodos oferecidos por uma classe, a função get_class_methods() é utilizada:

<?php
class Pessoa
{
    private $codigo;
    private $name;
    function __construct($codigo)
    {
        $this->codigo = $codigo;
    }

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

print_r(get_class_methods('Pessoa'));
?>

O PHP5 implementa uma API chamada Reflection. A Reflection API permite fazermos reflexão de objetos, ou seja, investigar sobre seus atributos, métodos e descobrir sua interface. A seguir, temos o mesmo código rescrito utilizando essa API:

<?php
class Pessoa
{
    private $codigo;
    private $name;
    function __construct($codigo)
    {
        $this->codigo = $codigo;
    }

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

$api = new ReflectionClass('Pessoa');
foreach($api->getMethods() as $method)
{
    echo $method->getName() . "<br>\\n";
}
?>

Você sabia que o PHP aceita a chamada de funções com argumentos variados?

Normalmente definimos os parâmetros a serem recebidos na assinatura da função (declaração). Mas quando não sabemos a quantidade exata de métodos a serem recebidos, podemos utilizar a função func_get_args(), que irá retornar um array contendo os parâmetros passados na chamada da função.

Como exemplo veja a função soma(), que pode receber uma quantidade variada de argumentos, retornando seu somatório.

<?php
function soma()
{
    $parametros = func_get_args();
    foreach ($parametros as $parametro)
    {
        $soma += $parametro;
    }
    return $soma;
}

echo soma(1,2) . "<br>\\n";
echo soma(1,2,3) . "<br>\\n";
echo soma(1,2,3,4,5,6) . "<br>\\n";
?>