PHP não é uma linguagem que se aprende na faculdade(pelo menos não normalmente). Ao invés disso, você aprende “linguagens mais aceitas no mercado”. Aqui já começa o preconceito, e também é aqui que nos diferenciamos dos outros.

Os caras que aprendem PHP normalmente fazem isso por conta própria, e isso faz toda a diferença!
Isso mostra o perfil do profissional de PHP, que já tem desde o início que procurar tudo, e se virar por conta própria.

Por não termos “professores” para tirar nossas dúvidas, nós mesmos procuramos a solução, o que nos leva à… COMUNIDADE!
A comunidade do PHP fala por sí mesma. É extremamente forte, e você NUNCA ficará sem ajuda. NUNCA!
O manual do PHP é de longe a melhor documentação de todas as linguagens.
E por ter que procurar a solução, nós (programadores PHP) acabamos por aprender muito mais.
Não digo só em conhecimento referente ao PHP, mas sim, relacionado a tecnologia. Aprendemos a lidar com sistemas
baseados em UNIX, conhecer os protocolos de forma mais específica, conhecer como as coisas funcionam debaixo dos panos, etc…

Aí você pode falar: “Porque a sua linguagem não implementa coisas para facilitar a sua vida”
Engano seu! PHP facilita sim a nossa vida, coisas que eu faço em uma linha com PHP, requerem implementações bem maiores em outras linguagens!
E vou mais além, se você quer ou precisa escovar bits com PHP, é muito simples também. E isso nos dá uma
flexibilidade enorme.

Isso sim, faz um profissional diferenciado. Já ouvi histórias de pessoas que apenas sabiam rodar o software em que estavam trabalhando na sua
própria máquina. Colocar em produção?!?! Que isso, só sei rodar na minha máquina…

Ou até mesmo programadores que não vivem sem IDE e Debugger, esse caras existem para nos ajudar, não devemos ser dependentes deles.

Cheguei ao limite de ver programador de uma linguagem X, que pediu para implementarem um wrapper para a API do Google+.
Pera aí, como assim?!?!?! Você realmente NÃO é um programador!
A porra da API é RESTFul, qual a dificuldade de usa-lá?!?! Isso é porque o cara só sabe juntar código, e se a linguagem dele
não oferece “Google+ API Wrapper” ele não tem como usar…

Isso acontece por causa de linguagens que dão tudo de mão beijada para os seus
ditos programadores. Estamos chegando numa época que programadores de verdade estão em falta. Eu não quero viver para ver quando chegar essa
época, o que não esta muito longe. Os “programadores” de hoje, simplesmente juntam código, e quando eles tem que fazer algo complexo que a sua
maravilhosa linguagem não oferece, eles NÃO fazem. Estamos no ponto de programadores não saberem que existe Ruby sem Rails, PHP sem WordPress!!!

Ah claro, temos também o caso dos programadores de framework e no caso do PHP, também temos os programadores de WordPress.
Porra, me ajudem! O background da grande maioria dos programadores PHP é sim, WebDesign. Porém essas caras que se dizem programadores PHP
mas não sabem programar fora de framework ou de CMS, NÃO SÃO PROGRAMADORES! Esses caras são “juntadores de código pronto”.

Se você não esta nem aí para os recursos novos que saem a cada versão do PHP, não vai a eventos de PHP, não contribui ou não
desenvolve nenhum projeto opensource, você não ama PHP.
Você simplesmente trabalha com ele porque é simples, e dá dinheiro.
Então por favor, não se apresente como programador PHP.

Escutem bem, não estou falando mal de programador PHP que começou com WebDesigner ou trabalha com framework X. Eu tambem comecei assim.
Mas caras, todos temos que evoluir, e continuar desenvolvendo somente dentro de uma “caixa” não é evolução.
Deixar para conhecer um recurso quando ele já estiver sendo usado globalmente é evolução reativa, nós não queremos isso.
Temos que começar a estudar algo quando ele ainda é um feto!
Isso ao meu ver, sempre diferenciou os programadores de PHP dos outros.

Não é porque sua linguagem abstrai uma conexão, que você não precisa conhecer oque é feito debaixo dos panos,
e se você falou que não precisa conhecer. Você é um preguiçoso. Conhecer oque a linguagem faz para que certas mágicas aconteçam,
vai fazer com que seu código seja muito melhor.

