ENVIANDO E-MAIL EM FORMATO HTML

terça-feira, 17 de junho de 2008 | Marcadores: | 0 comentários |

A função mail() do PHP nos permite enviar email através de um script de forma simples e objetiva.
Vamos ao código:

<?
mail(
"fabio@vivaolinux.com.br",
"Oi Fábio",
"Meu script para envio de email deu certo !"
);
?>

O comando mail() é definido da seguinte forma:

bool mail ( string to, string subject, string message [, string additional_headers [, string additional_parameters]])

Em nosso primeiro exemplo definimos apenas os campos to, subject e message, mas ainda existem os cabeçalhos adicionais que podem ser definidos e são opcionais. Sempre que você estiver consultando a sintaxe de uma função e encontrar parâmetros delimitados por [] (colchetes), significa que os mesmos são opcionais, ou seja, você pode omiti-los.

Sendo assim, para enviar um email em formato HTML, basta informar que o mesmo é do tipo text/html através do cabeçalho do email e digitar tags Html misturadas com o texto da mensagem no campo subject. Vamos ao código:
<?

$to = "fulano@seudominio.com";
$subject = "Olá, mundo!";
$html = "
<html>
<body>
Este é meu <b>primeiro</b> email em formato HTML!
</body>
</html>";
$headers = "Content-type: text/html; charset=iso-8859-1\r\n";

if (mail($to, $subject, $html, $headers)) {
echo "Email enviado com sucesso !";
} else {
echo "Ocorreu um erro durante o envio do email.";
}

?>

Como a função mail() retorna um valor booleano (verdadeiro ou falso) de acordo com o status de envio de email, podemos tratar uma mensagem de sucesso ou de erro durante o envio de email.

CSS PARA PAGINAÇÃO

sexta-feira, 13 de junho de 2008 | Marcadores: , , | 0 comentários |

Hoje vamos implementar o nosso post anterior - paginação de resultados - com um css que irá deixá-lo assim:Você pode variar as cores como desejar e é muito fácil, vamos ao código css:

body {
font-size: 100%;
color: #333;
background: #FFF;
font-family: Arial, Helvetica, sans-serif;
}
#pages {
padding: 3px;
}
#pages ul {
list-style-type: none;
}
#pages li {
float: left;
display: inline;
margin: 0 5px 0 0;
display: block;
}
#pages li a {
color: #88af3f;
padding: 4px;
border: 1px solid #ddd;
text-decoration: none;
float: left;
}
#pages li a:hover {
color: #638425;
background: #f1ffd6;
border: 1px solid #85bd1e;
}
#pages li.nolink {
color: #CCC;
border: 1px solid #F3F3F3;
padding: 4px;
}
#pages li.current {
color: #FFF;
border: 1px solid #b2e05d;
padding: 4px;
background: #b2e05d;
}

Salve esta página como paginacao.css

Agora vamos ver como o código é aplicado na paginação:

<div id="pages">
<ul>
<li class="nolink">« Previous Page</li>
<li class="current">1</li>
<li><a href="#">2</a></li>
<li><a href="#">3</a></li>
<li><a href="#">4</a></li>
<li><a href="#">5</a></li>
<li><a href="#">6</a></li>
<li><a href="#">7</a></li>
<li><a href="#">8</a></li>
<li><a href="#">9</a></li>
<li><a href="#">10</a></li>
<li><a href="#">Next Page »</a></li>
</ul>
</div>

Salve esta página como teste_paginacao.html e veja o resultado.

APLICANDO ESTE CSS NO POST ANTERIOR
Para ver o post clique aqui!

Este é o código completo com o css.

<link rel="stylesheet" type="text/css" href="paginacao.css">
<?
require("configuracoes/conecta.");

if (!isset($_GET["pagina"])) {
$pagina = 1;
}
else {
$pagina = $_GET["pagina"];

}

//quantidade de resultados por página
$max=50;
//quantidade de links para esquerda e direita
$qtd = 7;

$inicio = $pagina - 1;
$inicio = $max * $inicio;

$sql=("SELECT * FROM pessoa");
$query=mysql_query($sql);
$total=mysql_num_rows($query);

if ($total == 0)
echo "Nenhum registro encontrado!";
else

{
echo"Quantidade de registros encontrados: ".$total.'<br><br>';
$sql2=("SELECT * FROM pessoa LIMIT $inicio,$max");
$query2=mysql_query($sql2);
?>
<table>
<?
while ($mostrar=mysql_fetch_array($query2)){ ?>
<tr>
<td><? echo $mostrar['nome'];?></td>
<td><? echo $mostrar['telefone'];?></td>
</tr>
<? }?>
</table>
<table>
<tr>
<td height="71">
<div id="pages">
<ul>
<?
}
// Calculando pagina anterior
$menos = $pagina - 1;
// Calculando pagina posterior
$mais = $pagina + 1;
$pgs = ceil($total / $max);
if($pgs > 1 )
{
if($menos >0)
{
echo "<li><a href=\"?pagina=$menos\">Anterior</a></li>";
}else{ echo "<li class=\"nolink\">anterior</li>"; }
if (($pagina-$qtd) < 1 )

$anterior = 1;

else
$anterior = $pagina-$qtd;

if (($pagina+$qtd) > $pgs )
$posterior = $pgs;
else

$posterior = $pagina + $qtd;

for($i=$anterior;$i <= $posterior; $i++)
if($i != $pagina)
echo " <li><a href=\"?pagina=".($i)."\">$i</a></li>";

else
echo "<li class=\"current\"> <strong>".$i."</strong></li>";

if($mais <= $pgs)
{
?>
<li><a href="?pagina=<? echo $mais; ?>">Proxima</a></li>
<?
}else{
?>
<li class="nolink">Proxima</li>
<?
}

}

?>
</ul>
</div>
</td>
</tr>
</table>

PAGINAÇÃO DE RESULTADOS

