Loading ...
Postado por Plinio Cruz em 30 de dezembro de 2009 - Banco de Dados, PHP, Programação | 
Seja o primeiro a comentar
Na área de sistemas web uma coisa muito importante é o backup da base de dados, afinal um rotina imprópria no sistema pode alterar o banco de dados de forma errada comprometendo a integridade dos dados ou mesmo a consistência das informações. Além disso nenhuma empresa de hospedagem está livre de um problema sério com um servidor que coloque tudo a perder e como muitas não tiram backup podem criar um grande transtorno para o seu cliente.
Nós, da Trio Interativa, desenvolvemos muitos sistemas de gestão de eventos, muitas vezes, durante o processo de inscrições eletrônicas fazemos de três a quatro backup da base do cliente por dia. Além disse, trabalhamos muitas vezes nos sistemas enquanto são utilizados, ou seja, sempre estamos no risco, um código impróprio e podemos mudar tudo na base, então sempre que atualizamos um novo sistema fazemos backup da base também e os outros que normalmente fazemos ao longo do dia nos ajuda na detecção de erros e possíveis inconsistências nos dados.
Com o crescimento do número de clientes e os inúmeros eventos ocorrendo simultaneamente procuramos uma forma de fazer backup de forma rápida, eficiente e que fosse padronizada. Nas muitas pesquisas que fiz achei a uma rotina excelente do Fabio Berbet de Paula, fiz algumas interações no código para padronizá-las para nossa realidade e hoje qualquer profissional da TRIO tem um link para cada cliente, onde com a penas um clique fazemos o backup integral da base em um arquivo ZIP, perfeito e de forma íntegra. Tudo muito fácil e rápido. Veja o código com comentários e as interações que fiz.
Antes de mais nada agradeço ao Fabio Berbet o desenvolvimento do sistema. Para fazer o download do sistema e da classe clique aqui!.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
| <?
/*
Programa usado para fazer o dump de uma base de dados do MySQL
Por: Fabio Berbert de Paula <fabio@vivaolinux.com.br>
Rio de Janeiro, 26 de Novembro de 2002
link: http://www.vivaolinux.com.br/script/Backup-do-MySQL-via-PHP
Livres Adaptações: Plínio Cruz - Clube da Informática
- Inclusão de arquivo padrão de conexão com a base
- rotina "Lista de Tabelas"
- Padronização do nome do arquivo a ser gravado
*/
// classe phpzip.inc.php para criar os arquivos compactados
require 'phpzip.inc.php';
// variaveis de banco de dados de acordo com o arquivo padrão de conexão
$db_name = ''; //Nome do banco de dados
$hostdb = ''; //server do banco de dados
$userdb = ''; //Usuário de log do banco de dados
$passdb = ''; //senha do usuário do banco de dados
///////////////////////////////////////////////////////////////////////////////////////////////////
//Vamos montar a litas das tabelas do banco de dados escolhido
//Essa rotina foi incluída a original do Fábio, pois antes tínhamos que nomear as tabelas que
//queríamos guardar. Com a nova rotina ele faz o backup do banco como um todo, não precisando
//atualizar o sistema cada vez que você altera a base de dados
///////////////////////////////////////////////////////////////////////////////////////////////////
$nome = $db_name;
$link = mysql_connect("$hostdb","$userdb","$passdb");
$resultado_tabelas = mysql_list_tables($nome);
$qntd_tabelas = @mysql_numrows($resultado_tabelas);
if($qntd_tabelas == 0)
{
print "<li>Nenhuma tabela foi encontrada neste banco de bados</li>";
die;
//Assim "mato" o sistema quando existe um erro
} else {
//Aqui vamos criar a rotina para montar a listagem de tabelas
for ($i = 0; $i < $qntd_tabelas; $i++)
{
//Temos que determinar as tabelas que não precisam de backup
//no meu caso pode ser tabelas como crm, cep, cidade, estado, etc.
//No exemplo não faremos backup da "cep" e concatemos as restantes
if (mysql_tablename($resultado_tabelas, $i)!='cep')
{ $tabelas[]= mysql_tablename($resultado_tabelas, $i); };
};
//Temos a array de tabelas pronta
};
// as tabelas que quero
//$tabelas = array ('artigos','assuntos'); - Original da rotina do Fabio, onde você montava o array manualmente
//com as tabelas que desejava, a rotina acima faz automaticamente só isso
$tempdir = "/tmp"; // diretorio temporario
//$filename = 'sql.'.time().'.txt'; - Modo do Fabio de construir o nome do arquivo
$data = date("dmyhi",time());
$filename = 'nomedocliente.'.$data.'.txt';
//Inclui o nome do banco de dados no nome e a data completa
//Isso porque trabalho com phpmyadmin e MySqlFront e os dois trabalham com essa extensão
//o conteúdo é o mesmo, portanto não fará diferença na hora da gravação
//Na minha opinião facilita para aramazenamento de vários clientes na mesma pasta no servidor local
// variaveis do sistema
$incluir_insert = 1; // imprime os INSERT's tambem
// ----------------------------------------------------
// BLOCO PRINCIPAL
// conectar ao banco de dados
$con = mysql_pconnect($hostdb,$userdb,$passdb);
mysql_select_db($db_name);
// imprimir tipo do documento na tela
// imprimir o dump do banco de dados
//chdir($tempdir);
$fp = fopen($filename,"w");
for ($x=0; $x<count($tabelas); $x++) {
$saida = getTableDef($db_name, $tabelas[$x], "\n");
fputs($fp,$saida."\n\n");
if ($incluir_insert) {
getTableContentFast($db_name, $tabelas[$x], '', '');
fputs($fp,"\n\n");
}
}
fclose($fp);
// gerar o arquivo zipado
$zipname = ereg_replace("txt$","zip",$filename);
$zip = new PHPZip();
$files[]=$filename;
$zip -> Zip($files, $zipname);
$tamanho = filesize($zipname);
// imprimir arquivo p/ download
header("Content-Type: application/zip");
header("Content-Length: $tamanho");
header("Content-Disposition: attachment; filename=$zipname");
header("Content-Transfer-Encoding: binary");
// abrir e enviar o arquivo
$fp = fopen("$zipname", "r");
fpassthru($fp);
fclose($fp);
// remover os arquivos temporarios
//unlink($filename);
unlink($zipname);
// FIM DO PROGRAMA
// --------------------------------------------------------
// --------------------------------------------------------
// PROCEDIMENTOS - Baseado no csdigo do phpmyadmin
function sqlAddslashes($a_string = '', $is_like = FALSE) {
if ($is_like) {
$a_string = str_replace('\\', '\\\\\\\\', $a_string);
} else {
$a_string = str_replace('\\', '\\\\', $a_string);
}
$a_string = str_replace('\'', '\\\'', $a_string);
return $a_string;
} // end of the 'sqlAddslashes()' function
function backquote($a_name, $do_it = TRUE) {
if ($do_it && PMA_MYSQL_INT_VERSION >= 32306 && !empty($a_name)
&& $a_name != '*') {
if (is_array($a_name)) {
$result = array();
reset($a_name);
while(list($key, $val) = each($a_name)) {
$result[$key] = '`' . $val . '`';
}
return $result;
} else {
return '`' . $a_name . '`';
}
} else {
return $a_name;
}
} // end of the 'backquote()' function
/**
* Returns $table's CREATE definition
*
* @param string the database name
* @param string the table name
* @param string the end of line sequence
*
* @return string the CREATE statement on success
*
* @global boolean whether to add 'drop' statements or not
* @global boolean whether to use backquotes to allow the use of special
* characters in database, table and fields names or not
*
* @see PMA_htmlFormat()
*
* @access public
*/
function getTableDef($db, $table, $crlf) {
global $drop;
global $use_backquotes;
global $con;
$schema_create = '';
if (!empty($drop)) {
$schema_create .= 'DROP TABLE IF EXISTS ' .
backquote($table) . ';' . $crlf;
}
// For MySQL < 3.23.20
$schema_create .= 'CREATE TABLE ' .
backquote($table) . ' (' . $crlf;
$local_query = 'SHOW FIELDS FROM ' . backquote($table) . ' FROM '
. backquote($db);
$result = mysql_query($local_query,$con);
while ($row = mysql_fetch_array($result)) {
$schema_create .= ' ' .
backquote($row['Field'])
. ' ' . $row['Type'];
if (isset($row['Default']) && $row['Default'] != '') {
$schema_create .= ' DEFAULT \'' .
sqlAddslashes($row['Default']) . '\'';
}
if ($row['Null'] != 'YES') {
$schema_create .= ' NOT NULL';
}
if ($row['Extra'] != '') {
$schema_create .= ' ' . $row['Extra'];
}
$schema_create .= ',' . $crlf;
} // end while
mysql_free_result($result);
$schema_create = ereg_replace(',' . $crlf . '$', '', $schema_create);
$local_query = 'SHOW KEYS FROM ' . backquote($table) . ' FROM '
. backquote($db);
$result = mysql_query($local_query,$con);
while ($row = mysql_fetch_array($result)) {
$kname = $row['Key_name'];
$comment = (isset($row['Comment'])) ? $row['Comment'] : '';
$sub_part = (isset($row['Sub_part'])) ? $row['Sub_part'] : '';
if ($kname != 'PRIMARY' && $row['Non_unique'] == 0) {
$kname = "UNIQUE|$kname";
}
if ($comment == 'FULLTEXT') {
$kname = 'FULLTEXT|$kname';
}
if (!isset($index[$kname])) {
$index[$kname] = array();
}
if ($sub_part > 1) {
$index[$kname][] = backquote($row['Column_name']) . '(' . $sub_part . ')';
} else {
$index[$kname][] = backquote($row['Column_name']);
}
} // end while
mysql_free_result($result);
while (list($x, $columns) = @each($index)) {
$schema_create .= ',' . $crlf;
if ($x == 'PRIMARY') {
$schema_create .= ' PRIMARY KEY (';
} else if (substr($x, 0, 6) == 'UNIQUE') {
$schema_create .= ' UNIQUE ' . substr($x, 7) . ' (';
} else if (substr($x, 0, 8) == 'FULLTEXT') {
$schema_create .= ' FULLTEXT ' . substr($x, 9) . ' (';
} else {
$schema_create .= ' KEY ' . $x . ' (';
}
$schema_create .= implode($columns, ', ') . ')';
} // end while
$schema_create .= $crlf . ');';
return $schema_create;
} // end of the 'getTableDef()' function
/**
* php >= 4.0.5 only : get the content of $table as a series of INSERT
* statements.
* After every row, a custom callback function $handler gets called.
*
* Last revision 13 July 2001: Patch for limiting dump size from
* vinay@sanisoft.com & girish@sanisoft.com
*
* @param string the current database name
* @param string the current table name
* @param string the 'limit' clause to use with the sql query
* @param string the name of the handler (function) to use at the end
* of every row. This handler must accept one parameter
* ($sql_insert)
*
* @return boolean always true
*
* @global boolean whether to use backquotes to allow the use of special
* characters in database, table and fields names or not
* @global integer the number of records
* @global integer the current record position
*
* @access private
*
* @see PMA_getTableContent()
*
* @author staybyte
*/
function getTableContentFast($db, $table, $add_query = '', $handler) {
global $use_backquotes;
global $rows_cnt;
global $current_row;
global $con;
global $fp;
$local_query = 'SELECT * FROM ' . backquote($db) . '.' . backquote($table)
. $add_query;
$result = mysql_query($local_query,$con);
if ($result != FALSE) {
$fields_cnt = mysql_num_fields($result);
$rows_cnt = mysql_num_rows($result);
// Checks whether the field is an integer or not
for ($j = 0; $j < $fields_cnt; $j++) {
$field_set[$j] = backquote(mysql_field_name($result, $j), $use_backquotes);
$type = mysql_field_type($result, $j);
if ($type == 'tinyint' || $type == 'smallint' ||
$type == 'mediumint' || $type == 'int' ||
$type == 'bigint' ||$type == 'timestamp') {
$field_num[$j] = TRUE;
} else {
$field_num[$j] = FALSE;
}
} // end for
// Sets the scheme
if (isset($GLOBALS['showcolumns'])) {
$fields = implode(', ', $field_set);
$schema_insert = 'INSERT INTO ' . backquote($table)
. ' (' . $fields . ') VALUES (';
} else {
$schema_insert = 'INSERT INTO ' .
backquote($table) . ' VALUES (';
}
$search = array("\x00", "\x0a", "\x0d", "\x1a"); //\x08\\x09, not required
$replace = array('\0', '\n', '\r', '\Z');
$current_row = 0;
@set_time_limit($GLOBALS['cfg']['ExecTimeLimit']);
// loic1: send a fake header to bypass browser timeout if data
// are bufferized - part 1
if (!empty($GLOBALS['ob_mode']) || (isset($GLOBALS['zip'])
|| isset($GLOBALS['bzip']) || isset($GLOBALS['gzip']))) {
$time0 = time();
}
while ($row = mysql_fetch_row($result)) {
$current_row++;
for ($j = 0; $j < $fields_cnt; $j++) {
if (!isset($row[$j])) {
$values[] = 'NULL';
} else if ($row[$j] == '0' || $row[$j] != '') {
// a number
if ($field_num[$j]) {
$values[] = $row[$j];
} else {
// a string
$values[] = "'" . str_replace($search, $replace,
sqlAddslashes($row[$j])) . "'";
}
} else {
$values[] = "''";
} // end if
} // end for
// Extended inserts case
if (isset($GLOBALS['extended_ins'])) {
if ($current_row == 1) {
$insert_line = $schema_insert . implode(', ', $values) . ');';
} else {
$insert_line = '(' . implode(', ', $values) . ');';
}
} else {
// Other inserts case
$insert_line = $schema_insert . implode(', ', $values) . ');';
}
unset($values);
// Call the handler
fputs($fp,$insert_line . "\n");
// loic1: send a fake header to bypass browser timeout if data
// are bufferized - part 2
if (isset($time0)) {
$time1 = time();
if ($time1 >= $time0 + 30) {
$time0 = $time1;
header('X-pmaPing: Pong');
}
} // end if
} // end while
} // end if ($result != FALSE)
mysql_free_result($result);
return TRUE;
} // end of the 'getTableContentFast()' function
?> |
Loading ...
Postado por Plinio Cruz em 27 de outubro de 2009 - Banco de Dados, Delphi, Downloads, Programação | Seja o primeiro a comentar
Jackson Pires, o colaborador dos tutoriais mais completos de Delphi do Clube da Informática, volta a presentear nossos visitantes com um curso completo para desenvolvimento de um projeto de Locação de Fitas de Vídeo.
O arquivo PDF é ricamente recheado de imagens e muito bem detalhado. Serve de guia não só para a sua aplicação primária, mas como consulta para qualquer sistema de gerenciamento de banco de dados, pois trata das principais ferramentas necessárias para um sistema de gestão de dados.
O nível de detalhamento que leva o leitor do momento de criação das pastas, passando pela criação de menus e tabelas até chegar ao ponto de finalização do projeto e os relatórios.
Obrigado Jackson pela colaboração!
Loading ...
Postado por Plinio Cruz em 13 de agosto de 2009 - PHP, Programação | Leia o primeiro comentário
Verificando se o número é PAR ou IMPAR
<?php
function verNumero($numero)
{ // Verificando o resto da divisão por 2
if($numero % 2 == 0)
{ // Se o resto for igual a zero é par
return "PAR";
}
else
{ // Caso não seja zero é impar
return "IMPAR";
}
}
$n = 654646570;
// Chamando a função e passando o parametro
echo verNumero($n);
?>
Trabalhando com potênciação
<?php
function calcula_potencia($base,$expoente){
$nuns = $base;
// For de 1 até o valor do expoente
for($c = 1;$c < $expoente;$c++){
$nuns = $nuns * $base;
}
$verifica = explode("E",$nuns);
if(count($verifica) > 1) {
$nuns = "Expoente muito elevado.";
}
return $nuns ;
}
// Chamando a função passando base 7 e expoente 2
$potenciacao = calcula_potencia(7,2);
// Imprimindo na tela o resultado
echo $potenciacao;
?>
Verificando se um número é primo
<?php
$num = 1234567891;
if(nPrimo($num))
{
echo "$num é primo.";
}
else
{
echo "$num não é primo.";
}
function nPrimo($numero)
{ //com $numero > 2
$p = 2 ;
while($numero % $p != 0 && $p < sqrt($numero) ) $p+=1 ;
// 1 = Primo / 0 = ñ Primo
return ($numero%$p==0) ? 0 : 1 ;
}
?>
Trabalhando com Fatoração
<?php
$num = 123456789;
$resposta = fatorarando($num);
echo "Seus fatores: ";
foreach($resposta as $aux) echo "$aux ";
function fatorarando($numero)
{
// $numero > 2
$x=2 ;
while($numero != 1)
{
if($numero % $x == 0)
{ // Vetor recebendo a variavel $x
$vet[] = $x;
$numero = $numero/$x;
}
else
{
$x++;
}
}
return $vet;
}
?>
Formatando moeda
<?php
// Recebe o parametro $numero
// Existe outra maneira muito mais fácil
// Mas o objetivo e trabalhar seus conhecimentos
function formata($numero)
{
if(strpos($numero,'.')!='')
{
$var=explode('.',$numero);
if(strlen($var[0])==4)
{
$parte1=substr($var[0],0,1);
$parte2=substr($var[0],1,3);
if(strlen($var[1])<2)
{
$formatado=$parte1.'.'.$parte2.','.$var[1].'0';
}else
{
$formatado=$parte1.'.'.$parte2.','.$var[1];
}
}
elseif(strlen($var[0])==5)
{
$parte1=substr($var[0],0,2);
$parte2=substr($var[0],2,3);
if(strlen($var[1])<2)
{
$formatado=$parte1.'.'.$parte2.','.$var[1].'0';
}
else
{
$formatado=$parte1.'.'.$parte2.','.$var[1];
}
}
elseif(strlen($var[0])==6)
{
$parte1=substr($var[0],0,3);
$parte2=substr($var[0],3,3);
if(strlen($var[1])<2)
{
$formatado=$parte1.'.'.$parte2.','.$var[1].'0';
}
else
{
$formatado=$parte1.'.'.$parte2.','.$var[1];
}
}
elseif(strlen($var[0])==7)
{
$parte1=substr($var[0],0,1);
$parte2=substr($var[0],1,3);
$parte3=substr($var[0],4,3);
if(strlen($var[1])<2)
{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.$var[1].'0';
}
else
{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.$var[1];
}
}
elseif(strlen($var[0])==8)
{
$parte1=substr($var[0],0,2);
$parte2=substr($var[0],2,3);
$parte3=substr($var[0],5,3);
if(strlen($var[1])<2){
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.$var[1].'0';
}else{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.$var[1];
}
}
elseif(strlen($var[0])==9)
{
$parte1=substr($var[0],0,3);
$parte2=substr($var[0],3,3);
$parte3=substr($var[0],6,3);
if(strlen($var[1])<2)
{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.$var[1].'0';
}
else
{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.$var[1];
}
}
elseif(strlen($var[0])==10)
{
$parte1=substr($var[0],0,1);
$parte2=substr($var[0],1,3);
$parte3=substr($var[0],4,3);
$parte4=substr($var[0],7,3);
if(strlen($var[1])<2)
{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.'.'.$parte4.','.$var[1].'0';
}
else
{
$formatado=$parte1.'.'.$parte2.'.'.$parte3.'.'.$parte4.','.$var[1];
}
}
else
{
if(strlen($var[1])<2)
{
$formatado=$var[0].','.$var[1].'0';
}
else
{
$formatado=$var[0].','.$var[1];
}
}
}
else
{
$var=$numero;
if(strlen($var)==4)
{
$parte1=substr($var,0,1);
$parte2=substr($var,1,3);
$formatado=$parte1.'.'.$parte2.','.'00';
}
elseif(strlen($var)==5)
{
$parte1=substr($var,0,2);
$parte2=substr($var,2,3);
$formatado=$parte1.'.'.$parte2.','.'00';
}
elseif(strlen($var)==6)
{
$parte1=substr($var,0,3);
$parte2=substr($var,3,3);
$formatado=$parte1.'.'.$parte2.','.'00';
}
elseif(strlen($var)==7)
{
$parte1=substr($var,0,1);
$parte2=substr($var,1,3);
$parte3=substr($var,4,3);
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.'00';
}
elseif(strlen($var)==8)
{
$parte1=substr($var,0,2);
$parte2=substr($var,2,3);
$parte3=substr($var,5,3);
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.'00';
}
elseif(strlen($var)==9)
{
$parte1=substr($var,0,3);
$parte2=substr($var,3,3);
$parte3=substr($var,6,3);
$formatado=$parte1.'.'.$parte2.'.'.$parte3.','.'00';
}
elseif(strlen($var)==10)
{
$parte1=substr($var,0,1);
$parte2=substr($var,1,3);
$parte3=substr($var,4,3);
$parte4=substr($var,7,3);
$formatado=$parte1.'.'.$parte2.'.'.$parte3.'.'.$parte4.','.'00';
}
else
{
$formatado=$var.','.'00';
}
}
return $formatado." Reais";
}
$num = 1234567890;
echo formata($num);
?>Formatação para número inteiro
<?php
// Formatação para numero inteiro
$number = "1234567890000000";
$number=number_format($number,0,'.','.');
echo $number;
// resultado 1.234.567.890.000.000
?>
Formatação para número monetário
<?php
// Formatação para numero monetário
$number = "1234567890000000";
$number=number_format($number,2,',','.');
echo $number;
// resultado 1.234.567.890.000.000,00
?>
Formatação para número inteiro com espaçamento a cada 3 casas
<?php
// Formatação para numero inteiro com espaçamento a cada 3 casas
$number = "1234567890000000";
$number=number_format($number,0,'.',chr(0xA0));
echo $number;
// resultado 1 234 567 890 000 000
?>
Formatação para número em reais com decimal 99
<?php
// Formatação para numero em reais com decimal 99
$number = "2229346.99";
echo "R$" .number_format($number, 2, ',', '.');
// resultado R$2.229.346,99
?>
Formatação para número em reais com decimal 00
<?php
// Formatação para número em reais com decimal 00
$number = "222934699";
echo "R$" .number_format($number, 2, ',', '.');
// resultado R$222.934.699,00
?>
Formatação para número em reais sem decimal
<?php
// Formatação para número em reais sem decimal
$number = "222934699";
echo "R$" .number_format($number, 0, ',', '.');
// resultado R$222.934.699
?>
Formatação para número colocando virgula a cada 3 casas
<?php
// Colocando virgula a cada 3 casas
// Recebendo o valor por parametro
function formatar($input)
{
if(strlen($input)<=3)
{ return $input; }
$length=substr($input,0,strlen($input)-3);
$formatted_input = formatar($length).",".substr($input,-3);
return $formatted_input;
}
// numero a ser passado por parametro
$num = 1234567;
// imprimindo o valor
echo formatar($num);
// resultado 1,234,567
?>
Formatação para número colocando ponto a cada 3 casas
<?php
// Colocando ponto a cada 3 casas
// Recebendo o valor por parametro
function formatando($input)
{
if(strlen($input)<=3)
{ return $input; }
$length=substr($input,0,strlen($input)-3);
$formatted_input = formatando($length).".".substr($input,-3);
return $formatted_input;
}
// numero a ser passado por parametro
$num = 1234567;
// imprimindo o valor
echo formatando($num);
// resultado 1.234.567
?>
Por:
Carlos Silva
Desenvolvedor web, certificado ISPA CYCLADES e Macromedia. Desenvolvedor usando as tecnologias C#, JSP, PHP, JavaScript, XML, ABAP, Tableless e outros. Certificado em Segurança da Informação e atualmente trabalhando com ativos de Rede Cisco.
Em: Revista PHP
Loading ...
Postado por Plinio Cruz em 11 de julho de 2009 - PHP, Programação, Soluções | 3 Comentário para ler
Um dos artigos mais lidos do Clube da Informática é sobre o algortimo de validação do CPF, temos aqui no escritório essa validação em formato de função, utilizamos muito, temos em Java Script para os sistemas web e em formato de procedimento para Pascal, quando utilizamos o Delphi.
Estamos com um dos nossos clientes do Hermes que necessita fazer um formulário para colher inscrições para seu próximo evento dentro do hotsite do seu cliente, o problema é que estamos falando de uma das maiores empresa de assistência médica do país, que utiliza servidores próprios com programação de área restrita em seu site, busca e inúmeras ferramentas.
Para criar o menor impacto possível e agilizar o processo, nossa proposta foi a seguinte: vamos fazer todo o processo de inscrição (quatro telas) em um só arquivo de PHP, utilizando o banco de dados do nosso servidor e ainda, só utlizando o mais puro PHP, sem java script, sem AJAX, sem framework, sem nada que pudesse rivalizar ou incompatibilizar ferramentas do cliente ou as nossas próprias, ou ainda que necessitasse interação com o servidor para instalação, sendo assim enviaremos o arquivo para a empresa testado e pronto para colocação no hotsite do evento
Uma das rotinas que precisamos é de validação do CPF, que antes usamos em Java Script para poupar tempo e processos pela Internet, uma validação em JS dentro do site, quando acionado o botão de enviar a validação ocorre sem enviar os dados, ou seja, é mais rápido. No caso proposto vamos utilizar só PHP e uma única vez em cada inscrição realizada haverá validação, então deixamos de lado a função e incomporamos de forma bem enxuta a rotina.
Estamos tratando os dados na fonte, mesmo com o aviso de entrar só números, normalmente o usuários não prestam muito atenção nas instruções e já que vamos ter que “enviar” os dados por post e fazer a validação para retornar o resultado, vamos optar por tratar os dados, vamos fazer uma rotina para retirar sinais e espaços em branco da entrada, para evitar erros na validação e obrigar o usuário a verificar e reenviar os dados, o que aumentaria o processo e o número de vezes a interação com o trânsito de dados na internet.
$sinais= array("/"," ",".","-",",");
$cpf=str_replace($sinais,"",$_POST['cpf']);Após a verificação vamos aplicar de forma matemática e direto a validação do algoritmo do processo do artigo já apresentado aqui no site. Confira o código:
///////////////////////////////////////
//Valida o CPF - Algoritmo do Clube
///////////////////////////////////////
$cpf_validar=substr($cpf,0,9);
$soma=0; $n=11;
for ($i=0;$i<=9;$i++)
{
$n=$n-1;
$soma=$soma+(substr($cpf_validar,$i,1)*$n);
};
$resto= $soma % 11;
if ($resto<2) {$cpf_validar=$cpf_validar."0";} else {$cpf_validar=$cpf_validar.(11-$resto);};
//Segunda parte da validação do CPF
$soma=0; $n=12;
for ($i=0;$i<=10;$i++)
{
$n=$n-1;
$soma=$soma+(substr($cpf_validar,$i,1)*$n);
};
$resto= $soma % 11;
if ($resto<2) {$cpf_validar=$cpf_validar."0";} else {$cpf_validar=$cpf_validar.(11-$resto);}
if ($cpf_validar==$cpf) {$erro=1;} else {$erro=0;$mensagens="CPF Inválido";};As únicas obserrvações é que criamos um flag para o erro, ou seja, quando recebe “1″ está ok, caso contrário recebe “0″ e cria uma variável com a mensagem de erro. Espero que a rotina ajude a entender melhor o artigo e vice e versa. Qualquer dúvida escreva!
abraço
Plínio Cruz
Loading ...
Postado por Plinio Cruz em 25 de junho de 2009 - Aplicativos, Programação | Seja o primeiro a comentar
A Adobe anuncia mais avanços para a plataforma Adobe Flash colocando à disposição dos usuários a versão beta do Adobe Flash Builer 4 (formalmente chamado Adobe Flex Builder), do Adobe Flash Catalyst e da estrutura aberta da fonte Flex 4.
O Adobe Flash Builder é uma ferramenta profissional de desenvolvimento desenhada para ajudar desenvolvedores de software a rapiamente construírem aplicações ricas de Internet (RIAs). O Adobe Flash Catalyst é uma nova ferramenta de design profissional de interação que rapidamente cria aplicações de interface ntre usuários sem codificação. As ferramentas oferecem um fluxo de trabalho integrado e são baseadas na nova estrutura Flex 4 (Flash Builder), em uma fonte de estrutura aberta para a construção de RIAs que colaborarão para que os desenvolvedores e designers elaborem ses projetos com mais facilidade.
Os betas públicos desses produtos estão disponíveis para download no Adobe Labs pelo site. “As pessoas agora experimentarão aplicações mais ricas e se sentirão à vontade para usar as mesmas aplicações no seu ambiente detrabalho que utilizam em suas experiências diárias na web. Hoje, as companhias estão diante de vários recursos de desenvolvimento e menos tempo para criar aplicações intuitivas”, disse David Wadhwani, gerente geral e vice‐presidente da unidade Platform Business da Adobe. “As novas ferramentas da plataforma Adobe Flash ajudam a resolver este desafio de reduzir tempo de mercado e gerar envolventes alicações e conteúdo. Usando o Adobe Flash Builder e o Flash Catalyst, desenvolvedores e designers podem agora trabalhar juntos mais produtivamente para criarem ricas experiências que seus empregads, clientes e parceiros esperam.”
O Adobe Flash Builder 4 é baseado na fonte aberta da estrutura Flex e vem com um poderoso conjunto de novas funcionalidades par simplificar o desenvolvimento RIA. Antes conhecido como Adobe Flex Buider, o novo IDE melhora a funcionalidade básica, acrescenta novos dados centrais desenvolvendo funcionalidades e simplificando o design do workflow.
Novos desenvolvimentos de dados centrais de funcionalidades permitem aos programadores incluírem serviços e utilizarem um simpes arrastar e largar para aproximar rapidamente e vincular métodos para componentes de interface de quem utiliza, tais como mapas interativos, gráficos e dados de grade. Essas características tornam mais fácil a quebra de informações e integrar negócios a partir de base de dados e serviços web e diferentes organizações. Como resultado, as companhias podem construir aplicações de centros de usuários para painéis, e‐commerce e portais web de auto‐serviço que simplificam os processos empresariais para seus empregados, clientes e parceiros.
“Com a chegada da ‘geração digital’ nos locais de trabalho, profissionais esperam uma nova aproximação com a empresa e querem consumir aplicações de negócios como eles fazem com outras frramentas na Internet”, disse Herve Couturier, vice‐presidente executivo de P&D NetWeaver e Business Objects da SAP. “A adoção da plataforma Adobe Flash, particularmente com o uso do Adobe Flash Builder, tem ajudado a SAP a criar até mesmo uma melhor interface com os usuários e com o conteúdo interativo para nossas aplicações depróxima geração, como o nosso SAP Business Objects Explorer”. “Os componentes UI do Adobe Flash Builder entregam muito valor para desenvolvedores. Para mim, a ampla gama de componentes me permite rapidamente construir ferramentas e aplicações com menos ou nenhuma vantagem de suportede desenho e muito menos programação”, disse Andréas Heim, diretor de tecnologia da Smashing Ideas, Inc.
“Como resultado disso, eu posso criar versões interativas de RIAs até mais rapidamente e nós podemos diminuir os ciclos de produção.” Mesmo fundamento para desenho e desenvolvimento Também foi anunciado o mais novo release aberto da estrutura Flex que provê um fundamento comum para desenvolvedores e designer criarem experiências envolventes para o usuário que roda na plataforma Adobe Flash. O update da estrutura Flex facilita a produtividade e consistência, permitindo aos desenvolvedores importarem funcionalidades UI criadas por designers que utilizam o Adobe Flash Catalyst, completando o requerimento lógico enquanto preserva o desenho e layout da experiência do usuário. Rápido desenho e desenvolvimento.
O Adobe Flash Catalyst, a nova ferramenta da plataforma Adobe Flash, melhora a interação de desenvolvimento do design. Isto permite aos desenvolvedores transformarem a arte‐final criada no software Adobe Photoshop ou Adobe Illustrator dentro das interfaces do usuário, que pode então ser utilizadas diretamente pelos desenvolvedores para completar a aplicação ou lugar. Isto melhora o workflow permitindo aos designers manterem o controle da experiência do usuário enquanto desenvolvedores podem ermanecer focados em aplicações lógicas importantes para o fluxo.
O Adobe Flash Catalyst leva os designers demonstrarem e interagirem nas interfaces funcionais dos usuários de aplicações em um stágio anterior, assegurando retornos mais rápidos para o desenvolvimento. O arquivo do projeto é então provido para o desenvolvedor adicionar funcionalidades e integrá‐lo com servidores e serviços usando o Adobe Flash Builder. Adicionalmente, usando o Adobe Flash Catalyst, desenvolvedores podem publicar arquivos fechados no formato SWF para exposição em um navegador web. A ida e volta ao editar ferramentas no Adobe Creative Suíte permite aos desenvolvedores alterarem partes estruturadas do projto a qualquer hora, aumentando a produtividade e mantendo o movimento do processo do projeto.