Sempre que algum recurso legal aparecia em linguagem X ou Y, ou até mesmo uma nova forma de desenvolvimento estava sendo estudada ou lançada.
O pessoal de PHP já estava criando implementações para isso ou aquilo. Enquanto o pessoal das outras linguagens estavam esperando que a implementação fosse feita e eles pudessem apenas usar. Parem com isso! Todos temos que ser pró-ativos, e pesquisar coisas novas. Não fique
acomodado, não tenha medo de errar, vá em frente, e tente tudo de novo que você aprende a cada dia.

Começar um projeto novo sem ter nada de novidade para você fazer, não vai te ajudar em nada.
Você apenas estará na sua zona de conforto, e não estará prendendo nada. Comece um projeto novo,
com uma metodologia nova, uma nova arquitetura, um novo framework, qualquer coisa. Isso sim vai te ajudar!

Então que fique bem claro.
Não existem linguagens melhores ou piores, e sim cada uma se propõe a fazer algo diferente da outra.
E não venha falar mal da minha linguagem, porque não é bem assim.

Primeiro: Carambaaaaa, faz um tempão hein

Hoje vou falar sobre aplicações REST em php, e como criar a sua RESTful app!

Bom, vamos lá.

Oque é REST???

É um estilo de arquitetura para desenvolver aplicações web.

Como?

A idéia é simples, utilizar o protocolo HTTP que já temos e conhecemos, para desenvolver aplicações que possam ser “lidas” tanto por pessoas quanto por computadores.

Ok, vamos começar a falar sobre webservices então.

REST diz que uma página não é um recurso, e sim a representação de um recurso.
Ou seja, uma página web não é um recurso, e sim a representação de um, no formato HTML.

http://meusite.com/produtos/111

O protocolo HTTP, já possui todos os recursos que precisamos, então não precisamos fazer algo assim:

http://meusite.com/produtos/11/edit <- Isso não é legal 

Para mostrar que queremos alterar algo.

As URLs, devem ser hierárquicas! Ou seja, /edit é filho de produto? Eu acho que não.
Mas uma lista de fotos é!

http://meusite.com/produtos/11/fotos

Lindo, não?

Mas como eu faço para mostrar que quero alterar um produto então?
HTTP possui vários métodos, e REST diz que as ações são implícitas por esses métodos, e não passando a ação na URL.

GET
POST
PUT
DELETE

Esses são os métodos HTTP usados para construir apps RESTful.

GET http//meusite.com/produtos
Lista os produtos.

POST http//meusite.com/produtos
Adiciona um produto.

GET http//meusite.com/produtos/1
Mostra um produto específico.

PUT http//meusite.com/produtos/1
Altera um produto específico.

DELETE http//meusite.com/produtos/1
Deleta o produto.

Simples, não???

Agora vamos a questão de “representar” esses produtos

Esses produtos podem ser representados como?
HTML, JSON, XML, JPG, ...

E isso não precisa ser passado na URL.

http://meusite.com/produtos.xml <- Você não precisa deixar isso explícito!

O HTTP faz isso por você!

Para isso existe o cabeçalho Accept, com ele você fala “implícitamente” como você quer a representação desse produtos.

Accept    text/html,application/json 

Entenderam???

Vamos colocar a mão na massa então!

Para fazer isso, vou usar um cara bem legal chamado Respect\Rest. Com ele fica muito fácil desenvolver apps RESTful em PHP.
http://github.com/Respect/Rest

$router = new Router();

$router->get('/produtos', function() {
    return 'Listagem de produtos';
});

$router->post('/produtos', function() {
    return 'Criando um produto';
});

$router->get('/produtos/*', function() {
    return 'Mostrando um produto específico';
});

$router->put('/produtos/*', function() {
    return 'Alterando um produto';
});

$router->delete('/produtos/*', function() {
    return 'Apagando um produto';
});

Simples neh?

Agora vamos dizer de que formas esses produtos podem ser representados.

$router = new Router();

$router->get('/produtos', function() {
    return 'Listagem de produtos';
})->accept(
    array(
        'text/html' => function($data) {
            return 'Produto em HTML';
        },
        'application/json' => function($data) {
            return 'Produto em JSON';
        }
    )
);