| Marcadores: , | 0 comentários |

Vamos aprender como fazer uma paginação em php no estilo google!

Primeiramente faça uma base de dados com o nome paginacao , em seguida faça uma tabela com o nome pessoa com os campos nome e telefone.

Agora vamos ao código
<?
$conn=mysql_connect("localhost","root","") or die ("Erro na conexão");
$db=mysql_select_db("paginacao") or die ("Erro no banco");

if (!isset($_GET["pagina"])) {
$pagina = 1;
}
else {
$pagina = $_GET["pagina"];

}

$max=1;

$inicio = $pagina - 1;
$inicio = $max * $inicio;

$sql=("select * from pessoa");
$query=mysql_query($sql);
$total=mysql_num_rows($query);

if ($total == 0)
echo "Nenhum registro encontrado!";
else

{
echo"Quantidade de registros encontrados: ".$total.'<br><br>';
$sql2=("select * from pessoa LIMIT $inicio,$max");
$query2=mysql_query($sql2);
?>
<style type="text/css">
<!--
body,td,th {
font-family: Verdana, Arial, Helvetica, sans-serif;
font-size: 12px;
}
a:link {
color: #0099FF;
}
a:visited {
color: #0099FF;
}
a:hover {
color: #99CC00;
}
a:active {
color: #0099FF;
}
.texto_paginacao_pgatual {color:#FF0000}
-->
</style>
<table width="25%" border="0" cellspacing="0" cellpadding="0">
<?
while ($mostrar=mysql_fetch_array($query2)){ ?>
<tr>
<td scope="col"><? echo $mostrar['nome'];?></td>
<td scope="col"><? echo $mostrar['telefone'];?></td>
</tr>
<? }?>
</table>
<table width="25%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td height="71" scope="col">
<?
}
// Calculando pagina anterior
$menos = $pagina - 1;
// Calculando pagina posterior
$mais = $pagina + 1;
$pgs = ceil($total / $max);
if($pgs > 1 )
{
if($menos >0)
{
echo "<a href=\"?pagina=$menos\" class='texto_paginacao'>Anterior</a> ";
}else{
?>
Anterior
<?
}
if (($pagina-4) < 1 )

$anterior = 1;

else
$anterior = $pagina-4;

if (($pagina+4) > $pgs )
$posterior = $pgs;
else

$posterior = $pagina + 4;

for($i=$anterior;$i <= $posterior; $i++)
if($i != $pagina)
echo " <a href=\"?pagina=".($i)."\" class='texto_paginacao'>$i</a>";

else
echo " <strong class='texto_paginacao_pgatual'>".$i."</strong>";

if($mais <= $pgs)
echo " <a href=\"?pagina=$mais\" class='texto_paginacao'>Proxima</a>";
}else{
?>
Proxima
<?
}

?>
</td>
</tr>
</table>

Fácil, fácil ...
No próximo post nós iremos complementar esta paginação aplicando um css para deixar bem mais bonito!

VALIDAÇÃO DE FORMULÁRIOS COM AJAX

segunda-feira, 9 de junho de 2008 | Marcadores: , | 0 comentários |

Na validação no lado do cliente vamos utilizar uma classe Ajax chamada Really easy field validation with Prototype. Sua implantação é muito fácil. Basta adicionar ao campo do formulário um comando no atributo class.

EXEMPLO:
<HTML>
<HEAD>
<TITLE>Teste de validação de formulário</TITLE>
</HEAD>
<BODY>
<script src="ajax/scriptaculous/lib/prototype.js" type="text/javascript"></script>
<script src="ajax/scriptaculous/src/effects.js" type="text/javascript"></script>
<script type="text/javascript" src="ajax/fabtabulous.js"></script>
<script type="text/javascript" src="ajax/validation.js"></script>
<link rel="stylesheet" type="text/css" href="ajax/style.css">

<!-- INICIO DO FORMULÁRIO -->

<form id="teste" action="#" method="get">

Nome:<input name="nome" id="nome" class="required">

<input type="submit" value="submit">

</form>

<!-- OBJETO DE VALIDAÇÃO -->
<script type="text/javascript">
var teste=new Validation('teste');
</script>
</BODY>
</HTML>

No exemplo acima, se o usuário clicar no botão “Submit” sem preencher o campo “nome” o formulário não será enviado e uma mensagem de erro irá aparecer.

Se você quiser usar outra mensagem de erro é possível adicionado o atributo “title” ao elemento. O script automaticamente substitui a mensagem padrão pela definida.

Você não precisa saber nada de Ajax pra utilizar esta classe, basta adicionar os atributos corretos e personalizar as mensagens e você já tem uma validação no lado do cliente. Junto com o arquivo da classe estão outros exemplos.

FAÇA AQUI O DOWNLOAD DAS CLASSES

Fonte: www.rodrigopacheco.com

FUNÇÕES

| Marcadores: , | 0 comentários |

Definindo funções

A sintaxe básica para definir uma função é:

function nome_da_função([arg1, arg2, arg3]) {
Comandos;
... ;
[return ];
}

Qualquer código PHP válido pode estar contido no interior de uma função. Como a checagem de tipos em PHP é dinâmica, o tipo de retorno não deve ser declarado, sendo necessário que o programador esteja atento para que a função retorne o tipo desejado. É recomendável que esteja tudo bem documentado para facilitar a leitura e compreensão do código. Para efeito de documentação, utiliza-se o seguinte formato de declaração de função:

tipo function nome_da_funcao(tipo arg1, tipo arg2, ...);

Este formato só deve ser utilizado na documentação do script, pois o PHP não aceita a declaração de tipos. Isso significa que em muitos casos o programador deve estar atento ao tipos dos valores passados como parâmetros, pois se não for passado o tipo esperado não é emitido nenhum alerta pelo interpretador PHP, já que este não testa os tipos.

Valor de retorno
Toda função pode opcionalmente retornar um valor, ou simplesmente executar os comandos e não retornar valor algum.

Não é possível que uma função retorne mais de um valor, mas é permitido fazer com que uma função retorne um valor composto, como listas ou arrays.

Argumentos
É possível passar argumentos para uma função. Eles devem ser declarados logo após o nome da função, entre parênteses, e tornam-se variáveis pertencentes ao escopo local da função. A declaração do tipo de cada argumento também é utilizada apenas para efeito de documentação.

Exemplo:

function imprime($texto){
echo $texto;
}
imprime("teste de funções");

Passagem de parâmetros por referência
Normalmente, a passagem de parâmetros em PHP é feita por valor, ou seja, se o conteúdo da variável for alterado, essa alteração não afeta a variável original.

Exemplo:

function mais5($numero) {
$numero += 5;
}
$a = 3;
mais5($a); //$a continua valendo 3

No exemplo acima, como a passagem de parâmetros é por valor, a função mais5 é inútil, já que após a execução sair da função o valor anterior da variável é recuperado. Se a passagem de valor fosse feita por referência, a variável $a teria 8 como valor. O que ocorre normalmente é que ao ser chamada uma função, o interpretador salva todo o escopo atual, ou seja, os conteúdos das variáveis. Se uma dessas variáveis for passada como parâmetro, seu conteúdo fica preservado, pois a função irá trabalhar na verdade com uma cópia da variável. Porém, se a passagem de parâmetros for feita por referência, toda alteração que a função realizar no valor passado como parâmetro afetará a variável que o contém.

Há duas maneiras de fazer com que uma função tenha parâmetros passados por referência: indicando isso na declaração da função, o que faz com que a pasagem de parâmetros sempre seja assim; e também na própria chamada da função. Nos dois casos utiliza-se o modificador "&". Vejamos um exemplo que ilustra os dois casos:

function mais5(&$num1, $num2) {
$num1 += 5;
$num2 += 5;
}

$a = $b = 1;

mais5($a, $b); /* Neste caso, só $num1 terá seu valor alterado, pois a passagem por referência está definida na declaração da função. */

mais5($a, &$b); /* Aqui as duas variáveis terão seus valores alterados. */

Argumentos com valores pré-definidos (default)
Em PHP é possível ter valores default para argumentos de funções, ou seja, valores que serão assumidos em caso de nada ser passado no lugar do argumento. Quando algum parâmetro é declarado desta maneira, a passagem do mesmo na chamada da função torna-se opcional.

function teste($vivas = "testando") {
echo $vivas;
}

teste(); // imprime "testando"
teste("outro teste"); // imprime "outro teste"

É bom lembrar que quando a função tem mais de um parâmetro, o que tem valor default deve ser declarado por último:

function teste($figura = circulo, $cor) {
echo "a figura é um ", $figura, " de cor " $cor;
}

teste(azul);
/* A função não vai funcionar da maneira esperada, ocorrendo um erro no interpretador. A declaração correta é: */

function teste2($cor, $figura = circulo) {
echo "a figura é um ", $figura, " de cor " $cor;
}

teste2(azul);
/* Aqui a funcao funciona da maneira esperada, ou seja, imprime o texto: "a figura é um círculo de cor azul" */

Contexto
O contexto é o conjunto de variáveis e seus respectivos valores num determinado ponto do programa. Na chamada de uma função, ao iniciar a execução do bloco que contém a implementação da mesma é criado um novo contexto, contendo as variáveis declaradas dentro do bloco, ou seja, todas as variáveis utilizadas dentro daquele bloco serão eliminadas ao término da execução da função.

Escopo
O escopo de uma variável em PHP define a porção do programa onde ela pode ser utilizada. Na maioria dos casos todas as variáveis têm escopo global. Entretanto, em funções definidas pelo usuário um escopo local é criado. Uma variável de escopo global não pode ser utilizada no interior de uma função sem que haja uma declaração.

Exemplo:

$vivas = "Testando";

function Teste() {
echo $vivas;
}

Teste();

O trecho acima não produzirá saída alguma, pois a variável $vivas é de escopo global, e não pode ser referida num escopo local, mesmo que não haja outra com nome igual que cubra a sua visibilidade. Para que o script funcione da forma desejada, a variável global a ser utilizada deve ser declarada.

Exemplo:
$vivas = "Testando";

function Teste() {
global $vivas;
echo $vivas;
}

Teste();

Uma declaração "global" pode conter várias variáveis, separadas por vírgulas. Uma outra maneira de acessar variáveis de escopo global dentro de uma função é utilizando um array pré-definido pelo PHP cujo nome é $GLOBALS. O índice para a variável referida é o proprio nome da variável, sem o caracter $. O exemplo acima e o abaixo produzem o mesmo resultado:

Exemplo:
$vivas = "Testando";

function Teste() {
echo $GLOBALS["vivas"]; // imprime $vivas
echo $vivas; // não imprime nada
}

Teste();

FUNÇÕES PARA TRATAMENTO DE ARRAYS

| Marcadores: , | 0 comentários |

Funções genéricas

array

array array(...);
É a função que cria um array a partir dos parâmetros forncidos. É possível fornecer o índice de cada elemento. Esse índice pode ser um valor de qualquer tipo, e não apenas de inteiro. Se o índice não for fornecido o PHP atribui um valor inteiro sequencial, a partir do 0 ou do último índice inteiro explicitado. Vejamos alguns exemplos:

Exemplo 1:
$teste = array("um", "dois","tr"=>"tres",5=>"quatro","cinco");

Temos o seguinte mapeamento:
0 => "um" (0 é o primeiro índice, se não houver um explicito)
1 => "dois" (o inteiro seguinte)
"tr" => "tres"
5 => "quatro" (valor explicitado)
6 => "cinco" (o inteiro seguinte ao último atribuído, e não o próximo valor, que seria 2)

Exemplo 2:
$teste = array("um", 6=>"dois","tr"=>"tres",5=>"quatro","cinco");

Temos o seguinte mapeamento:
0 => "um"
6 => "dois"
"tr" => tres
5 => "quatro" (seria 7, se não fosse explicitado)
7 => "cinco" (seria 6, se não estivesse ocupado)

Em geral, não é recomendável utilizar arrays com vários tipos de índices, já que isso pode confundir o programador. No caso de realmente haver a necessidade de utilizar esse recurso, deve-se ter bastante atenção ao manipular os índices do array.

range

 array range(int minimo, int maximo);
A função range cria um array cujos elementos são os inteiros pertencentes ao intervalo fornecido, inclusive. Se o valor do primeiro parâmetro for maior do que o do segundo, a função retorna false (valor vazio).

shuffle

void shuffle(array &arr);
Esta função "embaralha" o array, ou seja, troca as posições dos elementos aleatoriamente e não retorna valor algum.

sizeof

int sizeof(array arr);
Retorna um valor inteiro contendo o número de elementos de um array. Se for utilizada com uma variável cujo valor não é do tipo array, retorna 1. Se a variável não estiver setada ou for um array vazio, retorna 0.

Funções de "navegação"

Toda variável do tipo array possui um ponteiro interno indicando o próximo elemento a ser acessado no caso de não ser especificado um índice. As funções seguintes servem para modificar esse ponteiro, permitindo assim percorrer um array para verificar seu conteúdo (chaves e elementos).

reset

mixed reset(array arr);
Seta o ponteiro interno para o primeiro elemento do array, e retorna o conteúdo desse elemento.

end

mixed end(array arr);
Seta o ponteiro interno para o último elemento do array, e retorna o conteúdo desse elemento.

next

mixed next(array arr);
Seta o ponteiro interno para o próximo elemento do array, e retorna o conteúdo desse elemento.

Obs.: Esta não é uma boa função para determinar se um elemento é o último do array, pois pode retornar false tanto no final do array como no caso de haver um elemento vazio.

prev

mixed prev(array arr);
Seta o ponteiro interno para o elemento anterior do array, e retorna o conteúdo desse elemento. Funciona de maneira inversa a next.

pos

mixed pos(array arr);
Retorna o conteúdo do elemento atual do array, indicado pelo ponteiro interno.

key

mixed key(array arr);
Funciona de maneira bastante semelhante a pos, mas ao invés de retornar o elemento atual indicado pelo ponteiro interno do array, retorna seu índice.

each

array each(array arr);
Retorna um array contendo o índice e o elemento atual indicao pelo ponteiro interno do array. o valor de retorno é um array de quatro elementos, cujos índices são 0, 1, "key" e "value". Os elementos de índices 0 e "key" armazenam o índice do valor atual, e os elementos de índices 1 e "value" contém o valor do elemento atual indicado pelo ponteiro.

Esta função pode ser utilizada para percorrer todos os elementos de um array e determinar se já foi encontrado o último elemento, pois no caso de haver um elemento vazio, a função não retornará o valor false. A função each só retorna false depois q o último elemento do array foi encontrado.

Exemplo:

/*função que percorre todos os elementos de um array e imprime seus índices e valores */
function imprime_array($arr) {
reset($arr);
while (list($chave,$valor) = each($arr))
echo "Chave: $chave. Valor: $valor";
}

Funções de ordenação

São funções que servem para arrumar os elementos de um array de acordo com determinados critérios. Estes critérios são: manutenção ou não da associação entre índices e elementos; ordenação por elementos ou por índices; função de comparação entre dois elementos.

sort

void sort(array &arr);
A função mais simples de ordenação de arrays. Ordena os elementos de um array em ordem crescente, sem manter os relacionamentos com os índices.

rsort

void rsort(array &arr);
Funciona de maneir ainversa à função sort. Ordena os elementos de um array em ordem decrescente, sem manter os relacionamentos com os índices.

asort

void asort(array &arr);
Tem o funcionamento bastante semelhante à função sort. Ordena os elementos de um array em ordem crescente, porém mantém os relacionamentos com os índices.

arsort

void arsort(array &arr);
Funciona de maneira inversa à função asort. Ordena os elementos de um array em ordem decrescente e mantém os relacionamentos dos elementos com os índices.

ksort

void ksort(array &arr);
Função de ordenação baseada nos índices. Ordena os elementos de um array de acordo com seus índices, em ordem crescente, mantendo os relacionamentos.

usort

void usort(array &arr, function compara);
Esta é uma função que utiliza outra função como parâmetro. Ordena os elementos de um array sem manter os relacionamentos com os índices, e utiliza para efeito de comparação uma função definida pelo usuário, que deve comparar dois elementos do array e retornar 0, 1 ou –1, de acordo com qualquer critério estabelecido pelo usuário.

uasort

void uasort(array &arr, function compara);
Esta função também utiliza outra função como parâmetro. Ordena os elementos de um array e mantém os relacionamentos com os índices, utilizando para efeito de comparação uma função definida pelo usuário, que deve comparar dois elementos do array e retornar 0, 1 ou –1, de acordo com qualquer critério estabelecido pelo usuário.

uksort

void uksort(array &arr, function compara);
Esta função ordena o array através dos índices, mantendo os relacionamentos com os elementos., e utiliza para efeito de comparação uma função definida pelo usuário, que deve comparar dois índices do array e retornar 0, 1 ou –1, de acordo com qualquer critério estabelecido pelo usuário.

FUNÇÕES PARA TRABAMENTO DE STRINGS

| Marcadores: , | 0 comentários |

Funções relacionadas a HTML

htmlspecialchars

string htmlspecialchars(string str);
Retorna a string fornecida, substituindo os seguintes caracteres:

& para '&'
" para '"'
< para '<'
> para ‘>'

htmlentities

string htmlentities(string str);
Funciona de maneira semelhante ao comando anterior, mas de maneira mais completa, pois converte todos os caracteres da string que possuem uma representação especial em html, como por exemplo:

º para 'º'
ª para 'ª'
á para 'á'
ç para ‘ç'

nl2br

string nl2br(string str);
Retorna a string fornecida substituindo todas as quebras de linha ("\n") por quebras de linhas em html ("<br>").

Exemplo:
echo nl2br("Mauricio\nVivas\n");

Imprime:
Maurício
Vivas

get_meta_tags

array get_meta_tags(string arquivo);
Abre um arquivo HTML e percorre o cabeçalho em busca de "meta" tags, retornando num array todos os valores encontrados.

Exemplo:
A execução da função:
get_meta_tags("teste.html");

Retorna o array:
array("author"=>"jose","tags"=>"php3 documentation");

strip_tags

string strip_tags(string str);
Retorna a string fornecida, retirando todas as tags html e/ou PHP encontradas.

Exemplo:
strip_tags('testando');
Retorna a string "testando".

urlencode

string urlencode(string str);
Retorna a string fornecida, convertida para o formato urlencode. Esta função é útil para passar variáveis para uma próxima página.

urldecode

string urldecode(string str);
Funciona de maneira inversa a urlencode, desta vez decodificando a string fornecida do formato urlencode para texto normal.

Funções relacionadas a arrays

Implode e join

string implode(string separador, array partes);
string join(string separador, array partes);
As duas funções são idênticas. Retornam uma string contendo todos os elementos do array fornecido separados pela string também fornecida.

Exemplo:

$partes = array("a", "casa número", 13, "é azul");
$inteiro = join(" ",$partes);

$inteiro passa a conter a string:
"a casa número 13 é azul"

split

 array split(string padrao, string str, int [limite]);
Retorna um array contendo partes da string fornecida separadas pelo padrão fornecido, podendo limitar o número de elementos do array.

Exemplo:
$data = "11/14/1975";
$data_array = split("/",$data);

O código acima faz com que a variável $data_array receba o valor:
array(11,14,1975);

explode

array explode(string padrao, string str);
Funciona de maneira bastante semelhante à função split, com a diferença que não é possível estabelecer um limite para o número de elementos do array.

Comparações entre strings

similar_text

int similar_text(string str1, string str2, double [porcentagem]);
Compara as duas strings fornecidas e retorna o número de caracteres coincidentes. Opcionalmente pode ser fornecida uma variável, passada por referência (ver tópico sobre funções), que receberá o valor percentual de igualdade entre as strings. Esta função é case sensitive, ou seja, maiúsculas e minúsculas são tratadas como diferentes.

Exemplo:
$num = similar_text("teste", "testando",&$porc);

As variáveis passam a ter os seguintes valores:
$num == 4; $porc == 61.538461538462

strcasecmp

int strcasecmp(string str1, string str2);
Compara as duas strings e retorna 0 (zero) se forem iguais, um valor maior que zero se str1 > str2, e um valor menor que zero se str1 <>

strcmp

int strcasecmp(string str1, string str2);
Funciona de maneira semelhante à função strcasecmp, com a diferença que esta é case sensitive, ou seja, maiúsculas e minúsculas são tratadas como diferentes.

strstr

 string strstr(string str1, string str2);
string strchr(string str1, string str2);
As duas funções são idênticas. Procura a primeira ocorrência de str2 em str1. Se não encontrar, retorna uma string vazia, e se encontrar retorna todos os caracteres de str1 a partir desse ponto.

Exemplo:
strstr("Mauricio Vivas", "Viv"); // retorna "Vivas"

stristr

string strstr(string str1, string str2);
Funciona de maneira semelhante à função strstr, com a diferença que esta é case insensitive, ou seja, maiúsculas e minúsculas são tratadas como iguais.

strpos

int strpos(string str1, string str2, int [offset] );
Retorna a posição da primeira ocorrência de str2 em str1, ou zero se não houver. O parâmetro opcional offset determina a partir de qual caracter de str1 será efetuada a busca. Mesmo utilizando o offset, o valor de retorno é referente ao início de str1.

strrpos

int strrpos(string haystack, char needle);
Retorna a posição da última ocorrência de str2 em str1, ou zero se não houver.

Funções para edição de strings

chop

string chop(string str);
Retira espaços e linhas em branco do final da string fornecida.

Exemplo:
chop(" Teste \n \n "); // retorna " Teste"

ltrim

string ltrim(string str);
Retira espaços e linhas em branco do final da string fornecida.

Exemplo:
ltrim(" Teste \n \n "); // retorna "Teste \n \n"

trim

string trim(string str);
Retira espaços e linhas em branco do início e do final da string fornecida.

Exemplo:

trim(" Teste \n \n "); // retorna "Teste"

strrev

string strrev(string str);
Retorna a string fornecida invertida.

Exemplo:
strrev("Teste"); // retorna "etseT"

strtolower

string strtolower(string str);
Retorna a string fornecida com todas as letras minúsculas.

Exemplo:
strtolower("Teste"); // retorna "teste"

strtoupper

string strtoupper(string str);
Retorna a string fornecida com todas as letras maiúsculas.

Exemplo:
strtolower("Teste"); // retorna "TESTE"

ucfirst

string ucfirst(string str);
Retorna a string fornecida com o primeiro caracter convertido para letra maiúscula.

Exemplo:
ucfirst("teste de funcao"); // retorna "Teste de funcao"

ucwords

string ucwords(string str);
Retorna a string fornecida com todas as palavras iniciadas por letras maiúsculas.

Exemplo:
ucwords("teste de funcao"); // retorna "Teste De Funcao"

str_replace

string str_replace(string str1, string str2, string str3);
Altera todas as ocorrências de str1 em str3 pela string str2.

Funções diversas

chr

string chr(int ascii);
Retorna o caracter correspondente ao código ASCII fornecido.

ord

int ord(string string);
Retorna o código ASCII correspontente ao caracter fornecido.

echo

echo(string arg1, string [argn]... );
Imprime os argumentos fornecidos.

print

print(string arg);
Imprime o argumento fornecido.

strlen

int strlen(string str);
Retorna o tamanho da string fornecida.

REDIRECIONAR O USUÁRIO PARA OUTRA PÁGINA

| Marcadores: , , | 0 comentários |

O tag refresh redireciona o usuário para outra página sem que o mesmo não execute nenhuma ação. Este comando pode ser bastante útil para os sites que mudaram de endereço. Veja abaixo um exemplo completo:

<html>
<head>
<meta HTTP-EQUIV = "Refresh" CONTENT = "xsegundos; URL = xendereço.htm">
<title> Home Page </title>
</head>
<body>
Documento
</body>
</html>

xsegundos = tempo em segundos
xendereço = endereço do redirecionamento

ENVIAR, REDIMENCIONAR, SALVAR CAMINHO NA BASE DE IMAGENS E MONTAR GALERIA DE IMAGENS

| Marcadores: , , | 0 comentários |

Para enviarmos uma imagem para o servidor de seu site o primeiro passo é criar um formulário de upload de arquivos.

FUNÇAO QUE SERÁ USADA NO PROCESSO
Salve esta página como funcao.php

<?
//ESTA FUNÇÃO REDIMENCIONA A IMAGEM PROPORCIONALMENTE
function gera_thumbnail( $diretorio, $imagem, $x, $y, $arg ) {
$extensao = strtolower(end(explode('.', $imagem)));

//Define o nome do novo thumbnail
$thumbnail = explode('.', $imagem);
$thumbnail = $diretorio."/".$thumbnail[0]."".$arg.".".$extensao;

$imagem = $diretorio."/".$imagem;

//Cria uma nova imagem da imagem original
if ( $extensao == 'jpg' || $extensao == 'jpeg' ):
$img_origem = imagecreatefromjpeg($imagem);
elseif ( $extensao == 'png' ):
$img_origem = imagecreatefrompng($imagem);
elseif ( $extensao == 'gif' ):
$img_origem = imagecreatefromgif($imagem);
endif;

//Recupera as dimensoes da imagem original
$origem_x = imagesx($img_origem); //Largura
$origem_y = imagesy($img_origem); //Altura
//PROPORÇÃO DAS IMAGENS
$percent = 0.5;
$x = $origem_x * $percent;
$y = $origem_y * $percent;

$img_final = imagecreatetruecolor($x, $y);

// Resize
imagecopyresized($img_final, $img_origem, 0, 0, 0, 0, $x, $y, $origem_x, $origem_y);

//Salvo o novo thumbnail
if ( $extensao == 'jpg' || $extensao == 'jpeg' ):
imagejpeg($img_final, $thumbnail, 100);
elseif ($extensao == 'png'):
imagepng($img_final, $thumbnail, 100);
elseif ($extensao == 'gif'):
imagegif($img_final, $thumbnail, 100);
endif;

//Destruo as imagens que foram utilizadas
imagedestroy($img_origem);
imagedestroy($img_final);
}

//ESTA FUNÇÃO REDIMENCIONA AS IMAGENS PARA UM TAMANHO EXATO PREENCHENDO OS ESPAÇOS COM UMA COR BRANCA
function gera_thumbnail_tn( $diretorio, $imagem, $x, $y, $arg ) {
$extensao = strtolower(end(explode('.', $imagem)));

//Define o nome do novo thumbnail
$thumbnail = explode('.', $imagem);
$thumbnail = $diretorio."/".$thumbnail[0]."".$arg.".".$extensao;

$imagem = $diretorio."/".$imagem;

//Cria uma nova imagem da imagem original
if ( $extensao == 'jpg' || $extensao == 'jpeg' ):
$img_origem = imagecreatefromjpeg($imagem);
elseif ( $extensao == 'png' ):
$img_origem = imagecreatefrompng($imagem);
elseif ( $extensao == 'gif' ):
$img_origem = imagecreatefromgif($imagem);
endif;

//Recupera as dimensoes da imagem original
$origem_x = imagesx($img_origem); //Largura
$origem_y = imagesy($img_origem); //Altura

//Se a imagem nao for proporcional ao thumbnail que se vai gerar
//Pega a maior face e calcula a outra face proporcional a imagem original
if ( $origem_x > $origem_y ): // Se a largura for maior que a altura
$final_x = $x; //A largura sera a do thumbnail
$final_y = floor( $x * $origem_y / $origem_x ); //Calculo a altura proporcional
$f_x = 0; //Posiciono a imagem no x = 0
$f_y = 0;/*round( ( $y / 2 ) - ( $final_y / 2 ) ); *///Centralizo a imagem no vertice y
else: //Se a altura for maior ou igual a largura
$final_y = $y; //A altura sera a do thumbnail
$final_x = floor( $y * $origem_x / $origem_y ); //Calculo a largura proporcional
$f_y = 0; //Posiciono a imagem no x = 0
$f_x = round( ( $x / 2 ) - ( $final_x / 2 ) ); //Centralizo a imagem no vertice x
endif;

//Gero a nova imagem do thumbnail do tamanho $x X $y
$img_final = imagecreatetruecolor($x,$y);
//define o fundo
$fundob = imagecolorallocate($img_final, 255,255,255);
//preenche o fundo da imagem
imagefill($img_final, 0, 0, $fundob);


//Copio a imagem original para a imagem do thumbnail utilizando os dados que foram calculados
imagecopyresized($img_final, $img_origem, $f_x, $f_y, 0, 0, $final_x, $final_y, $origem_x, $origem_y);

//Salvo o novo thumbnail
if ( $extensao == 'jpg' || $extensao == 'jpeg' ):
imagejpeg($img_final, $thumbnail, 100);
elseif ($extensao == 'png'):
imagepng($img_final, $thumbnail, 100);
elseif ($extensao == 'gif'):
imagegif($img_final, $thumbnail, 100);
endif;

//Destruo as imagens que foram utilizadas
imagedestroy($img_origem);
imagedestroy($img_final);
}
?>

CRIANDO A PÁGINA DE ENVIO DO ARQUIVO
Salve esta pagina como envio_imagem.htm
Abaixo o código:

<html>

<head>
<title>Envio de Imagens</title>
</head>

<body>
<form name="imagem" method="post" enctype="multipart/form-data" action="envia.php">
<p><input type="file" name="imagem"><br><input type="submit" name="formbutton1" value="Enviar Imagem"> </p>
</form>
</body>

</html>

CRIANDO A BASE DE DADOS
Vamos criar uma base chamada imagem.

Agora criamos uma tabela chamada galeria.

CREATE TABLE `galeria` (
`id` int(11) NOT NULL auto_increment,
`caminho` varchar(200) NOT NULL default '',
PRIMARY KEY (`id`)
) TYPE=MyISAM AUTO_INCREMENT=1 ;

ENVIANDO AS IMAGENS

Agora vamos fazer a página que faz todo o processo de envio, redimensionamento e que salvará o caminho da imagem em uma base.

Salve esta pagina como envia.php

Vamos ao código:

<?
//CHAMAMOS A FUNÇÃO CRIADA ACIMA
require("funcao.php");

//CONECÇÃO COM O BANCO DE DADOS
$con = mysql_connect("localhost","root","") or die("ERRO NA CONEXÃO");
$db = mysql_select_db("imagem",$con) or die("ERRO NA SELEÇÃO DA BASE DE DADOS");

//RECEBE AS IMAGENS
$ball = $_FILES['imagem']['name'];

//VERIFICA SE É JPG
//DEIXO A EXTENÇÃO PARA MINÚSCULO
$extensao = strtolower(end(explode('.', $ball)));

// SE A EXTENÇÃO É JPG CONTINUA, VOCÊ PODE VERIFICAR OUTROS TIPOS DE IMAGEM TAMBÉM É SÓ REPETIR O IF
if ($extensao=="jpg")
{

//CAMINHO COM O NOME DA IMAGEM E LOCAL (Este é o caminho onde as imagens serão salvas)
$caminho1 = "imgs/".$ball;

//MOVE A IMAGEM
move_uploaded_file($_FILES['imagem']['tmp_name'],$caminho1);

//PEGA O TAMANHO DA IMAGEM
$origem_x = getimagesize("imgs/".$ball."");


// SE A LARGURA FOR MAIOR QUE 600 (altera para o tamanho que que desejar)

if ($origem_x[0]>600)
{
//REDIMENSIONA A IMAGEM
$diretorio = "imgs";
$imagem = $ball;
$x = 600;
$y = 600;
$arg = "";
$acao = "grande";

gera_thumbnail($diretorio, $imagem, $x, $y, $arg);
}
//GERA O THUMBNAIL
$diretorio = "imgs";
$imagem = $ball;
$x = 100;
$y = 100;
$arg = "_tn";
$acao = "pequeno";

gera_thumbnail_tn($diretorio, $imagem, $x, $y, $arg);

//PESQUISA NA BASE O ULTIMO NOME DA IMAGEM
$sql_n = "SELECT MAX(id) FROM galeria";
$cons_n = mysql_query($sql_n);
$num = mysql_fetch_array($cons_n);
$numero = $num[0];
$numero1 = $numero+1;

//RENOMEIA AS IMAGEMS
rename("imgs/".$ball."","imgs/".$numero1.".jpg");
$nome_t = explode('.jpg', $ball);
$nome_t2 = $nome_t[0];
rename("imgs/".$nome_t2."_tn.jpg","imgs/".$numero1."_tn.jpg");

//INSERE O CAMINHO NA BASE
$caminho_novo = "imgs/".$numero1.".jpg";
$sql = "INSERT into galeria VALUES('', '$caminho_novo')";
mysql_query($sql);

echo "IMAGEM INCLUÍDA COM SUCESSO";

}
else
{
//SE A IMAGEM NÃO FOR JPG
echo "IMAGEM NÃO INCLUIDA PORQUE A IMAGEM NÃO CORRESPONDE AO FORMATO ACEITO! (.jpg)";
}
?>

PÁGINA PARA VISUALIZAR A GALERIA
Salve como galeria.php

<?
//CONECÇÃO COM O BANCO DE DADOS
$con = mysql_connect("localhost","root","") or die("ERRO NA CONEXÃO");
$db = mysql_select_db("imagem",$con) or die("ERRO NA SELEÇÃO DA BASE DE DADOS");

?>
<html>
<head>
<title>Minha Galeria<title>
</head>
<body>
<table>
<?
//MONTAMOS A GALERIA
$colunas="5";//ALTERE AQUI PARA A QUANTIDADE DE COLUNAS PRETENDIDAS
$cont="1";

//CONSULTA AS IMAGENS
$sql = "SELECT caminho FROM galeria";
$cons = mysql_query($sql);
while($valor = mysql_fetch_array($cons))
{
if($cont==1){
?>
<tr>
<?
}
?> <td>
<img src="imgs/<? echo $valor["caminho"]; ?>">
</td>
<?
if($cont==$colunas){
echo "</tr>";

$cont=0;
}
$cont=$cont+1;
}

if(!$cont==$colunas){
echo "</tr></table>";
} else {
?> </tr>

</table>
</body>
</html>
<?
}
?>

PRONTINHO!
EM UM PRÓXIMO POST ENSINAREI A FAZER PAGINAÇÃO NESTA GALERIA, FAZER VÁRIAS GALERIAS E TAMBÉM A INCLUIR COMENTÁRIOS NAS FOTOS!

CRIANDO E GERANDO PDF NO PHP COM A BIBLIOTECA PDML

quinta-feira, 5 de junho de 2008 | Marcadores: , , | 0 comentários |

A PDML é uma biblioteca que permite a criação e geração de PDFs no PHP de uma maneira super fácil para quem já é familiarizado com o HTML, se tornando tão fácil a criação e geração de PDFs por ela quanto se criar uma página em HTML.

Ela utiliza como base a linguagem de marcação de mesmo nome, que é totalmente escrita em PHP, e a classe FPDF.

Uma vez tendo baixado a biblioteca, descompacte ela em um diretório de sua preferência e ela já estará pronta para uso.

Um exemplo básico de PDF gerado usando ela:

<?
require_once("pdml.php");
?>
<pdml>
<body>
<i><u>Testando a biblioteca PDML</u></i><br />
<br />
A criação de PDF pela <b>PDML</b> é tão simples quanto criar um documento <b>HTML</b>.<br />
<br />
<a href="http://www.htmlstaff.org">http://www.htmlstaff.org</a>
</body>
</pdml>

Agora vamos para a parte mais avançada

Conhecendo as principais funções

Abaixo estão relacionadas as principais funções que serão utilizadas para a criação do arquivo, com a respectiva descrição.

SetFont - Define a fonte que será usada para imprimir o texto. É obrigatório setar ao menos uma vez a fonte que será utilizada no documento.

SetTitle - Define o título do documento.

SetSubject - Define o assunto do documento.

SetX - Define a abscissa da posição corrente. A grosso modo podemos dizer que informa a posição a partir da margem esquerda do documento.

SetY - Explicando de uma forma simples, indica a linha (posição vertical).

Cell - Imprime uma célula (área retangular) com bordas opcionais, cor de fundo e texto. O canto superior-esquerdo da célula corresponde à posição atual. O texto pode ser alinhado ou centralizado. Depois de chamada, a posição atual se move para a direita ou para a linha seguinte. É possível pôr um link no texto. Se a quebra de página automática está habilitada e a pilha for além do limite, uma quebra de página é feita antes da impressão.

Ln - Faz uma quebra de linha. A abscissa corrente volta para a margem esquerda e a ordenada é somada ao valor passado como parâmetro.

MultiCell - Este método permite imprimir um texto com quebras de linha. Podem ser automática (assim que o texto alcança a margem direita da célula) ou explícita (através do caracter n). Serão geradas tantas células quantas forem necessárias, uma abaixo da outra.

Image - Permite inserir uma imagem no documento. Os tipos permitidos são JPG e PNG.

AddPage - Acrescenta uma página ao documento.

PageNo - Informa a página atual.

AliasNbPages - Define um apelido para a impressão do número total de páginas.

Header e Footer - Estes métodos inserem automaticamente o cabeçalho e rodapé das páginas do documento. Porém, para utilizá-las, é necessário criar uma subclasse para sobrepor os métodos originais.

Output - Envia o documento para o destino informado. Pode-se abrir o arquivo no navegador, fazer o download ou mesmo salvar o arquivo no disco.

OBSERVAÇÃO:

Sempre que for necessário setar a posição X e Y, sete primeiro o Y e depois o X.

Criando nosso primeiro documento

<?

require_once("pdf/fpdf.php");

$texto = "Os arquivos PDF se transformaram ao longo do tempo em um padrão para troca de documentos. Desde relatórios até contratos, este formato
tem sido usado em larga escala devido a sua portabilidade - é possível abrir arquivos deste tipo em qualquer sistema operacional - além de, geralmente, ser um arquivo pequeno.
Isso sem falar que um arquivo PDF não pode ser modificado, garantindo, desta forma, que o arquivo irá sempre manter o mesmo conteúdo. Eu arriscaria dizer, ainda, que passa uma
aparência mais profissional enviar um arquivo em formato PDF, ao invés de outros formatos, como DOC, por exemplo.";

//defininfo a fonte !
define("FPDF_FONTPATH","pdf/font/");

//instancia a classe
//uso: FPDF(orientacao - retrato ou paisagem), unidade de medida, tamanho do papel)
$pdf = new FPDF("P","mm","A4");

//define a fonte a ser usada
//uso: SetFont(nome da fonte, estilo (branco = normal, b = negrito, i = italico, u = sublinhado), tamanho da fonte)
$pdf->SetFont("arial","",10);

//define o titulo
$pdf->SetTitle("Criando nosso primeiro arquivo PDF !");

// seta a posicao vertical e horizontal
$pdf->SetY("-1");

//assunto
$pdf->SetSubject("Criação de arquivos PDF com PHP!");

//escreve o texto
//uso: Cell(largura, altura, conteudo, borda, quebra de linha, alinhamento (L = esquerdo, R = direito, C = centralizado)
$pdf->Cell(0,5,"Criando arquivos PDF com PHP",0,0,'L');
$pdf->Cell(0,5,"http://fdweb.com.br",0,1,'R');
$pdf->Cell(0,0,"",1,1,'L');
$pdf->Ln(8);

//Seta a fonte do texto do documento
$pdf->SetFont("arial",'',8);

// insere a imagem
//uso: Image(caminho, posicao X,posicao Y,altura, largura)
//$pdf->Image(”http://fdweb.com.br/downloads/logo.jpg”, $pdf->GetX(), $pdf->GetY(), 20, 20);
$pdf->Image("imgs/curriculum/1.jpg",10,30,40,60);

//posiciona horizontalmente
$pdf->SetY("30");
$pdf->SetX("50");

//Insere o texto do documento
//uso: MultiCell(largura, altura, conteudo, borda, quebra de linha, alinhamento (L = esquerdo, R = direito, C = centralizado, J = justificado)
$pdf->MultiCell(0,5,$texto,0,'L',0);

$pdf->Output("imgs/curriculum/teste.pdf");
?>

Prontinho Fácil, fácil!

DOWNLOAD A CLASSE AQUI

Site Oficial: http://pdml.sourceforge.net/

Assinar: Postagens (Atom)