$router->post('/produtos', function() {
     return 'Criando um produto';
});

$router->get('/produtos/*', function() {
    return 'Mostrando um produto específico';
});

$router->put('/produtos/*', function() {
    return 'Alterando um produto';
});

$router->delete('/produtos/*', function() {
    return 'Apagando um produto';
});

Está pronto! Agora, a lista de produtos pode ser representada em JSON e HTML.

Espero que tenham gostado da simples introdução que fiz!
Bom, vou ficando por aqui mesmo, num próximo post vou mostrar como realmente “desenvolver” uma aplicação completa.

Se voce tambem quer a sua, esse post é pra voce, vou apresentar aqui algumas impressões sobre a prova e algumas dicas.

Bom vamos ao que interessa!

Primeiro de tudo, estude! Isso mesmo, sem estudo será difícil de passar
Mas não precisa ficar desesperado, a prova não é difícil! Se voce estudar e conhecer bem o PHP,
não terá nenhum problema para passar.

A prova possui 10 áreas de conhecimento, são elas:

1. PHP BASICS
2. DATA FORMATS AND TYPES
3. STRINGS
4. ARRAYS
5. INPUT / OUTPUT
6. FUNCTIONS
7. OBJECT-ORIENTED PROGRAMMING
8. DATABASES
9. SECURITY
10. WEB FEATURES

PHP Basics, Strings, Arrays, OO são muito cobrados, por isso conheça muito bem esses tópicos.
Input/Output, Functions, Web Features tambem tem um bom número de questões.
Data Formats and Types, Databases, Security são tratados bem por cima.

Outra coisa, aprenda Hexadecimal, Octal e Binário, eles serão importantes tambêm, nada demais, apenas contas simples.

Não se esqueça de conhecer tambêm um pouco sobre precedência de operadores, os principais “.+-/*”.

Em relação aos novos recursos do 5.3, foram poucas questões 2 de namespace e 2 de Late Static Binding, na minha prova nem caiu Closures.

Na prova também serão testados conceitos que você não encontrará no manual do PHP, coisa que você deve conhecer pela sua experiência e conhecimento sobre Web.

Estudando

Eu recomendo que você compre o livro da php|arch ZEND PHP 5 Certification Study Guide, também leia esse post na devzone, o post é bem completo e você pode pegar varias dicas bacanas.

Outra coisa, quando você comprar o voucher, deve receber um pdf da zend, que é um beta de guia de estudos para a ZCE 5.3.
Ah, é importante lembrar, que não tem mais teste online, pode ser que futuramente tenha, mas até agora não tem.

Bom é basicamente isso, boa sorte!

Bom, o assunto de hoje é a ArrayAccess, que apesar de simples, possibilita que uma classe seja manipulada como um array.

A ArrayAccess, obriga que a classe implemente 4 métodos, são eles:

public boolean offsetExists(mixed $offset)
public mixed offsetGet (mixed $offset)
public void offsetSet(mixed $offset, mixed $value)
public void offsetUnset(mixed $offset)

Através desses métodos, você conseguirá acessar a sua classe como se fosse um array, com algumas restrições é claro

Para demonstrar o uso da ArrayAccess, usarei as mesmas classes usadas do post anteriror, só adicionei a classe CarrinhoCompras onde será posteriormente implementada a ArrayAccess.

class Produto
{
	private $nome;
	private $preco;

	public function __construct($nome, $preco)
	{
		$this->nome = $nome;
		$this->preco = $preco;
	}

	/** GETTERS AND SETTERS **/
}

class Item implements Countable
{
	private $produto;
	private $quantidade;

	public function __construct(Produto $produto, $quantidade)
	{
		$this->produto = $produto;
		$this->quantidade = $quantidade;
	}

	public function count()
	{
		return $this->quantidade;
	}
}

class CarrinhoCompras
{
	private $itens;
	private $data;

	public function __construct($data)
	{
		$this->itens = array();
		$this->data = $data;
	}
}

Nesse exemplo, continuamos com nosso contexto de e-commerce, a classe Item possui um Produto e a quantidade desejada desse produto, e a classe CarrinhoCompras possui todos os Itens que estão sendo vendidos. Bem simples, apenas para demonstração

Agora sim, vamos ao que interessa! O atributo $itens, é um array de Itens, para acessar ele poderíamos criar um método getItens(), ou qualquer outro método que acesse esse atributo, mas aqui vou demonstrar como acessar ele através da ArrayAccess.

A classe CarrinhoCompras deve implementar a interface ArrayAccess, e implementar todos os métodos acima citados, como no exemplo abaixo.

class CarrinhoCompras implements ArrayAccess
{
	private $itens;
	private $data;

	public function __construct($data)
	{
		$this->itens = array();
		$this->data = $data;
	}

	public function offsetSet($offset, $value)
	{
		var_dump(__METHOD__);
        $this->itens[$offset] = $value;
    }

    public function offsetExists($offset)
	{
		var_dump(__METHOD__);
        return isset($this->itens[$offset]);
    }

    public function offsetUnset($offset)
	{
		var_dump(__METHOD__);
        unset($this->itens[$offset]);
    }

    public function offsetGet($offset)
	{
		var_dump(__METHOD__);
        return isset($this->itens[$offset]) ? $this->itens[$offset] : null;
    }
}

No exemplo eu coloquei var_dump(__METHOD__) dentro de cada método para que você possa ver quando cada método é chamado. Agora vamos executar alguns testes para que você possa ver a utilização da ArrayAccess.

$produto = new Produto('Livro PHP', 78.50);
$item = new Item($produto, 5);

$produto1 = new Produto('Livro Java', 88.50);
$item1 = new Item($produto1, 1);

$carrinho = new CarrinhoCompras(new DateTime());
$carrinho[0] = $item;
$carrinho[1] = $item1;

var_dump($carrinho[0]);

Fácil não? Agora a sua classe é acessível como um array! Mas agora vamos as restrições

// Isso não funciona!
// Apesar de a classe ser acessível como um array, ela não é um array...
// Fazendo isso, você terá como resultado um foreach de todos os atributos public
foreach ($carrinho as $c)
var_dump($c);

// Isso também não!
array_push($carrinho, 'teste');

// Isso funciona!
// Mas não como de costume...
// O indice vazio, no caso de um array, teria o mesmo comportamento
// Que array_push(), mas no caso de um objeto
// O indice é covertido para NULL
$carrinho[] = 'teste';

Você pode continuar chamando os métodos normalmente, ou seja.

// Isso funciona!
$carrinho->offsetExists(0);

Abaixo uma breve explicação de cada método.

// Chamado quando usamos isset() ou empty()
public boolean offsetExists(mixed $offset)

// Chamado quando usamos empty()
// NOTA: Só é chamado quando ArrayAccess::offsetExists() retorna true
public mixed offsetGet (mixed $offset)

// Chamado quando usamos $obj['index'] = 'teste'
public void offsetSet(mixed $offset, mixed $value)

// Chamado quando usamos unset()
// NOTA: Fazendo casting para (unset) não chama esse método
public void offsetUnset(mixed $offset)

É isso, espero que tenham gostado!
Não esqueçam de comentar e de ler a documentação, RTFM.

http://br3.php.net/manual/pt_BR/class.arrayaccess.php

Hoje venho falar de um assunto muito interessante, SPL.

Pra quem não conhece, a SPL, é uma biblioteca com diversas classe e interfaces para PHP, que vão desde estruturas de dados, implementações de Design patterns, Iterators, Exceptions e funções diversas.

Nesse post, falarei de uma das interfaces, a Countable que é extremamente simples, porém muito útil!

Antes de ir direto ao assunto, usarei o exemplo abaixo para demonstrar o uso da interface dentro de um contexto de e-commerce.

class Produto
{
    private $nome;
    private $preco;

    public function __construct($nome, $preco)
    {
        $this->nome = $nome;
        $this->preco = $preco;
    }

    /** GETTERS AND SETTERS **/
}

class Item
{
    private $produto;
    private $quantidade;

    public function __construct(Produto $produto, $quantidade)
    {
        $this->produto = $produto;
        $this->quantidade = $quantidade;
    }
}

Nesse exemplo, temos a classe Produto e a classe Item, a Item recebe como parâmetro no
construtor uma instância de Produto e a quantidade desejada desse produto.

Agora se você quer saber a quantidade de produtos que um item possui você pode fazer algo assim?

$produto = new Produto('Livro PHP', 78.50);
$item = new Item($produto, 5);
echo count($item);

Até poderia, mas não seria o resultado esperado. O resultado desse count() seria 1. E agora?

É claro que você poderia criar um método getQuantidade(), ou resolver de alguma outra forma, idéias não faltam

Mas com a SPL você pode sim realizar o código acima e obter o resultado esperado!!!

Vamos lá!

Basta que a classe Item implemente a Countable como no exemplo abaixo.

class Item implements Countable
{
    private $produto;
    private $quantidade;

    public function __construct(Produto $produto, $quantidade)
    {
        $this->produto = $produto;
        $this->quantidade = $quantidade;
    }

    public function count()
    {
        return $this->quantidade;
    }
}

A interface Countable, obriga você implementar um método count(), mas ai você deve estar se perguntando: “Tá mas onde esta a graça nisso?”. Eu respondo, execute novamente o código abaixo.

$produto = new Produto('Livro PHP', 78.50);
$item = new Item($produto, 5);
echo count($item);

Agora sim! O resultado será 5, isso acontece porque sua classe implementou a interface Countable, e agora o PHP sabe que ele pode chamar o método count() da sua classe quando você utilizar a função count() nativa.

É isso, espero que tenham gostado e até a próxima.

http://br3.php.net/manual/pt_BR/countable.count.php

Hoje vou falar sobre CrudIgniter, esse é o primeiro cast de vários que vou fazer, mostrando desde o básico até o avançado de CrudIgniter.

Nesse cast, ensino como gerar a sua aplicação em minutos, e nos próximos irei ensinar a customizar os templates, criar seus próprios templates e até criar as suas próprias funcionalidades.
Espero que gostem e até a próxima!

PS: Assistam em HD porque aí fica muito mais fácil de entender as letras.

CrudIgniter – Basics from Thiago Rigo on Vimeo.

No screencast eu explico oque é, para que serve e como se implementa Singleton em php!

Bom vamos ao screencast. Ah, se vocês gostaram, não entenderam nada ou ficaram com alguma dúvida comentem

Download dos arquivos

Até a próxima!!!

Design Pattern – Singleton from Thiago Rigo on Vimeo.

Não vou entrar em muitos detalhes agora, mas em breve farei screencasts e artigos mostrando como utilizar, adicionar funcionalidades personalizadas, customizar os templates, enfim tudo!

O CrudIgniter está hospedado no Google code, neste link.

É só baixar e aproveitar, no download está toda a documentação também.

Espero que o CrudIgniter ajude muita gente! E que ele possa crescer bastante.

Divulguem!!!

E claro, comentem

Vamos lá!

Primeiro: AJAX significa Asynchronous JavaScript and XML, e consiste na idéia de se comunicar com um servidor web, sem a necessidade de recarregar a página.

Segundo: O objeto XMLHttpRequest é um objeto JavaScript que torna possível essa comunicação assíncrona.

Terceiro: O XMLHttpRequest não suporta o envio de formulário com enctype="multipart/form-data", que são utlizados para envios de arquivo. Isso ocorre porque dessa maneira os caracteres não são codificados, não permitindo assim o seu envio pelo objeto.

Então como faremos ?

Simples!

Iremos simular um upload com AJAX, utilizando um iframe.

Essa técnica é bastante utilizada, e não é complicada de se fazer.

Bom, agora que ja temos uma breve explicação, vamos ao código!

Primeiro o nosso código HTML, com o formulário para upload.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>UPLOAD</title>
<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
</head>
<body>

<h1>Escolha o arquivo</h1>

<div style="display: none;" id="loader_img">
	<img src="img/loader.gif" alt="Carregando..." title="Carregando..." />
</div>
<div style="display: none;" id="upload_msg"></div>
<form action="do_upload.php" id="form_upload" enctype="multipart/form-data" method="post" target="upload_target">
<p>
	<label>Arquivo
		<input type="file" name="arquivo" id="arquivo" />
	</label>
</p>
<p>
	<input type="submit" name="do_action" id="do_action" value="Upload" />
</p>
</form>
<iframe id="upload_target" name="upload_target" src="#"></iframe>

</body>
</html>

Excplicação

1. Incluimos a jQuery no nosso documento pois iremos utilizá-la, caso voce não conheca a jQuery, neste post falo um pouco sobre ela, e apresento alguns seletores básicos.
2. Note que temos duas divs com display:none, a div#loader_img é mostrada quando o form sofrer um submit, e a div#upload_msg é utilizada para mostrar mensagens para o usuário.
3. O form possui um target apontando para o iframe, aqui esta a mágica! Como esta apontando para o iframe, isso indica que o formulário será processado dentro do iframe, evitando que a página seja recarregada.

Agora vamos ao nosso código JavaScript dessa página.

<script type="text/javascript">
$(document).ready(function() {
	$('#upload_target').hide();

	$('form#form_upload').submit(function() {
		$('#upload_msg').hide(500);
		$(this).hide(500, function() {
			$('#loader_img').show(500);
		});
	});
});
</script>

Explicação

1. Linha 3, escondemos o iframe da página, pois não queremos que ele sejá visto.
2. Linha 5, selecionamos o form, e colocamos uma função de callback para quando o form sofrer o submit.
3. Linha 6, escondemos a div de mostrar mensagens para o usuário. Eu sei ela já esta com display:none, mas se ja foi feito um upload, ela estará visível.
4. Linha 7, Escondemos o form, e na função de callback mostramos a imagem de carregando.

O nosso código da página ficou assim

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>UPLOAD</title>
<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
<script type="text/javascript">
$(document).ready(function() {
	$('#upload_target').hide();

	$('form#form_upload').submit(function() {
		$('#upload_msg').hide(500);
		$(this).hide(500, function() {
			$('#loader_img').show(500);
		});
	});
});
</script>
</head>
<body>

<h1>Escolha o arquivo</h1>

<div style="display: none;" id="loader_img">
	<img src="img/loader.gif" alt="Carregando..." title="Carregando..." />
</div>
<div style="display: none;" id="upload_msg"></div>
<form action="do_upload.php" id="form_upload" enctype="multipart/form-data" method="post" target="upload_target">
<p>
	<label>Arquivo
		<input type="file" name="arquivo" id="arquivo" />
	</label>
</p>
<p>
	<input type="submit" name="do_action" id="do_action" value="Upload" />
</p>
</form>
<iframe id="upload_target" name="upload_target" src="#"></iframe>

</body>
</html>

Bom, agora falta a página de action do form, do_upload.php nela fazemos o upload e escrevos o status do upload na página, além de escondermos a div com a imagem de carregando e mostramos novamente o form.

Vamos lá

<?php

/******* CONFIGURACOES *******/

// Nome do input FILE
$inputFile = 'arquivo';

// Limitar extensoes (TRUE ou FALSE)
$limitarExt = TRUE;

// Extensoes validas
$extensoesValidas = array('.gif', '.jpg', '.jpeg', '.png', '.txt');

// Limitar tamanho (TRUE ou FALSE)
$limitarTamanho = FALSE;

// Tamanho em bytes
$tamanhoMax = 1024 * 200;

// Caminho do upload
$caminho = 'upload/';

// Sobrescrever arquivo (TRUE ou FALSE)
$sobrescrever = FALSE;

/******* FIM CONFIGURACOES *******/

$nomeArquivo 	 = $_FILES[$inputFile]['name'];
$tamanhoArquivo  = $_FILES[$inputFile]['size'];
$nomeTempArquivo = $_FILES[$inputFile]['tmp_name'];
$erroArquivo 	 = $_FILES[$inputFile]['error'];
$extArquivo 	 = strtolower(strrchr($nomeArquivo, '.'));
$msg = '';

if ( $erroArquivo == 4 ) {
	// Nenhum arquivo enviado
	$msg = 'Selecione um arquivo!';
} elseif ( $erroArquivo == 0 ) {
	// Verifica a extensao
	if ( ($limitarExt === TRUE) && (! in_array($extArquivo, $extensoesValidas)) ) {
		$msg = 'Tipo de arquivo inválido!';
	// Verifica o tamanho
	} elseif ( ($limitarTamanho === TRUE) && ($tamanhoArquivo > $tamanhoMax) ) {
		$msg = 'Arquivo muito grande!';
	// Varifica se o arquivo ja existe
	} elseif ( ($sobrescrever === FALSE) && (file_exists($caminho . $nomeArquivo)) ) {
		$msg = 'Arquivo já existe!';
	} else {
		// Se moveu o arquivo
		if ( move_uploaded_file($nomeTempArquivo, $caminho . $nomeArquivo) ) {
			$msg = 'Arquivo enviado com sucesso!';
		} else {
			$msg = 'Ocorreu um erro durante o envio do arquivo, tente novamente.';
		}
	}
} else {
	$msg = 'Ocorreu um erro durante o envio do arquivo, tente novamente.';
}

sleep(1);

$out  = <<<OUT
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
<script type="text/javascript">
	$('#loader_img', top.document).hide();
	$('#upload_msg', top.document).html('$msg');
	$('#upload_msg', top.document).show()
	$('form#form_upload p label input:file', top.document).remove();
	$('form#form_upload label', top.document).append('<input type="file" name="arquivo" id="arquivo" />');
	$('form#form_upload', top.document).show();
</script>
OUT;

echo $out;
?>

Desenvolvi um script de upload bem completo, que voce pode usar inclusive em outros sistemas que voce esteja desenvolvendo.

Explicação

Primeiro possuimos a parte de configurações, onde voce pode configurar:

1. O nome do input file que voce esta usando no form.
2. Se deve-se limitar extensões para envio de arquivo.
3. As extensões válidas.
4. Se deve-se limitar o tamanho do arquivo enviado.
5. O tamanho máximo permitido.
6. O caminho do upload.
7. Se deve-se sobrescrever o arquivo, caso ela já exista.

Não irei explicar linha por linha, pois os comentários no código ja são auto explicativos.

O script só vai até a linha 58, após isso, são realizadas operações para escrever o JavaScript que irá manipular a página, como dito anteriormente.

Linha 60, adicionei a função sleep() para caso o arquivo enviado seja muito pequeno, ou não tenha sido enviado nenhuma arquivo, haja tempo necessário para os efeitos esconderem os elementos na página.

Linha 62, começamos a preparar o JavaScript para manipular a página.

Note que utilizamos os seletores dentro de top.document. Ou seja, serão selecionados elementos no documento acima do iframe, que é justamente a página.

No JavaScript

1. Linha 66, escondemos a imagem de carregando.
2. Linha 67, escrevemos o retorno do upload, variável $msg.
3. Linha 68, mostramos a div#upload_msg.
4. Linha 69, removemos o input file do form, pois o atributo value de um input file, não pode ser modificado.
5. Linha 70, inserimos um novo input file.
6. Linha 71, mostramos o form.

E pronto!

A idéia de funcionamento é bem simples, é selecionado o arquivo, faz o upload que é processado no iframe, e o PHP escreve o JavaScript que manipula a página.

Dica: Se voce tem o FireBug, após um upload verá que dentro do iframe, foi escrito aquele código JavaScript.

Download

Caso haja alguma dúvida, poste nos comentários.

Imagine o seguinte código:

<?php
$a = 10;
if ( $a = 10 ) {
	echo 10;
}

Ele será executado normalmente, e com certeza te dará um bom trabalho para encontrar o erro, não é o caso, pois aqui temos apenas o IF, mas imagine que tenha diversas outras linhas e até outras opções no IF.

Esse tipo de erro, pode ocorrer por um simples erro de digitação, ou sem querer você apagou um sinal de igual = e não percebeu.

Por isso, é bom utilizar a variável que você deseja comparar na frete do valor.

<?php
$a = 10;
if ( 10 = $a ) {
	echo 10;
}

Dessa forma, pode até parecer meio desorganizado, mas se por acaso você esquecer de colocar um sinal de igual =, isso irá gerar um erro no PHP, facilitando assim, a detecção do problema.

Escrevendo dessa forma, 10 seria atribuído a variável $a, e seria avaliado como true, logo seria escrito 10 na tela.

<?php
$a = 10;
if ( $a = 10 ) {
	echo 10;
}

Já escrevendo assim, ocorreria um erro de parse no PHP.

<?php
$a = 10;
if ( 10 = $a ) {
	echo 10;
}

Dica removida do livro PHP CookBook 2 edição.
Espero que a dica seja útil para você!