Logica Programacao Php Joomla

Sumário
Capítulo 1. Introdução a Lógica de Programação...................................................................9
1.1. Noções de Lógica.........................................................................................................9
1.2. O que é lógica.............................................................................................................9
1.3. A real lógica do dia a dia.............................................................................................9
1.4. Lógica de programação.............................................................................................10
1.5. O que é um algoritmo...............................................................................................11
1.6. Porque é importante construir um algoritmo............................................................11
1.7. As maneiras de representarmos um algoritmo. ........................................................12
1.7.1. Descrição Narrativa.   ........................................................................................12
1.7.2. Fluxograma Convencional.................................................................................12
1.7.3. Português Estruturado ou Pseudocódigo............................................................14
1.8. EXERCÍCIOS PROPOSTOS  ......................................................................................15
Capítulo 2. Tópicos Preliminares..........................................................................................16
2.1. Tipos primitivos.........................................................................................................16
2.1.1.   Tipos de Primitivos de Dados...........................................................................16
2.2. Constantes.................................................................................................................16
2.3. Variável......................................................................................................................17
2.4. Formação de identificadores.....................................................................................17
2.5. Declaração de variáveis.............................................................................................17
2.6. Comandos de entrada e saída...................................................................................18
2.6.1. COMANDO DE ENTRADAS DE DADOS.............................................................18
2.6.2. COMANDO DE SAIDAS DE DADOS...................................................................19
2.7. Expressões aritméticas..............................................................................................20
2.8. Operadores aritméticos.............................................................................................21
2.9. Expressões lógicas.....................................................................................................22
2.10. Operadores relacionais............................................................................................22
2.11. Operadores lógicos..................................................................................................23
2.12. Comando de atribuição...........................................................................................24
2.12.1. PRIORIDADE DE OPERADORES:.....................................................................24
2.13. EXERCÍCIOS PROPOSTOS  ....................................................................................25
Capítulo 3. Estruturas de Controle.......................................................................................26
3.1. Estrutura sequencial..................................................................................................26
3.2. Estrutura de seleção..................................................................................................27
3.2.1. Seleção Simples.................................................................................................27
3.2.2. Seleção Composta..............................................................................................29
3.2.3. Seleção encadeada.............................................................................................30
3.3. Seleção de múltipla escolha......................................................................................32
3.4. Estruturas de repetição.............................................................................................33
3.5. Repetição com teste no início e no final....................................................................34
3.5.1. TESTE INÍCIO....................................................................................................34
3.5.2. TESTE FINAL.....................................................................................................35
3.6. Repetição com variável de controle...........................................................................37
3.7. Comparação entre estruturas de repetição.   ............................................................39
Capítulo 4. Estruturas de Dados...........................................................................................42
4.1. O que é estruturas de dados......................................................................................42
4.2. Variáveis compostas homogêneas..............................................................................42

4.3. Variáveis compostas unidimensionais........................................................................43
4.4. Declaração e manipulação(unidimensional).............................................................44
4.4.1. Leitura de Dados de Uma Matriz do Tipo Vetor.................................................44
4.5. Variáveis compostas multidimensionais....................................................................45
4.6. Declaração e manipulação(multidimensionais ).......................................................46
4.7. Variáveis compostas heterogêneas............................................................................46
4.8. Registros (declaração e manipulação).......................................................................47
4.9. Registros de conjuntos (declaração e manipulação).   .............................................48
4.11. Referencias:.............................................................................................................50
Capítulo 5. Introdução a PHP...............................................................................................53
5.1. O que é PHP..............................................................................................................53
5.1.1. Um pouco da História do PHP............................................................................54
5.2. Instalação do Servidor PHP.......................................................................................54
5.2.1. Instalação Apache..............................................................................................55
5.2.2. Instalação Php5..................................................................................................56
5.2.3. Instalação MYSQL..............................................................................................57
5.2.4. Instalação phpMyAdmin....................................................................................57
5.3. Características de um programa PHP.........................................................................58
5.3.1. COMANDOS DE SAÍDA(OUTPUT).....................................................................59
Capítulo 6. Atribuições em PHP............................................................................................61
6.1. Variáveis....................................................................................................................61
6.2. Tipos de Variáveis......................................................................................................63
6.2.1. Tipo booleano....................................................................................................63
6.2.2. Tipo inteiro........................................................................................................63
6.2.3. Tipo ponto flutuante:.........................................................................................64
6.2.4. Tipo numérico....................................................................................................64
6.2.5. Tipo String.........................................................................................................64
6.2.6. Tipo array..........................................................................................................65
6.2.7. Tipo objeto.........................................................................................................65
6.2.8. Tipo recurso.......................................................................................................65
6.2.9. Tipo null.............................................................................................................65
6.3. Constantes.................................................................................................................65
6.3.1. Constantes prédefinidas....................................................................................65
6.3.2. Definindo constantes.........................................................................................65
6.4. Conversão de variável...............................................................................................66
Capítulo 7. Operadores.........................................................................................................68
7.1. Operadores de strings...............................................................................................68
7.2. Operadores de atribuição..........................................................................................68
7.3. Operadores de decremento e incremento.................................................................70
7.4. Operadores aritméticos.............................................................................................71
7.5. Operadores relacionais .............................................................................................71
7.6. Operadores lógicos ou booleanos..............................................................................72
7.7. Precedência de Operadores.......................................................................................73
Capítulo 8. Estruturas de Controle e Repetição....................................................................77
8.1. Blocos de controle.....................................................................................................77
8.2. IF e ELSE...................................................................................................................77

8.3. Atribuição condicional (ternário)..............................................................................79
8.4. SWITCH....................................................................................................................79
8.4.1. SWITCH com BREAK.........................................................................................80
8.5. WHILE.......................................................................................................................81
8.6. DO...WHILE...............................................................................................................82
8.7. FOR...........................................................................................................................83
8.8. FOREACH..................................................................................................................84
8.9. BREAK.......................................................................................................................85
8.10. CONTINUE..............................................................................................................86
Capítulo 9. Manipulação de Arrays......................................................................................88
9.1. Criando um Array......................................................................................................88
9.2. Arrays Associativos....................................................................................................89
9.3. Interações..................................................................................................................90
9.4. Acessando um Array..................................................................................................91
9.5. Alterando um Array...................................................................................................91
9.6. Arrays multidimensionais..........................................................................................92
9.7. Funções com Arrays..................................................................................................94
Capítulo 10. Manipulações de Funções................................................................................99
10.1. Declarando uma Função.........................................................................................99
10.2. Escopo de Variáveis em Funções...........................................................................100
10.3. Passagem de Parâmetro.........................................................................................101
10.4. Valor de Retorno....................................................................................................102
10.5. Recursão................................................................................................................102
10.6. EXERCÍCIOS PROPOSTOS  ..................................................................................103
Capítulo 11. Manipulação de arquivos e diretórios............................................................104
11.1. Criando e Abrindo um Arquivo.............................................................................104
11.2. Gravando em um arquivo......................................................................................105
11.3. Fechando um arquivo............................................................................................106
11.4. Lendo um arquivo.................................................................................................106
11.5. Copiando,Renomeando e Apagando um Arquivo..................................................107
11.6. Manipulando Diretório..........................................................................................108
Capítulo 12. Interações PHP com HTML............................................................................110
12.1. Formulários ..........................................................................................................110
Elementos de um formulário......................................................................................110
12.2. Exemplo de formulário..........................................................................................112
12.3. Método Post e Get.................................................................................................114
12.3.1. Método Get....................................................................................................114
Recebendo dados via método GET.............................................................................115
12.3.2. Método Post...................................................................................................116
12.4. Interações com o Browser.....................................................................................117
12.5. Cookies..................................................................................................................118
Acessando um cookie:................................................................................................120
12.6. Sessão....................................................................................................................120
12.7. Requisição de Arquivos.........................................................................................122
12.8. Tratamentos de erro..............................................................................................123
Capítulo 13. Introdução ao MySQL....................................................................................125

13.1. O que é o MYSQL?................................................................................................125
13.2. Trabalhando com MYSQL......................................................................................125
13.2.1. Estruturas de Dados.......................................................................................126
13.2.2. Criando Banco e Tabelas................................................................................127
13.2.3. Manipulando dados das tabelas.....................................................................128
13.3. Trabalhando com PhpMyAdmin............................................................................130
13.3.1. Manipulando banco de dados no PhpMyadmin.............................................131
Capítulo 14. PHP com Banco de dados MYSQL..................................................................135
14.1. Criando e Selecionando a Conexão.......................................................................135
14.2. Manipulando Dados do Database..........................................................................136
mysql_query...............................................................................................................136
mysql_result...............................................................................................................136
mysql_fetch_array......................................................................................................137
14.3. Criação de CRUD...................................................................................................138
Capítulo 15. História do Joomla.........................................................................................144
15.1. Introdução.............................................................................................................144
15.2. Vantagens de utilizar o Joomla!............................................................................144
15.3. O Joomla tem como principais características:.....................................................145
15.4. Ferramentas CMS – Sistema de Gerenciamento de Conteúdo...............................145
Capítulo 16. Instalação do Joomla.....................................................................................146
16.1. Iniciando os Servidores.........................................................................................147
16.1.1. Passos para instalação do Joomla..................................................................147
16.1.2. Copiando o Joomla para a Pasta HTDOCS.....................................................147
Capítulo 17. Vamos a Instalação.........................................................................................148
17.1. 1º Passo Idiomas.................................................................................................148
17.2. 2º Passo – PréInstalação.......................................................................................149
17.3. 3º Passo Licença..................................................................................................149
17.4. 4º Passo – Banco de Dados....................................................................................150
17.5. 5º Passo – Configuração do FTP............................................................................151
17.6. 6º Passo Configuração.........................................................................................151
17.7. 7º Passo Fim........................................................................................................152
Capítulo 18. Frontend e Backend.......................................................................................153
18.1. Frontend – Área de Usuários.................................................................................153
18.2. Backend – Área de Administradores.....................................................................154
18.2.1. Login de Acesso.............................................................................................154
18.2.2. Nível de usuário – Papel ................................................................................155
18.2.3. Papéis no Site principal (Frontend)...............................................................155
18.2.4. Papeis na Área de administração (BackEnd).................................................155
Capítulo 19. Conhecendo a Área de Administração...........................................................155
19.1. Acessos..................................................................................................................155
19.2. Registrando os usuários........................................................................................156
19.3. Categorias de Usuários Registrados......................................................................156
19.4. Usuários Responsáveis pelo Conteúdo..................................................................156
19.4.1. Usuário Registrado.........................................................................................156
19.4.2. Autor..............................................................................................................156
19.4.3. Editor.............................................................................................................156
19.4.4. Publicador (publisher)...................................................................................156
19.5. Usuários de Administração....................................................................................157

19.5.1. Super Administrador......................................................................................157
19.5.2. Administrador................................................................................................157
19.5.3. Gerenciador (Manager).................................................................................157
Capítulo 20. Gerenciando as Categorias e Seções..............................................................157
20.1. Como criar uma Seção..........................................................................................158
20.2. Como criar uma categoria.....................................................................................159
Capítulo 21. Inserindo um Novo Texto...............................................................................159
21.1. Para inserir um texto, siga os seguintes passos:....................................................159
Capítulo 22. Como criar um link no menu para um item de conteúdo..............................160
22.1. Criando um link para o item de conteúdo.............................................................160
22.2. Administração dos menus.....................................................................................162
22.2.1. Tela de configuração de menus......................................................................162
22.3. Especificação de Alguns Itens de Menu.................................................................163
22.3.1. Conteúdo.......................................................................................................163
22.3.2. Miscellaneous................................................................................................163
22.3.3. Componentes .............................................................................................163
22.3.4. Links ...........................................................................................................163
Capítulo 23. Administração de Mídia.................................................................................163
23.1. Observando a imagem acima, teremos os seguintes tópicos:................................164
23.1.1. Primeiro tópico..............................................................................................164
23.1.2. Segundo tópico..............................................................................................164
23.1.3. Terceiro tópico...............................................................................................164
23.1.4. Quarto tópico.................................................................................................164
23.1.5. Quinto tópico.................................................................................................164
23.1.6. Sexto tópico...................................................................................................164
Capítulo 24. Conhecendo alguns componentes..................................................................164
24.1. Componente Weblinks...........................................................................................164
24.2. Componente Contatos...........................................................................................165
24.3. Componente Banner..............................................................................................167
Capítulo 25. Módulos e Componentes................................................................................168
25.1. Criando um módulo utilizando o próprio Joomla.................................................169
25.1.1. Veja os pontos necessários para criação de um módulo:................................169
25.2. Instalação de Módulos..........................................................................................170
25.2.1. Passos para instalar um novo módulo:...........................................................170
25.3. Componentes........................................................................................................170
Capítulo 26. Estrutura........................................................................................................171
26.1. Designer................................................................................................................171
26.2. Programação.........................................................................................................171
26.3. Conteúdo MySQL..................................................................................................171
26.4. Posições de Módulos.............................................................................................172
26.4.1. Vejamos exemplo no Código PHP:.................................................................172
26.4.2. Vejamos agora o exemplo no Painel de Administração (BackEnd)................172
26.5. Estendendo a Estrutura do Template (Tema)........................................................172
26.5.1. Você pode usar os seguintes atributos para os módulos:...............................172

Caro Aluno(a),
Este Material foi criado com o objetivo de ser utilizado na aprendizagem da lógica voltada
para programação, onde será utilizado a programação estruturada em português, também
chamada de português estruturado ou Portugol. Para auxílio na aprendizagem usaremos a
ferramenta (programa) chamada Visualg.
Será dividido o conteúdo em quatro capítulos, desde princípios básicos até algo mais
avançado dentro de um contexto lógico, e que traz ao aluno uma base inicial para futuras
programações em outras linguagens. As diagramações desse material foram feitas com o uso
da ferramenta Dia, porém não entraremos em detalhes sobre ela.
Vale ressaltar que o conteúdo aqui visto, devido a limitação da ferramenta Visualg, não tem
aparo completo de seu uso dentro da ferramenta, mas será tratado de forma coerente todos os
conceitos que serão abordados.
Esperamos que esse material seja um contribuinte para todos aqueles que querem aprender
de forma dedicada e que principalmente tenha um significado importante para inicialização da
formação dos que querem seguir a carreira de programador.

Logica de Programação 9
Capítulo 1. Introdução a Lógica de Programação
Objetivos
  Apresentar os conceitos elementares de lógica e sua aplicação no cotidiano; Definir o que é um
algoritmo; Estabelecer uma relação entre a lógica e o algoritmo; Mostrar exemplos de como utilizar a
lógica em situações do dia a dia, apresentando de forma simples e coerente.
1.1. Noções de Lógica
Lógica é algo muito comum na nossa vida, a prova disso é o que fazemos durante o dia, pois
mesmo sem perceber usamos a lógica todo momento, por exemplo:
    Ao acordamos:
      • Tomamos um banho.
      • Escovamos os dentes.
      • Tomamos o café da manhã.
    Para irmos ao trabalho:
      • Colocamos uma roupa apropriada.
      • Pegamos um ônibus.
      • Chegamos no trabalho.
Perceba que podemos detalhar mais coisas a respeito do exemplo anterior, nessa sequência foi
definida alguns fatos comuns.
Quando queremos chegar a um objetivo final, temos que traçar uma lógica coerente que tenha
sentido, onde em uma sequência lógica temos definido todos os passos que devemos seguir até o
final.
1.2. O que é lógica.
Lógica vem do grego clássico logos(λογική), que significa
palavra, pensamento, ideia, argumento, relato, razão lógica ou
princípio lógico. É uma parte da filosofia que estuda o
fundamento, a estrutura e as expressões humanas do
conhecimento. A lógica foi criada por Aristóteles no século IV a.C.
Para estudar o pensamento humano e distinguir interferências e
argumentos certos e errados.
Já que o pensamento é a manifestação do conhecimento, e que
o conhecimento busca a verdade, é preciso estabelecer algumas
regras para que essa meta possa ser atingida.
1.3. A real lógica do dia a dia.
Sempre que estamos pensando em algo, a lógica nos acompanha. Usamos a lógica quando
falamos ou quando escrevemos para por em ordem o nosso pensamento que está sendo expressado.
A automação é o processo em que uma tarefa deixa de ser desempenhada pelo homem e passa a
ser realizada por máquinas, sejam estes dispositivos mecânicos, eletrônicos (como os
computadores) ou de natureza mista. Para que a automação de uma tarefa seja bem sucedida é
Projeto Ejovem Módulo II
Ao acordar, tenho
um algoritmo para
Fazer o café?

necessário que a máquina que irá realizála seja capaz de desempenhar cada uma das etapas
constituintes do processo a ser automatizado com eficiência, de modo a garantir a repetição do
mesmo. Assim, é necessário que seja especificado com clareza e exatidão o que deve ser realizado
em cada uma das fases do processo a ser automatizado, bem como a sequência em que estas fases
devem ser realizadas.
A essa especificação da sequência ordenada de passos que deve ser seguida para a realização de
uma tarefa, garantindo a sua repetibilidade, dáse o nome de algoritmo.
Ao contrário do que se pode pensar, o conceito de
algoritmo não foi criado para satisfazer as necessidades da
computação. Pelo contrário,a programação de computadores
é apenas um dos campos de aplicação dos algoritmos. Na
verdade, há inúmeros casos que podem exemplificar o uso
(involuntário ou não) de algoritmos para a padronização do
exercício de tarefas rotineiras. No entanto, daqui por diante
a nossa atenção se volta para automação de tarefas
utilizando computadores e para isto definiremos o que lógica
de programação. Os algoritmos são descritos em uma
linguagem chamada pseudocódigo.
Este nome é uma alusão à posterior implementação em uma linguagem de programação,ou seja,
quando formos programar em uma linguagem, por exemplo Visual Basic,C,C++,java,etc, estaremos
gerando nossos código usando a ferramenta VisuAlg.
Exemplo:
Preciso pagar um conta de luz.
O valor da conta e de R$ 45,25 reais.
Portanto preciso de R$ 45,25 reais para pagar a conta.
Pagarei a conta as 3:00h da tarde.
Voltei para casa.
1.4. Lógica de programação.
A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento
de sistemas e programas, assim, ela permite definir a sequência lógica para a criação de aplicativos.
Significa o uso correto das leis do pensamento, da “ordem da razão”, do processo de raciocínio e
simbolização formais na programação de computadores. Com isso criase técnicas que cooperam
para a produção de soluções logicamente válidas e coerentes, que resolvam com qualidade os
problemas que se deseja programar.
Então o que é lógica?
Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo.
Usar o raciocínio é algo abstrato, intangível. Os seres humanos tem a capacidade de expressálo
através de palavras ou escrita, que por sua vez se baseia em um determinado idioma, que segue
uma série de padrões(gramática). Um mesmo raciocínio pode ser expresso em qualquer um dos
inúmeros, mas continuará representando o mesmo raciocínio, usando apenas outra convenção.
Em programação temos várias linguagens como, java, C, php,
Python, delphi dentre muitas outras que existem, porem cada uma
delas tem um padrão próprio. Essas por sua vez, são muito atreladas
a uma grade diversidade de detalhes computacionais, mas com o
mesmo raciocínio, seguindo as regras da linguagem, pode ser obtido
o mesmo resultado.

1.5. O que é um algoritmo
Um algoritmo é formalmente uma sequência finita de passos que levam a execução de uma
tarefa. Podemos pensar em algoritmo como uma receita, uma sequência de instruções que busca
uma meta específica. Estas tarefas não podem ser redundantes nem subjetivas na sua definição,
logo, devem ser claras e precisas.
Os algoritmos servem como modelo para programas, pois sua linguagem é intermediária a
linguagem humana e as linguagens de programação, sendo então, uma boa ferramenta na validação
da lógica de tarefas a serem automatizadas. Os algoritmos, servem para representar a solução de
qualquer problema, mas no caso do processamento de dados, eles devem seguir as regras básicas de
programação para que sejam compatíveis com as linguagens de programação.
Por esse motivo os algoritmos são independentes das linguagens. Ao contrário de uma linguagem
de programação, não existe um formalismo rígido de como deve ser escrito o algoritmo. O
algoritmo deve ser fácil de se interpretar e fácil de codificar, ou seja, ele deve ser o intermediário
entre a linguagem falada e a linguagem de programação a qual for definir.
Como exemplos de algoritmos podemos citar os algoritmos das operações básicas (adição,
multiplicação, divisão e subtração) de números reais decimais. Outros exemplos seriam os manuais
de aparelhos eletrônicos, como um DVD player, aparelhos celulares, televisores, que explicam passo
a passo como operar, programar, gravar um evento,listar suas fotos,etc.
Até mesmo as coisas mais simples, podem ser descritas por sequências lógicas. Por exemplo:
         “Trocar uma lâmpada”.
         •  Pegar uma escada
         •  Colocar a escada no local certo.
         •  Pegar a lâmpada nova
         •  Subir na escada.
         •  Retirar a lâmpada velha.
         •  Colocar a lâmpada nova.
         •  Descer da escada.
         •  Guardar a escada.
         •  Colocar a lâmpada velha no lixo.
         •  Ligar o interruptor para testar.

         “Somar dois números quaisquer”.
         •  Escreva o primeiro número no retângulo A
         •  Escreva o segundo número no retângulo B
         •  Some o número do retângulo A com número do retângulo B e coloque o resultado no
            retângulo C
1.6. Porque é importante construir um algoritmo.
Saber construir algoritmos é fundamental na formação de profissionais de informática ou
computação e como tal, proporcionar condições para essa aprendizagem é um constante desafio aos
professores e profissionais da área.
Um algorítimo tem um papel importante, pois ele determina de que formas podemos resolver um
determinado problema, um programa de computador por exemplo, é desenvolvido com muita
lógica e principalmente um conjunto de algorítimos.
Outra importância da construção dos algoritmos é que um vez concebida uma solução algorítmica
para um problema, esta pode ser traduzida para qualquer linguagem de programação e ser
agregada das funcionalidades disponíveis nos diversos ambientes; costumamos denominar esse
processo de codificação.

1.7. As maneiras de representarmos um algoritmo.
Existem diversas formas de representação de algoritmos, mas não há um consenso com relação a
melhor delas para ser aplicada na resolução do problema proposto. Algumas formas de
representação de algoritmos tratam os problemas apenas em nível lógico, abstraindose de detalhes
de implementação muitas vezes relacionados com alguma linguagem de programação específica.
Por outro lado existem formas de representação de algoritmos que possuem uma maior riqueza
de detalhes e muitas vezes acabam por obscurecer as ideias principais do algoritmo, dificultando
seu entendimento. Sendo assim temos as seguintes formas:
• Descrição Narrativa;
• Fluxograma Convencional;
• Pseudocódigo,também conhecido como Português Estruturado ou Portugol.
1.7.1. Descrição Narrativa.
Nesta forma de representação os algoritmos são expressos diretamente em linguagem
natural. Como exemplo, observe os algoritmos seguintes:
Esta representação é pouco usada na prática porque o uso da linguagem natural muitas vezes da
oportunidade a mas interpretações,ambiguidades e imprecisões.
Por exemplo, a instrução afrouxar ligeiramente as “porcas” no algoritmo da troca de pneus esta
sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais precisa seria: “afrouxar
a porca, girandoa 30 grau no sentido antihorário”.
Por mais simples que seja um algoritmo narrativo, pode haver uma grande quantidade de
detalhes, que por sua vez segue um conjunto de regras dentro da sequencia a qual pertencem.
1.7.2. Fluxograma Convencional.
É uma representação gráfica de algoritmos onde formas geométricas diferentes implicam ações
(instruções,comandos) distintos. Tal propriedade facilita o entendimento das ideias contidas nos
algoritmos e justifica sua popularidade.
Esta forma é aproximadamente intermediária a descrição narrativa e ao pseudocódigo (subitem
seguinte), pois é menos imprecisa que a primeira e, no entanto, não se preocupa com detalhes de
implementação do programa, como o tipo das variáveis usadas. Notase que os fluxogramas
convencionais preocupamse com detalhes de nível físico da implementação do algoritmo. Por
exemplo, figuras geométricas diferentes são adotadas para representar operações de saída de dados
realizadas em dispositivos distintos.
Existem diversas ferramentas para criação de fluxograma como Jude, Microsoft Visio, Dia(usado
no linux), dentre outras, cada uma delas tem uma vantagem em particular.

Trabalharemos com o editor de diagrama chamado Dia, onde podemos facilmente instalar no
Linux e sua licença é de livre acesso.
Dica: Pesquise o uso dessas ferramentas por meios da internet, amigos ou professores.
Observe as principais formas geométrica usadas para representação de Fluxogramas de
algoritmos:
Início ou fim do fluxograma            Operação de entrada de  dados

                             Operação de atribuição                       Decisão
                           Operação de saída de dados
Um fluxograma se resume a um único símbolo inicial por onde a execução do algoritmo começa,
e um ou mais símbolos finais, que são pontos onde a execução do algoritmo se encerra. Partindo do
símbolo inicial, há sempre um único caminho orientado a ser seguido, representando a existência de
uma única sequência de execução das instruções. Isto pode ser melhor visualizado pelo fato de que,
apesar de vários caminhos poderem convergir para uma mesma figura do diagrama, há sempre um
único caminho saindo desta. Exceções a esta regra são os símbolos finais, dos quais não há nenhum
fluxo saindo, e os símbolos de decisão, de onde pode haver mais de um caminho de saída
(usualmente dois caminhos), representando uma bifurcação no fluxo.
O exemplo ao lado representa um fluxograma
convencional, mostrando a representação do algoritmo
de cálculo da média de um aluno sob a forma de um
fluxograma.
A imagem abaixo é uma representação no diagrama de
Chapin. (não abordaremos esse diagrama, nessa
apostila).

1.7.3. Português Estruturado ou Pseudocódigo.
Esta forma de representação de algoritmos é rica em detalhes,como a definição dos tipos das
variáveis usadas no algoritmo. Por assemelharse bastante a forma em que os programas são
escritos, encontra muita aceitação. Na verdade, esta representação é suficientemente geral para
permitir a tradução de um algoritmo nela representado para uma linguagem de programação
específica seja praticamente direta. A forma geral da representação de um algoritmo na forma de
pseudocódigo é a seguinte:
Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de
pseudocódigo.
I Nome do programa: é um nome simbólico dado ao algoritmo com a finalidade de
distinguilos dos demais.
II – Var: consiste em uma porção opcional onde são declaradas as variáveis globais usadas
no algoritmo principal;
III Início e Fim: são respectivamente as palavras que delimitam o início e o término do
conjunto de instruções do corpo do algoritmo.
O algoritmo do cálculo da média de um aluno, na forma de um pseudocódigo, fica da
seguinte forma no visualg:
Dica: O Visual será a ferramenta que utilizaremos no decorrer do aprendizado,
lembrando que não usaremos todos os recursos disponíveis diretamente na ferramenta,
uma parte é pratica com programação lógica dentro do Visualg, a outra mostra conceitos
que são logicamente utilizados nas maiorias das linguagens de programação, uma vez
que, até então, a versão do Visual não abrange praticar todo conteúdo contido nessa
apostila como registos, manipulação de arquivo,dentre outros.

1.8. EXERCÍCIOS PROPOSTOS
1°)Crie uma sequência lógica para sacar dinheiro em um caixa eletrônico.
2°)Crie uma sequência lógica para determinar se um numero é par ou impar.
3°)Crie um fluxograma para as questões um e dois.
4°)dado o fluxograma abaixo determine:
C = capital,ex: R$ 1.000,00
T = tempo em anos,ex: 2 anos
I = Taxa de juros,ex: 5%
o usuário entra com esses valores e sabe quanto e calculado em juros simples.
a)quais as entradas de dados.
b)qual o processo que está sendo executado.
c)qual será a saída de informação se o usuário digitar 1025, 3, 12.
5º)Resolva as seguintes lógicas:
I Um time de futebol ganhou 8 jogos mais do que perdeu e empatou 3 jogos menos do que
ganhou, em 31 partidas jogadas. Quantas partidas o time venceu?
II Uma pessoa supõe que seu relógio está 5 minutos atrasado, mas, na verdade, ele está 10
minutos adiantado. Essa pessoa que chega para um encontro marcado, julgando estar 15 minutos
atrasada em relação ao horário combinado, chegou, na realidade, na hora certa em quantos minutos
atrasados?
III Três músicos, João, Antônio e Francisco, tocam harpa, violino e piano. Contudo, não se sabe
quem toca o quê. Sabese que o Antônio não é o pianista. Mas o pianista ensaia sozinho à Terça. O
João ensaia com o Violoncelista às Quintas . Quem toca o quê?
IV – Existem três mulheres, Dona Rosa, Dona Branca, Dona Lilas, Dona branca diz: as cores de
vestido que estamos usando combinam com nossos nomes, mas não estamos usando a cor do
próprio nome, a pessoa que está de lilas diz: é verdade, quis as cores que cada uma está usando?
6°) Supondo que você tenha planejado no seu dia posterior ir para o colégio, após isso pagar uma
conta no banco, após isso ir trabalhar,crie um algoritmo o mais detalhado possível que possa
satisfazer todo o planejamento citado:
7º)Faça um algoritmo para imprimir um documento. Descreva com detalhes.
8º)Faça um algoritmo para colocar um quadro em uma parede. Descreva com detalhes.

Capítulo 2. Tópicos Preliminares
Objetivos
Apresentar basicamente alguns tipos de dados a ser implementados e adotados; Falar qual sua
importância; Diferenciar variável e constante; Apresentar comados e processo de entrada.
2.1. Tipos primitivos.
Todo o trabalho realizado por um computador é baseado na manipulação das informações
contidas em sua memória. A grosso modo de expressarse, estas informações podem ser
classificadas em dois tipos:
As instruções, que comandam o funcionamento da máquina e determinam a maneira como
devem ser tratados os dados. As instruções são específicas para cada modelo de computador, pois
são funções do tipo particular de processador utilizado em sua implementação.
Os dados propriamente ditos, que correspondem a porção das informações a serem processadas
pelo computador.
2.1.1.   Tipos de Primitivos de Dados
Quaisquer dados a ser tratado na construção de um algoritmo deve pertencer a algum tipo, que
irá determinar o domínio de seu conteúdo. Os tipos mais comuns de dados são conhecidos como
tipos primitivos de dados, são eles: inteiro, real, caractere e lógico. A classificação que será
apresentada não se aplica a nenhuma linguagem de programação específica, pelo contrário, ela
sintetiza os padrões utilizados na maioria das linguagens.
Inteiro: todo e qualquer dado numérico que pertença ao conjunto de números
inteiros relativos (negativo, nulo ou positivo). Exemplos: {...4,3,2,1,0,1,2,3,4,...}.
Real: todo e qualquer dado numérico que pertença ao conjunto de números reais
(negativo, nulo ou positivo). Exemplos: {15,34; 123,08 ; 0,005 12,0 ; 510,20}.
Numérico: tratase de todo e qualquer número que pertença ao conjunto dos inteiros ou
reais, também abrange números binários, octal e hexadecimal.
Dados literais: todo e qualquer dado composto por um conjunto de caracteres
alfanuméricos  (números, letras e caracteres especiais). Exemplos: {“Aluno Aprovado”, “10% de
multa”, “Confirma a exclusão ??”, “S”, “9930002”, “email”,”123nm”,”fd54fd”}.
Lógico: A existência deste tipo de dado é, de certo modo, um reflexo da maneira como os
computadores funcionam. Muitas vezes,estes tipos de dados são chamados de booleanos, devido à
significativa contribuição de Boole a área da lógica matemática. A todo e qualquer dado que só
pode assumir duas situações dados biestáveis,algo como por exemplo {0/ 1, verdadeiro/falso,
sim/não,  true/false }.
2.2. Constantes.
Uma constante é um determinado valor fixo que não se modifica ao longo do tempo, durante a
execução de um programa. Conforme o seu tipo, a constante é classificada como sendo numérica,
lógica e literal.

Nesse exemplo temos o número 4 como constante, ou seja, ele nunca se altera.
2.3. Variável.
Uma variável é um espaço reservado na memória do computador para armazenar um tipo de
dado determinado. As variáveis devem receber nomes para poderem ser referenciadas e
modificadas quando necessário. Um programa deve conter declarações que especificam de que tipo
são as variáveis que ele utilizará e as vezes um valor inicial. Tipos podem ser por exemplo: inteiros,
reais,caracteres,etc. As expressões combinam variáveis e constantes para calcular novos valores.
Veja um exemplo de variáveis do tipo carácter e outra do tipo inteiro,ele serão armazenados na
memória :
Veja um exemplo onde atribuímos valores as variáveis nome e idade:
2.4. Formação de identificadores.
Toda variável deve possuir um nome para sua identificação dentro de um algoritmo, mas vale
ressaltar que não podemos atribuir qualquer nome a ela,e uma vez atribuindo, verificar se ele é um
identificador válido ou não. Na figura abaixo observamos um resumo através de um gráfico que
segue resumidamente as regras.
Representamos nomes escolhidos para rotular as variáveis,procedimentos e funções,
normalmente, obedecem as seguintes regras:
1. O primeiro carácter deve ser uma letra.
2. Os nomes devem ser formados por caracteres pertencentes ao seguinte conjunto :
{a,b,c,..z,A,B,C,...Z,0,1,2,...,9,_}.
3. Os nomes escolhidos devem explicitar seu conteúdo. EX: A, B1, BC3D,SOMA, CONTADOR.
obs.: Um exemplo de identificador inválido seria 2AB ou qualquer outro iniciado por um dígito.
2.5. Declaração de variáveis
Toda variável possui algum conteúdo, que será armazenado por ela e manipulado pelo algoritmo.
As variáveis que serão utilizadas nos algoritmos devem ser declaradas inicialmente. A declaração de
uma variável indica o tipo de dado que ela pode “guardar” no decorrer da execução do algoritmo
(ou no decorrer da execução do programa que futuramente será construído).
Para declararmos uma variável, temos que criar um identificador para ela, que será o nome da
variável no algoritmo, e também temos que definir o tipo de dado que a variável pode armazenar.
Faremos a declaração de variáveis obedecendo ao seguinte padrão:

Portugol: [nome do tipo de variável] : [ nome da variável] ;
Padrão Visualg: [nome da variável] : [ nome do tipo de variável]
Percebemos que existe duas diferença na declaração das variáveis do portugol em relação a do
Visual,que é justamente a troca de posições e a ausência de pontoevirgula.
Exemplo:
Visualg: Portugol:
alunos : caracter caracter : alunos ;
valor : inteiro inteiro : valor ;
b : real real : b ;
2.6. Comandos de entrada e saída.
Em um algoritmo é preciso representar a troca de informações que ocorrerá entre o mundo da
máquina e o nosso mundo, para isso, devemos utilizar comandos de entrada e saída, sendo que,a
nível de algoritmo esses comandos representam apenas a entrada e a saída da
informação,independe do dispositivo utilizado (teclado, discos, impressora, monitor,...), mas,
sabemos que nas linguagens de programação essa independência não existe, ou seja, nas linguagens
de programação temos comandos específicos para cada tipo de unidade de Entrada/Saída.
2.6.1. COMANDO DE ENTRADAS DE DADOS
Para que possamos obter dados do meio exterior para uso do computador (memória
principal),estes têm de vir através dos dispositivos de entrada. Da mesma forma, as informações que
são produzidas, tem de ser levadas ao meio externo (um arquivo, um a impressora, uma tela etc.)
através de um dispositivo de saída. Para isso, utilizamos dois comandos assim definidos:
Comando “leia” tem a finalidade de lê, do meio externo, a próxima informação disponível para
leitura e armazena na(s) variável(eis) discriminada(s) após o comando, entre parênteses. Mais
tarde aprenderemos como especificar a leitura de um dado que está armazenado em um arquivo e
de que arquivo está sendo lido o dado.
Exemplo: leia (v) O valor da variável (v) é dado por um dispositivo de entrada.

2.6.2. COMANDO DE SAIDAS DE DADOS
Comando escreva ou escreval: Imprime (na tela ou na impressora) o conteúdo da(s)
variável(eis) especificada(s) após o comando, entre parênteses. Não será preocupação nossa a
formatação de relatórios, mas o comando permite a impressão de texto (entre “ ”), se for necessária
para clareza ou especificação do que está sendo impresso.
Exemplo: escreva(x) O valor atual da variável (x) é informado para um dispositivo de saída.
Vale ressaltar que em linguagens de programação geralmente termina um comando com
ponto e virgula( ; ), mas para o uso no Visualg, não precisamos usar ; para fechar o comando,uma
vez que isso ocorre de forma automática.
Exemplo: escreva(x) O valor atual da variável (x) é informado para um dispositivo de saída.
em visualg: numero : inteiro
portugol: inteiro numero;
Também podemos concatenar valores no comando de saída. Isso varia muito de uma linguagem
para outra, por exemplo:
ao executar(tecla de atalho F9) isso imprime na tela resultado seguinte:
Esse exemplo ao lado utilizamos os a
subtração de dois números e logo após
imprimimos o resultado na tela.

O resultado da saída desse programa é a seguinte:
Exemplo com o comando leia e escreva:
códigofonte. saída da execução:
utilizamos o “escreval” quando queremos uma quebra de linha, troque por “escreva” e perceba o que
acontece:
2.7. Expressões aritméticas.
Quando construímos algoritmos é comum trabalharmos com expressões matemáticas para a
resolução de alguns problemas. As expressões matemáticas podem fazer uso de operadores
aritméticos e relacionais. As variáveis (ou constantes) manipuladas pelos operadores são chamadas
de operandos. Observe o diagrama:
Exemplos:
A+B (A e B são os operados, e + é o operador da expressão).
((2 * A) + 5)
(B/A)
((A//2)*B) – 15

2.8. Operadores aritméticos
Chamamos de operadores aritméticos o conjunto de símbolos que representa as operações
básicas da matemática.
Para representa potencia e radiciação utilizamos:
Operador Função Significado Exemplos
^ Potenciação x elevado a y 2^8
raizQ(x) Radiciação Raiz quadrada de x raizQ(9)
Exemplo:
   códigofonte.      Saída da execução.
Usaremos outras operações matemáticas não convencional, porém muito úteis nas construção de
algoritmo, que são o resto e o quociente da divisão inteira, conforme abaixo:
Operador Função Exemplo
mod Resto da divisão 9 mod 4 resolta em 1
div Quociente da divisão 9 div 4 resulta em 2
Exemplo:
  algorítimo que possui as quatros operações:
algorítimo que calcula o quociente e resto de uma divisão:

2.9. Expressões lógicas
As expressões lógicas sempre retornaram True (Verdadeiro) e False (Falso). Para se montar
expressões lógicas utilizamos de operadores relacionais e operadores lógicos.
Exemplo:
Visualg: Portugol:
a <- verdadeiro a <- verdadeiro;
b <- falso b <- falso;
2.10. Operadores relacionais.
São utilizados para relacionar variáveis ou expressões, resultando num valor lógico (Verdadeiro
ou Falso), sendo eles mostrados na tabela abaixo:
Obs.: utilizamos somente o “=” no lugar de “==”, e “<>” no lugar de “!=”, mas isso somente no
Visualg.
Exemplos:
comparações:
num != 3 {compara se num é diferente de 3,se for igual retorna falso}
nome = ‘DENISE’ {compara se nome é igual a ‘DENISE’ ,se for retorna verdadeiro}
num > 5 é falso (0) {3 não é maior que 5}
Algorítimo abaixo mostra o uso desse operadores relacionais.
código-fonte. Saída da execução.

2.11. Operadores lógicos.
São utilizados para avaliar expressões lógicas. Estes operadores servem para avaliar expressões
que resultam em valores lógico sendo verdadeiro ou falso:
Esses operadores tem a finalidade de novas proposições lógicas composta a partir de outra
proposições lógicas simples. Observe:
Operador Função
não negação
e conjunção
ou disjunção
Com isso podemos podemos construir a Tabela verdade onde trabalhamos com todas as
possibilidades combinatória entre os valores de diversas variáveis envolvidas, as quais se encontram
em apenas duas situações (V e F), e um conjunto de operadores lógicos. Veja o comportamento
dessas variáveis:
Operação de Negação:
A (not) não A
F V
V F
Operação de conjunção:
A B A e B
F F F
F V F
V F F
V V V
Operação de disjunção nãoexclusiva:
A B A ou B
F F F
F V V
V F V
V V V
Exemplos:
ACHOU = falso , ACHOU = true;
NUM = 9
( 4 > 5 ) e ( 5 > 3) => falso e verdadeiro (1) = falso (0)
não ACHOU => verdadeiro

Exemplo:
código-fonte. Saída da execução.
2.12. Comando de atribuição.
O operador de atribuição é utilizado para atribuir valores aos identificadores(variáveis e
constantes) e na montagem de expressões(aritméticas,lógicas e literal).
Com isso podemos definir sempre que um tipo de dado deve ser compatível com o tipo da
variável.
A figura abaixo mostra em diagrama a sua sintaxe:
O valor da expressão é atribuído ao identificador (variável).
X <- 2 y <- 5-x Z <- (3*(y- 9)) w <- (4*((w+2y)/2)*x)
Este comando permite que se forneça ou altere o valor de uma determinada variável, onde o tipo
desse valor seja compatível ao tipo de variável na qual está sendo armazenado, de acordo com o
especificado na declaração.
Exemplo:
NUM < 8 {A variável NUM recebe o valor 8}
NOME < “Guilherme” {A variável NOME recebe o valor ‘Guilherme’}
2.12.1. PRIORIDADE DE OPERADORES:
Durante a execução de uma expressão que envolve vários operadores, é necessário a existência de
prioridades, caso contrário poderemos obter valores que não representam o resultado esperado. A
maioria das linguagens de programação utiliza as seguintes prioridades de operadores:
1. Efetuar operações embutidas em parênteses "mais internos".
2. Efetuar Funções.
3. Efetuar multiplicação e/ou divisão.
4. Efetuar adição e/ou subtração.
5. Operadores Relacionais.
6. Operadores Lógicos

1º)Como podemos definir o conceito de tipos primitivos de dados.
2°)Cite alguns tipos primitivos e der exemplos.
3°)Qual a diferença entre constantes e variáveis.
4°)Como podemos definir a formação de um identificador válido? crie cinco identificadores no
Visualg (o nome devera ser uma única letra e após isso os tipos).
5°)Crie o seguinte código no Visualg e diga qual o resultado final.
6°)Crie um programa no onde podemos receber dois números digitados pelo usuário no final ele
some os números e imprima o resultado.
7°)Dado a formula:

     crie um programa para calcular a formula de Bhaskara. Onde no final mostre ao usuário x1 e
x2 separadamente.
Dica:o usuário digita três valores, a,b e c,o programa terá duas variáveis para receber o calculo,
x1 e x2.Para calcular raiz quadrada use o comando raizQ(x) onde x é o numero que tem valor
inteiro,atribua o resultado da raiz a soma e depois a subtração.
ex: b ← raizQ(25) , b recebe 5,pois é raiz de 25, e b deve ser do tipo real.
8º)Crie um diagrama onde podemos representar o programa da questão 7.
9°)Crie um programa que receba pelo usuário o nome,ano de nascimento, ano atual, e calcule a
idade,mostrando a seguinte saída ex:  meu nome é Janaína e tenho 23 anos de idade.
10°)crie um diagrama para representação da questão 9.
11°) usando o comando o tipo de dado logico do Visualg, teste  os operadores relacionais. ex: a :
logico , a 12 <=5 ,escreva(a).←

Capítulo 3. Estruturas de Controle
Objetivos
Mostrar conceitos e estrutura sequencial de fluxo, em etapas lógicas, onde podese assimilar
suas variações, combinações e equivalências; Apresentar estruturas de repetição e sua aplicação.
As estrutura de controle de dado são responsáveis pela manipulação dos dados conforme seja
necessário na realização de um processamento. Cada instrução programável possui uma lógica de
operação e estabelece uma sequencia de ações a serem efetuadas ou verificadas.
Quando estivermos criando os algoritmos serão necessárias as manipulações de dados
respeitando a sequencia lógica de cada comando, buscando sempre alcançar os objetivos almejados
pelos algoritmos. Basicamente as estruturas de controle de dados são de três tipos principais:
Sequencial: conjunto de comandos separados por ponto e vírgula (;) que são executados em
uma sequência linear de cima para baixo.
Seleção:a partir de um teste condicional, uma instrução, ou um conjunto de instruções, podem
ser executados ou não, dependendo exatamente do resultado do teste efetuado.
Repetição:uma instrução ou o conjunto de instruções que será executado repetidamente, de
acordo com o resultado de um teste condicional.
3.1. Estrutura sequencial.
A estrutura sequencial é a mais convencional entre todas as possíveis, pois ela consiste na
execução de uma instrução de cada vez, onde o encerramento da primeira instrução permite o
acionamento da instrução seguinte, respeitando a ordem de cima para baixo.
Observe o exemplo a seguir:
Declarações
real NOTA;
Inicio
escreva("Informa a nota da prova: ");
leia(NOTA);
escreva("Nota =", NOTA);
Fim
O mesmo exemplo no Visualg fica:

O algoritmo proposto no exemplo anterior é descritivo e respeita as regras de organização e
sintaxe do português estruturado. Porém, qual é a primeira instrução a ser executada neste
algoritmo?
Ele será executado de maneira sequencial, onde a partir da palavra reservada Declarações as
instruções vão sendo executadas de cima para baixo e a próxima instrução só é executada após a
anterior ser encerrada. O ponto e vírgula marca exatamente o final da instrução a ser executada, no
caso dos comando do Visualg vale lembrar que suas instruções não finalizam com ponto e virgula,
pois ao passar pra próxima linha o programa reconhece como finalização da instrução anterior.
1. Primeira execução será a criação da variável NOTA.
2. Segunda será a escrita da mensagem que orienta o usuário.
3. Na terceira será armazenado o valor informado pelo usuário.
4. A quarta e última mostrará uma mensagem e o valor lido
            É importante observar que sempre será executado primeiro o bloco de declarações e na
sequencia o bloco de instruções. A execução da palavra reservada Fim encerra a execução do
algoritmo.
3.2. Estrutura de seleção.
Este tipo de estrutura permitir a escolha de um caminho sequencial a ser executado.
Primeiramente, ela efetua um teste condicional que definirá o caminho de execução do algoritmo
baseado no resultado deste teste.
Os testes condicionais são baseados na lógica convencional, podem obter o resultado de
verdadeiro ou falso. Estes testes podem ser efetuados sobre operações relacionais simples ou com
expressões lógicas complexas que resultem em um valor lógico (verdadeiro ou falso).
As estruturas de seleção podem ser classificadas de 4 formas diferentes, sendo esta classificação
baseada na organização lógica existente em cada situação. Esta classificação se resume em:
       >  Seleção simples.
       >   Seleção composta.
       >  Seleção encadeada.
       >  Seleção de múltipla escolha.
3.2.1. Seleção Simples
Neste tipo de seleção é proposto um teste condicional, que sendo verdadeiro possibilitará a
execução de uma instrução ou um conjunto de instruções (bloco condicional) específica.
Português estruturado:
Acompanhe a seguir as regras de representação em algoritmo para a técnica descritiva do
português estruturado.
Sintaxe:
:
se (<condição>) então
comando 1;
comando 2;
:
:
comando n;
fim se;

Exemplo: No Visualg:
Declarações
inteiro IDADE;
Inicio
escreva("Informe sua idade: ");
leia(IDADE);
se (IDADE < 15) então
escreva ("Você é uma criança");
fim se;
Fim
Este algoritmo será executado sequencialmente até chegar ao comando SE (comando condicional
SE) que realizará o teste condicional para verificar a veracidade do valor informado pelo usuário e
armazenado na variável IDADE.
Se ela for verdadeira, ou seja, for menor que 15 a mensagem "Você é uma criança" será mostrada
na tela. Se o valor informado pelo usuário não atender ao teste condicional, a mensagem não será
exibida e o bloco condicional não será executado.
Fluxograma:
Abaixa temos no fluxograma o simbolo que representa uma decisão ou seleção e a seguinte:
As suas vértices indica qual a saída caso ela for
verdadeira ou falsa.
Acompanhe a seguir a representação em
algoritmo na técnica gráfica do fluxograma:

Exercício rápido:
1°) Crie um algoritmo que leia um número e diga se
ele é maior ou menor que 10.
2°) Crie um algoritmo que leia dois números e
determine qual é o maior entre eles, imprimindo na
tela (“o primeiro número é o maior”, “o segundo
número e o maior” ) de acordo com o valor digitado.

3.2.2. Seleção Composta
A seleção composta sempre executará um bloco condicional, pois se o resultado do teste
condicional for verdadeiro um conjunto de instruções ou somente uma será executada e se o
resultado não for verdadeiro um outro conjunto de instruções, ou somente uma, será executada
também.
Este tipo de seleção sempre identificará um único caminho de instruções a ser percorrido,
dependendo sempre do resultado da veracidade do testes condicional executado.
Sintaxe:
:
se (<condição>) então
comando 1;
:
comando n;
senão
comando 5;
:
comando m;
fim se;
Exemplo: no Visualg
Declarações
inteiro idade;
Inicio
leia(idade);
se (idade < 15) então
escreva ("Você é uma criança");
senão
escreva("Você é adulto");
fim se;
Fim
Se a idade informada for menor que 15 então a mensagem a classificará como uma criança, senão
a mensagem apresentada será que Você é adulto.

Veja como é o fluxograma que representa o código anterior abaixo:
Exercício rápido:
1°) Crie um algoritmo que leia sua
idade e diga se você é de “maioridade”
ou de “menoridade”.
2°) Crie um algoritmo que um
número, caso ele seja menor que 0,
transforme ele em positivo, se não,
imprima seu valor na tela.
3.2.3. Seleção encadeada
A instrução de seleção (SE) pode ser encadeada uma dentro da outra, seja no bloco verdadeiro
(então) ou falso (senão). Todas as instruções programáveis podem estar dentro de qualquer um dos
blocos da instrução de seleção.
O encadeamento destas instruções também é chamada de aninhamento de instruções de seleção
ou condicional várias, não existindo um limite de quantos testes condicionais podem estar dentro de
outro. Quem estabelece este tipo de limite é a solução lógica proposta no algoritmo para alcançar
uma solução eficiente.
Sintaxe:
:
se (<condição_1>) então
<bloco de comandos 1>;
senão
<bloco de comandos 2>;
senão
:
fim se;
fim se;
fim se;

Exemplo: no Visualg:
Declarações
inteiro idade;
Início
leia(idade);
se (idade < 20) então
se(idade < 15) então
escreva ("Você é criança");
senão
escreva ("Você é adolescente");
fim se;
senão
se(idade < 50) então
escreva("Você é adulto");
senão
escreva("Você é velho");
fim se;
fim se;
Fim
Fluxograma:
Exercício rápido:
1°) Crie um algorítimo que receba os três lados(A,B,C) de um triângulo e diga de ele é
triângulo escaleno(todos os lados diferente), isósceles(somente dois lados iguais) ou
equilátero(todos os lados iguais).
2°) Dado três variáveis, crie um algoritmo que determine quem é a maior, a intermediaria e a
menor.

3.3. Seleção de múltipla escolha.
Uma outra instrução condicional, muito utilizada nas avaliações de igualdade, é a seleção de
múltipla escolha. Ela verifica somente a igualdade do valor avaliado, onde sua veracidade resultará
na execução de um bloco, ou de uma única instrução específica.
Sintaxe:
:
escolha (X)
caso <v1>:
comandos;
caso <v2>:
comandos;
caso <v3>:
comandos;
caso contrario:
comandos;
fim escolha;
<v1>, <v2>, <v3> são supostos valores a serem relacionados por meio da operação de
igualdade.
Exemplo:
Declarações
inteiro estação;
Inicio
escreva("Digite o período trimestral do ano em que estamos: ");
leia(estação);
escolha (estação) { instrução de múltipla escolha sobre estação }
caso 1: escreva ("verão"); { testes de igualdades sobre estação }
caso 2: escreva ("outono");
caso 3: escreva ("inverno");
caso 4: escreva ("primavera");
caso contrario: escreva ("período inválido");
fim escolha;
Fim

No Visualg
Temos algumas diferenças de sintaxe, onde uma delas é a ausência de dois pontos após caso, a
outra é o comando “outrocaso” que no portugol é representado por “casocontrario”.
3.4. Estruturas de repetição.
O processamento de valores pode ocorrer diversas vezes sobre uma mesma lógica, porém os
dados a serem manipulados podem ser diferentes, como no calculo da tabuada de um número. Este
calculo realiza a mesma operação de multiplicação sobre os valores numéricos inteiros sequencias,
normalmente iniciados em um (1) e seguindo até o número dez (10) quando estamos aprendendo a
calcular e memorizar o resultado obtido nesta operação.
Sendo assim, Vamos criar um algoritmo que leia um número positivo e apresente o resultado de
sua tabuada de um a dez (1 à 10). Observe o exemplo proposto:
Exemplo:
Supondo que o valor
desejado seja 2 então: Solução (algoritmo descritivo):
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
2 x 10 = 20

Para o exemplo acima foi desenvolvido um algoritmo que atende ao problema apresentado, mas
se os valores tivessem que ser gerados até 1000? .Assim o algoritmo não ficaria mais complexo, pois
a operação a ser realizada seria a mesma, e ele ficaria bem maior. Adiante veremos a solução para
esse problema.
Dica: os laços de repetição são conhecidos em inglês como loops ou looping.
3.5. Repetição com teste no início e no final.
3.5.1. TESTE INÍCIO
Com o intuito de controlarmos as manipulações necessários sobre os dados armazenados,
também podemos utilizar as instruções de repetição, que permitem a repetição de uma operação
quantas vezes forem necessárias, baseando esta repetição no resultado de um teste condicional.
Para isso temos a estrutura enquanto <condição> faça.
A instrução de repetição ENQUANTO ... FAÇA permite a execução do conjunto de comandos
pertencentes ao seu bloco de repetição, sendo eles executados a partir de um teste condicional
verdadeiro. Enquanto este teste permanecer verdadeiro a repetição é executada continuamente,
sendo encerrada somente quando a condição for falsa.
Sintaxe:
:
enquanto (< condição >) faça
<bloco de repetição>; { com um ou vários comandos }
fim enquanto;
Exemplo (descritivo): No Visualg:

Declarações
real nota, media;
inteiro aux;
Início
aux 1; ←
media 0; ←
enquanto  aux < 50 faca
       escreva("Informe sua nota: ");
       leia(nota);
       media ← media + nota;
       aux ← aux + 1;
fim enquanto
escreva("Média da turma = ",media /50);
Fim

Fluxograma:
Observe ao lado a representação genérica em um algoritmo gráfico usando o
ENQUANTO ...FAÇA.
Exercício rápido:
1°) Crie um algorítimo que conte de 1 até 100.
2°) Crie um algorítimo que receba 10 números e
imprima na tela após cada digitação.
3°) Crie um programa que conte de 1 a 52.
3.5.2. TESTE FINAL
Para o teste final temos a instrução REPITA ... ATÉ, onde possui características relevantes na
sua lógica de execução.
As principais características dessa instrução são:
• O teste condicional para realizar a repetição sobre o bloco de instruções existente
entre a palavra reservada REPITA e ATÉ é executado somente no final do bloco, conforme
organização sequencial do algoritmo
• O bloco entre as duas palavras reservadas desta instrução será executado no mínimo
uma vez
• A repetição é executada somente se o teste condicional for falso, pois sendo ele
verdadeiro a repetição é encerrada.
Sintaxe:
:
repita
<bloco de repetição>;{ com um ou vários comandos }
até (<condição>);
:

Declarações
real nota, media;
inteiro aux;
Início
aux ← 1;
media ← 0;
repita
leia(nota);
media ← media + nota;
aux ← aux + 1;
até (aux > 50);
escreva("Média da turma = ",media /50);
Fim
Usando a representação gráfica, vamos observar o mesmo exemplo usando a instrução REPITA ...
ATÉ.
O bloco de repetição vai ser executado até a condição for maior que 50.
Observe Fluxograma ao lado:
Exercício rápido:
1°) Crie um algorítimo que leia um número e
mostre vários “*” na tela de acordo com esse
número. Ex: 10 vai imprimir **********.
2°) Crie um algoritmo que leia dois números e
mostre o intervalo entre eles. Ex: 5 e 12 vai
mostra: 6,7,8,9,10,11.

3.6. Repetição com variável de controle.
Na estrutura de repetição vista até agora, ocorrem casos que fica difícil determinar o números de
vezes que um bloco vai executar. Ou seja,será executado enquanto a condição for satisfatória.
A instrução de repetição PARA ... FAÇA executa um conjunto de instruções por uma quantidade
de vezes bem definidas (conhecidas).
Sintaxe:
:
para X de i até f passo p faça
<comandos>;
fim para;
onde:
X é uma variável inteira que auxiliará na contagem da repetição iniciada com o valor i até o valor
final de f ,p é o valor do incremento dado a variável X.
O problema da tabuada, apresentado anteriormente, pode ser solucionado com o algoritmo que
usa eficientemente a instrução de repetição para ... faça.
Solução da tabuada (descritiva):
Declarações
inteiro valor, contador;
Início
escreva ("Informe o valor desejado: ");
leia(valor);
para contador de 1 até 10 passo 1 faça
escreval(valor, " x ",contador," = ", ( valor * contador) );
fim para;
Fim
No Visualg:

Vamos acompanhar outro exemplo na aplicação desta instrução de repetição.
Declarações
real nota, soma, media;
inteiro aux;
Início
soma <- 0;
para aux de 1 até 50 passo 1 faça
leia(nota);
soma<- soma + nota;
fim para;
media <- soma / 50;
escreva ("Média da turma = ", MEDIA);
Fim
Neste exemplo, a repetição, ou looping, realizado pela instrução para ... faça efetua a leitura e a
soma de 50 notas de alunos de uma turma, apresentando no seu final a média desta turma.
Fluxograma:
Acompanhe a seguir o algoritmo gráfico da
solução descrita anteriormente em português
estruturado.
Exercício rápido:
1°) Faça um algoritmo que receba 10
números e imprima somente os 5 primeiros.
2°) Faça um algoritmo que imprima somente
números pares de 2 até 20.

3.7. Comparação entre estruturas de repetição.
As estruturas de repetição possuem uma forma diferenciada para controlar a quantidade de
repetições a serem executadas. Estes controles podem ser genericamente classificados em
automático ou controlado pelo usuário do programa.
AUTOMÁTICO: Uma variável auxiliar contará de quantas vezes será executado o conjunto
de comandos (bloco de repetição), sem interferência direta do usuário. O bloco será
repetido sempre a quantidade de vez prevista pelo desenvolvedor do programa.
CONTROLADO PELO USUÁRIO: O programa sempre respeitará a solicitação do usuário,
executando um bloco de repetição quantas vezes forem solicitadas pelo usuário, respeitando a
lógica existente no programa desenvolvido.
Na tabela a seguir podemos ver um comparativo de estruturas de repetição;
Estrutura Condição Quantidade de execuções Condição de existência
Enquanto Início 0 ou muitas Condição verdadeira
Repita Final Minimo 1 Condição falsa
Para Não tem ((vf-vi) div p)+1 v<=vf
Onde:
v       variável de controle;→
vi      é a variável de controle;→
vf      é o valor final da variável v;→
p       é o valor o incremento dado à variável;→
Diagrama:
enquanto:
repita:
para:

Repare que a estrutura para é a mais complexa, uma vez que acontece vários processos no
mesmo, as estruturas repita e enquanto são muito semelhantes. A diferença está na ordem da
expressão e ação, pois em repita a expressão lógica é testada no final, ou seja, a ação executa pelo
menos uma vez.
Comparação da sintaxe:
enquanto:
enquanto aux < 50 faca
….......
fim enquanto
repita
repita
…......
até (aux > 50);
para
para aux de 1 até 50 passo 1 faça
….....
fim para;
veja um exemplo de um programa feito com as três estruturas:
repare que a variável aux é iniciada varias vezes pois a cada laço de repetição é incrementado um
novo valor, no cado de 1 até o numero 10.

1°)Quais os três tipos de estruturas de dados, e diga qual a principal diferença entre elas.
2°) Quais as estruturas de seleção,defina cada uma delas.
3°) Usando estrutura de seleção crie um algoritmo no Visualg onde o usuário digite 4 notas de um
aluno e mostre no final a média dizendo ao usuário se ele foi aprovado ou reprovado.
4°) Usando escolha crie um algoritmo onde o usuário digite um numero de 1 a 7,após isso
imprima a seguinte frase,ex : “a opção escolhida foi a de número 5”.
5°) Crie um fluxograma para a questão 4 de acordo com a forma resolvida.
6°) Defina qual a principal finalidade de uma estrutura de repetição.
7º) Crie um algoritmo no visual que receba dois números, o primeiro devera ser digitado por uma
pessoa, o outro por outra pessoa,o intuito do algorítimo e verificar se o segundo usuário chutou o
numero próximo do primeiro ou não, caso ele acerte o chute imprima na tela(use a estrutura se
para comparar).
8°) usando estrutura de repetição enquanto,crie um algorítimo no Visualg que conte de 1 até 20.
9°) Agora com os mesmos códigos da questão 9, faça um algorítimo que, ao chegar em 20 comece
a contar de novo(acrescente a estrutura se para reinicializar a variável) .
10°)Crie um algorítimo onde o usuário entre com o tempo em minutos,após isso ele imprima na
tela uma contagem regressiva(use qualquer estrutura de repetição).
11°)Faça um algorítimo onde o usuário entre com numero e imprima a tabuada daquele
numero(use qualquer estrutura de repetição).
12°) Dada a expressão H= 1/1+3/2+5/3+7/4+.....+99/50,crie um algoritmo que mostre o
valor final de H.
13°) Crie um algoritmo que o usuário entre com um numero e ele diga se é “par” ou “impar”(use
qualquer estrutura de comparação)..
14º) Crie um programa que mostre toda a tabuada de 1 até 9 (use qualquer estrutura de
repetição).

Capítulo 4. Estruturas de Dados
Objetivos
Mostrar a manipulação de vetores e matrizes em sua aplicação; Mostrar aplicabilidade dessas
estruturas visando somente o conceito de registros(uma vez que não existe registos nas versões
atuais do Visualg).
4.1. O que é estruturas de dados.
São organizações de dados construídas a partir da composição dos tipos primitivos já existentes
(caractere, inteiro, real, lógico). Esses novos tipos de dados podem armazenar um conjunto de
dados conhecidos como variáveis compostas. As variáveis que armazenam esses tipos de dados
podem ser classificadas em: variáveis compostas homogêneas e variáveis compostas heterogêneas.
As variáveis compostas são estruturas de dados (armazenam um conjunto de dados) homogêneos
ou heterogêneas. Esses dados podem ser armazenados em dois tipos de variáveis: as variáveis
unidimensionais (conhecidas como vetores) e as variáveis multidimensionais (conhecidas como
matriz).
O diagrama abaixo mostra as regras sintáticas, supondo que o valor a ser atribuído é um conjunto
de informações:
Lembrando que estas regras podem mudar de acordo com a linguagem. Veja a forma
estruturada utilizada no Visualg.
Declaração:
Inicialização:
4.2. Variáveis compostas homogêneas.
As estruturas de dados homogêneas permitem agrupar diversas informações dentro de uma
mesma variável. Este agrupamento ocorrerá obedecendo sempre ao mesmo tipo de dado, e é por
esta razão que estas estruturas são chamadas homogêneas. A utilização deste tipo de
estrutura de dados recebe diversos nomes, como: variáveis indexadas, variáveis compostas,
variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou arrays. Os nomes mais
usados para essas estruturas homogêneas são: matrizes (genérico) e vetores (matriz de uma linha e
várias colunas).
Exemplos:
Alcateia (vários lobos), conjunto de números inteiros, lista de contatos, time de futebol, o
vetor notas, que armazena o conjunto de notas da primeira e outros.

4.3. Variáveis compostas unidimensionais.
São variáveis que necessitam de apenas um índice para individualizar um elemento do conjunto
que são chamado de vetores. Os vetores são usados nos casos em que um conjunto de dados do
mesmo tipo precisa ser armazenado em uma mesma estrutura.
Exemplo:
1. Guardar 20 números diferentes em um mesmo tipo de variável.
2. Lista de palavras em uma mesmo tipo de variável.
3. 50 Médias de alunos em um mesmo tipo de variável.
Diagrama:
Diagrama da estrutura no Visualg:
onde:
Li = representa o limite inicial do vetor.
Lf = representa o limite final do vetor.
Tipo primitivo: representa qualquer uns dos tipos básicos de dados.

4.4. Declaração e manipulação(unidimensional).
Ao imaginar o elevador de um prédio sabemos que este é capaz de acessar qualquer um de
seus andares. Entretanto, não basta saber que andar desejamos atingir se não soubermos o nome do
edifício, pois qualquer um possui andares. O que precisamos de antemão é saber o nome do edifício
e só então nos preocuparmos para qual daqueles andares queremos ir. O mesmo acontece com os
vetores, visto que são compostos por diversas variáveis e, como podem existir muitos vetores, torna
se necessário determinar qual vetor contém o dado desejado e depois especificar em qual posição
este se encontra. O nome do vetor é determinado por meio do identificador que foi utilizado na
definição de variáveis, e a posição, por meio da constante, expressão aritmética ou variável que
estiver dentro dos colchetes, também denominada índice. Após isolar um único elemento do vetor,
poderemos manipulálo através de qualquer operação de entrada, saída ou atribuição.
A sintaxe do comando de definição de vetores é a seguinte:
Portugol: <nome do tipo de variável>  :   [ nome da variável] <expressão>;
Padrão Visualg: [nome da variável] : vetor[<valor do índice>] de [ tipo de variável]
Observe:
Declaração convencional : tipo: nome[n];
Declaração no Visualg: nome : identificador[n]de tipo
n –  é o tamanho do vetor.
Exemplo:
              real: media[40];
              inteiro: valor[100];
              alunos : vetor[0..50] de caracter
              dias : vetor[0..31] de inteiros
4.4.1. Leitura de Dados de Uma Matriz do Tipo Vetor
A leitura de um vetor é feita passo a passo, ou seja, um de seus componentes por vez usando a
mesma sintaxe da instrução primitiva da entrada de dados, onde além do nome da variável, deve
ser explicitada a posição do componente lido.
Sintaxe:
leia(<nome_da_variável> [ <índice> ]);
Veja uma figura onde representamos um vetor de 10 posições onde cada uma guarda uma nota
diferente. Para recuperarmos o valor guardado, devemos fazer uma chamada do nome do vetor
passando pra ele qual a posição queremos. Vale lembrar que se passarmos um índice inválido
ocorrerá um erro no algoritmo.
notas : vetor[1..10] de real
escreva(notas[6])

Uma observação importante a ser feita é a utilização da construção para a fim de efetuar a
operação de leitura repetidas vezes em cada uma delas, lendo um determinado componente do
vetor. De fato esta construção é muito comum quando se opera com vetores, devido à necessidade
de se realizar uma mesma operação com os diversos componentes dos mesmos. Na verdade, são
raras as situações que se deseja operar isoladamente com um único componente do vetor.
Um vetor é uma estrutura de dados indexada, ou seja, cada valor pode ser acessado através de
um índice, o qual corresponde a uma posição no vetor os índices são valores inteiros e positivos (0,
1, 2, 3,...); em outras palavras, uma posição específica do vetor pode ser acessada diretamente
através do seu índice.
Abaixo temos o exemplo de uma operação com para, onde temos um vetor notas de 5 posições e
cada uma será atribuída o valor de 1*10 até 5*10 logo após a leitura :
atribuição: leitura:
4.5. Variáveis compostas multidimensionais.
São as variáveis que necessitam mais de um índice para a individualização de seus
elementos. As variáveis multidimensionais podem ser bidimensionais, onde o primeiro elemento
representa a linha e o segundo a coluna. Podem ainda ser tridimensionais, onde o elemento
representa a página (face).
Diagrama:
Diagrama da estrutura no Visualg:

onde:
Li = representa o limite inicial do vetor.
Lf = representa o limite final do vetor.
V = vetor.
Vn = números de vetores.
Tipo primitivo: representa qualquer uns dos tipos básicos de dados.
Dica: Cada vetor é separado por virgula, com isso formamos uma matriz.
4.6. Declaração e manipulação(multidimensionais ).
Para declarar uma matriz multidimensional temos que definir quantas dimensões a mesma
vai possuir. Cada matriz vai ser composta por dois ou mais vetores.
Sintaxe da declaração:
tipo IDENTIFICADOR = matriz [LI1..LF1, LI2..LF2, ..., LIn..LFn] de <tipo>;
Onde:
LI1..LF1, LI2..LF2, ..., LIn..LFn : São os limites dos intervalos de variação dos índices da variável,
onde cada par de limites está associado a um índice; <tipo> : representa qualquer um dos tipos
básicos ou tipo anteriormente definido; lista de variáveis : lista de variáveis (separadas por vírgula)
que terão o mesmo tipo denotado por IDENTIFICADOR.
Exemplo:
tipo SALA = matriz [1..4, 1..4] de inteiro;
tipo M = matriz [1..3, 1..5, 1..4] de inteiro;
No Visualg:
notas : vetor [1..2,1..5] de inteiro
alunos : vetor[1..3,1..20] de caracter
Veja um Exemplo onde temos o seguinte código:

Observe que no código temos uma matriz com duas dimensões onde cada dimensão é um vetor.
Além disso, essa matriz é guardada em uma variável chamada dados, onde ela representa tanto o
nome como a rua de uma determinada pessoa.
4.7. Variáveis compostas heterogêneas.
Já sabemos que um conjunto homogêneo de dados é composto de variáveis do mesmo tipo
primitivo,porém se tivéssemos um conjunto em que os elementos não são do mesmo tipo, teríamos
então um conjunto heterogêneo de dados.
Considerando que os andares de um prédio são divididos em apartamentos temos uma estrutura
multidimensional. Para localizarmos um indivíduo 4 neste prédio precisaremos de seu nome, o
andar e o número do apartamento. Considerando uma estrutura bidimensional (dois índices: andar
e apartamento),o primeiro índice indica a linha e o segundo, a coluna.
O elemento hachurado é referenciado por MSALA [2, 3].
4.8. Registros (declaração e manipulação).
Uma das principais estruturas de dados é o registro. Para exemplificar, imagine uma passagem de
ônibus, que é formada por um conjunto de dados logicamente relacionados, porém de tipos
diferentes, tais como número da passagem (inteiro), origem e destino (caractere), data (caractere),
horário (caractere), poltrona (inteiro), distância (real), que são subdivisões do registro (elementos
do conjunto), também chamadas de campos. Logo, um registro é composto por campos que são
partes que especificam cada um dos dados.
Observe o seguinte formulário abaixo:
Uma das principais estruturas de dados é o registro. Para exemplificar imagine uma identificação
de passageiro, ou seja, aquele formulário de informações que o passageiro entrega ao motorista
antes de embarcar no ônibus junto com a passagem. Ela é formada por um conjunto de informações
logicamente relacionadas, porém de tipos diferentes tais como números de passageiros(inteiro),
idade(inteiro) e o nome do passageiro(caracteres) que são subdivisões do registro (elementos do
conjunto), também chamadas de campo.
Um registro é composto por campos que são partes que especificam cada uma das informações
que o compõe. Uma variável do tipo registro é uma variável composta, pois engloba um conjunto de
dados e é heterogênea (cada campo pode ser de um tipo primitivo diferente).

Diagrama:
Dica: Não existe registro no Visualg, portanto para programação do mesmo usase outras
linguagens que serão visto nos módulos mais adiante.
4.9. Registros de conjuntos (declaração e manipulação).
Para usarmos um registro precisamos primeiramente definir em detalhes como é constituído o
tipo construído, especificando todos os campos e depois, declarar uma ou mais variáveis, associando
os identificadores de variáveis ao identificador do tipo registro. Nas estruturas composta
homogêneas (vetores e matrizes ) utilizamos tipos de dados primitivos como sendo os elementos
dessas estruturas. Agora utilizaremos como componentes dessa estrutura não apenas um tipo
primitivo mas também os tipos construídos, neste caso os registros.
Sintaxe da declaração:
tipo IDENTIFICADOR = registro
tipo1 : campo1;
tipo2 : campo2;
. .
. .
tipon :campon;
fimregistro;
INDENTIFICADOR : lista de variáveis;
Onde:
IDENTIFICADOR: representa o nome associado ao tipo registro construído; tipo1, tipo2, tipon :
representam qualquer um dos tipos básicos ou tipo anteriormente definido; campo1, campo2,
campo : representam nomes associados a cada campo do registro; lista de variáveis : lista de
variáveis (separadas por vírgula) que terão o mesmo tipo denotado por IDENTIFICADOR.
Declaração: Como possuímos um vetor composto de registros, não podemos declarar esse vetor
sem antes ter definido a estrutura de dados de seus elementos(registros);devemos então definir
primeiro o tipo construído registro e depois o vetor.
Exemplo:
tipo REGPASSAGEM = registro
inteiro : numero, poltrona;
caractere: origem, destino,
data, horário;
real: distância;
fimregistro;
REGPASSAGEM : PASSAGEM;

O exemplo corresponde à definição de um modelo REGPASSAGEM de um registro e à criação de
uma área de memória chamada PASSAGEM, capaz de conter sete subdivisões.
Manipulação:
A manipulação de um registro de conjuntos deve obedecer as manipulações próprias de cada
estrutura de dados anteriormente definida.
Para utilizar um campo específico do registro, devemos diferenciar esse campo. Para tal
utilizamos o caractere “.” (ponto) para estabelecer a separação entre o nome do registro e o nome
do campo.
Podemos aplicar uma leitura ou uma escrita direta no registro:
leia(PASSAGEM);
escreva(PASSAGEM);
Exemplo utilizando o registro PASSAGEM:
     início
{definições anteriores}
.
.
leia(PASSAGEM.numero);
leia(PASSAGEM.origem);
.
.
escreva(PASSAGEM);
fim
1°) Diga com suas palavras qual a principal finalidade de uma estrutura de dados.
2°) Qual a diferença de variáveis compostas homogêneas para variáveis compostas heterogêneas.
3°) Qual  a diferença de variáveis compostas unidimensionais para variáveis compostas
multidimensionais.
4°) Como podemos definir o conceito de registro.
5°) Crie um algoritmos que leia um vetor com 20 números de 1...20 e escreva na tela cada um
deles, use escreval (escrever com quebra de linha).
6°) Crie um algoritmo que leia 30 números  de 1... 30  e gere um segundo vetor para receber os
mesmos,porém de maneira invertida,mostre na tela os dois vetores.
7°) Crie um algorítimo que leia 10 números digitados pelo usuário e diga qual foi o maior
numero, use dois vetores de mesmo tipo.
8°) Crie um algoritmo que tenha uma matriz 2 x 3 com base nisso faça:
a) O preenchimento de cada linha digitada pelo usuário.
b) A soma das 2 linhas separadamente.
c) A soma das 3 colunas separadamente.
d) A soma total da matriz.
10°) Observe o seguinte registro:

responda:
a) Quantos campos do tipo inteiro o registro possui.
c) Quantos campos do tipo caracter o registro possui.
d) Declare a forma desse registro em código.
c) Com uma folha de papel criem um algorítimo onde o usuário digite todas essas informações e
logo após ele escreva essas informações na tela.

4.11. Referencias:
http://www.brasilescola.com/filosofia/o-que-logica.htm
http://www.ucb.br/programar/algoritmo/
www.apostilando.com
Logica de Programação(A contrução de Algoritmos e estrutura de
dados) 3° edição.
Autores: André Luiz Villar Forbellone e Henri Frederico Eberspacher

Caro Aluno(a),
Este material tem como objetivo abordar o uso da tecnologia de programação web PHP e a
base de dados MYSQL. Além disso, mostrar a sintaxe e exemplos práticos dos principais
comandos.
Será dividido o conteúdo em dez capítulos, onde, sete deles são dedicados a tecnologia PHP,
um direcionado a tecnologia HTML com PHP, um a comandos SQL voltados para banco de
dados MYSQL, e outro para associação das três tecnologias. Além disso em alguns capítulos
temos exercícios rápidos para fixação do conteúdo visto e ao final de cada capítulo, uma lista
de exercícios propostos.
Não falaremos de ferramentas de edição, onde fica a critério do aluno escolher juntamente
com o seu instrutor qual a ferramenta mais adequada, porem informamos que todas as
imagens e testes executados em nessa apostila teve como base o uso da ferramenta netbeans
para PHP.

PHP e MySQL 53
Capítulo 5. Introdução a PHP
Objetivos
Fazer uma apresentação da linguagem PHP e um pouco da historia; Mostrar quais requisitos
necessários para instalação e configuração de um servidor web para PHP e banco de dados MYSQL.
5.1. O que é PHP
PHP significa: Hypertext Preprocessor . O produto foi originalmente chamado de “Personal Home
Page Tools”, mas como se expandiu em escopo um nome novo e mais apropriado foi escolhido por
votação da comunidade. Você pode utilizar qualquer extensão que desejar para designar um arquivo
PHP, mas os recomendados foram *.php , *.phtml. O PHP está atualmente na versão 5.3.3,
chamado de PHP5 ou, simplesmente de PHP, mas os seus desenvolvedores estão trabalhando para
lançamento da versão 6, que causa uma preocupação para os programadores do mundo todo, uma
vez que, algumas funcionalidades antigas deixam de funcionar quando passaram da versão 4 para a
5.
PHP é uma linguagem de criação de scripts embutida em HTML no servidor. Os produtos
patenteados nesse nicho do mercado são as Active Server Pages(ASP) da Microsoft, o Coldfusion da
Allaire e as Java Server Pages da antiga Sun que foi comprada pela Oracle. PHP é às vezes chamado
de “o ASP de códigofonte aberto” porque sua funcionabilidade é tão semelhante ao
produto/conceito, ou o que quer que seja, da Microsoft.
Exploraremos a criação de script no servidor, mais profundamente, nos próximos capítulos, mas,
no momento, você pode pensar no PHP como uma coleção de supertags de HTML que permitem
adicionar funções do servidor às suas páginas da Web. Por exemplo, você pode utilizar PHP para
montar instantaneamente uma complexa página da Web ou desencadear um programa que
automaticamente execute o débito no cartão de crédito quando um cliente realizar uma compra.
Observe uma representação de como PHP e HTML se comportam:

PHP e MySQL 54
O PHP tem pouca relação com layout, eventos ou qualquer coisa relacionada à aparência de uma
página da Web. De fato, a maior parte do que o PHP realiza é invisível para o usuário final. Alguém
visualizando uma página de PHP não será capaz de dizer que não foi escrita em HTML, porque o
resultado final do PHP é HTML.
O PHP é um módulo oficial do servidor http Apache, o líder do mercado de servidores Web livres
que constitui aproximadamente 55 por cento da World Wide Web. Isso significa que o mecanismo
de script do PHP pode ser construído no próprio servidor Web, tornando a manipulação de dados
mais rápida. Assim como o servidor Apache, o PHP é compatível com várias plataformas, o que
significa que ele executa em seu formato original em várias versões do UNIX e do Windows. Todos
os projetos da Apache Software Foundation – incluindo o PHP – são software de códigofonte
aberto.
5.1.1. Um pouco da História do PHP.
Rasmus Lerdorf, engenheiro de software, membro da equipe Apache é o criador e a força motriz
original por trás do PHP. A primeira parte do PHP foi desenvolvida para utilização pessoal no final
de 1994. Tratavase de um wrapper de PerlCGI que o auxiliava a monitorar as pessoas que
acessavam o seu site pessoal. No ano seguinte, ele montou um pacote chamado de Personal Home
Page Tools (também conhecido como PHP Construction Kit) em resposta à demanda de usuários
que por acaso ou por relatos falados depararamse com o seu trabalho. A versão 2 foi logo lançada
sob o título de PHP/FI e incluía o Form Interpreter, uma ferramenta para analisar sintaticamente
consultas de SQL.
Em meados de 1997, o PHP estava sendo utilizado
mundialmente em aproximadamente 50.000 sites. Obviamente
estava se tornando muito grande para uma única pessoa
administrar, mesmo para alguém concentrado e cheio de energia
como Rasmus. Agora uma pequena equipe central de
desenvolvimento mantinha o projeto sobre o modelo de “junta
benevolente” do códigofonte aberto, com contribuições de
desenvolvedores e usuários em todo o mundo. Zeev Suraski e Andi
Gutmans, dois programadores israelenses que desenvolveram os
analisadores de sintaxe PHP3 e PHP4, também generalizaram e
estenderam seus trabalhos sob a rubrica de Zend.com (Zeev, Andi,
Zend, entendeu?).
O quarto trimestre de 1998 iniciou um período de crescimento explosivo para o PHP, quando
todas as tecnologias de códigofonte aberto ganharam uma publicidade intensa. Em outubro de
1998, de acordo com a melhor suposição, mais de 100.000 domínios únicos utilizavam PHP de
alguma maneira. Um ano depois, o PHP quebrou a marca de um milhão de domínios. Enquanto
escrevo esta apostila, o número explodiu para cerca de dois milhões de domínios.
5.2. Instalação do Servidor PHP
As requisições são feita de forma cliente servidor, onde um determinado cliente faz uma
requisição a um servidor, ele por sua vez recebe a requisição e faz todo o processo em diferentes
camadas, retornando somente o que o cliente(browser) solicitou.
Para o funcionamento do PHP é necessário a instalação de um serviço dentro de um sistema
operacional, esse serviço e proporcionado através do Apache que é compatível com o protocolo
HTTP. Além disso é preciso instalar a versão do PHP5 para um funcionamento mais compatível com
as maioria das páginas PHP. Outro serviço é o banco de dados, onde futuramente estaremos
trabalhando com ele. O banco de dados que usaremos é o MYSQL.
Normalmente essa instalação é chamada de LAMP(Linux, Apache, MYSQL, PHP) voltada para
sistemas operacionais Linux, como também WAMP(Windows, Apache, MYSQL, PHP) voltada para
sistemas operacionais Windows. Será visto a instalação do LAMP uma vez que esse material e

PHP e MySQL 55
voltado para Linux Educacional e por se tratar de uma instalação mais “complicada”, e também a
ferramenta phpMyAdmin usada para administrar banco de dados MYSQL.
5.2.1. Instalação Apache.
O apache é um dos principais aplicativo para o funcionamento de programas web feito em PHP,
existe duas grandes versões, o apache 2.x e o Apache 1.3, que apesar de antigo ainda é muito
utilizado em servidores. O Apache 2 trouxe muitas vantagens, sobretudo do ponto de vista do
desempenho além de oferecer novos módulos e mais opções de segurança. Mas sua adoção foi
retardada nos primeiros anos por um detalhe muito simples: o fato de ele ser incompatível com os
módulos compilados para o Apache 1.3. Como os módulos são a alma do servidor web, muitos
administradores ficavam amarrados ao Apache 1.3 devido à falta de disponibilidade de alguns
módulos específicos para o Apache 2.
Iremos trabalhar com o Apache2 em sua versão para Linux, o procedimento de instalação é
simples pois precisamos apenas de uma conexão com a internet e alguns comando, outra forma de
instalação e baixando o mesmo no site: http://httpd.apache.org/ e instalando de forma manual.
Para instalarmos precisamos abrir o konsole atualizar o nosso repositório do Linux:
Digite sudo su,ou sudo e o nome do usuário root para ter permissões dentro do Konsole, logo
após como o computador em rede com a internet atualize os repositórios:
#aptget update
Apartir de agora podemos instalar o apache:
#aptget install apache2
Espere até a conclusão de toda instalação. Por padrão o apache automaticamente inicializa,
podendo ser utilizado após isso. Digite no http://127.0.0.1/ ou http://localhost/ no browser,
deverá aparecer a seguinte tela:
Isto mostra que o apache estar funcionando corretamente. Tratase de um texto dentro de um
arquivo HTML que vem como padrão dentro da pasta var/www , essa é a pasta principal do
apache, onde trabalharemos com os arquivos PHP.
O apache pode ser configurado de forma que podemos acessar mais de uma página com ip's ou
portas diferentes,ou seja podemos ter www1,www2 … em uma mesma maquina servidora fazendo
acesso por endereços como http://localhost:8060 ou http://localhost:82, entre outros. Mas
trabalharemos apenas com a configuração padrão do apache, uma vez que existe muito conteúdo a
respeito desse assunto na internet. Para obter mais informações consulte a documentação do site
oficial do apache: http://httpd.apache.org/docs/2.2/

PHP e MySQL 56
5.2.2. Instalação Php5.
Para o funcionamento dos programas em PHP precisamos de algumas dependências, onde
funcionalidades, funções, classes e suporte a XML então embutidas. Por exemplo, se você quiser
utilizar orientação a objeto ou simplesmente fazer uma conexão com o banco de dados, é
necessário a instalação do PHP5, onde algumas bibliotecas serão instaladas para dar suporte aos
programas em PHP.
Após instalar do apache e com o konsole logado como root podemos instalar o PHP5 com o
seguinte comando:
#aptget install php5
Após a conclusão da instalação, podemos testar criando um arquivo dentro da pasta
var/www.
Entre na pasta principal:
cd /var/www
Renomeie o arquivo index.html para outro nome:
#mv index.html nome.html
Qualquer arquivo com o nome “index” dentro da pasta www será o primeiro arquivo a ser
executado. Lembrando que pode existir somente um arquivo “index” na pasta. Após renomear
criaremos um novo arquivo.
#kate index.php
Após executar esse comando, digite o seguinte código no editor de texto kate:
Nesse momento estamos criando uma aplicação PHP que chama a função phpinfo() que tem
como finalidade mostra informações sobre configuração do PHP.
Abra o Browser e digite http://localhost/, se tudo estiver correto, observaremos seguinte tela:

PHP e MySQL 57
5.2.3. Instalação MYSQL.
Agora veremos a instalação do banco de dados MYSQL, onde trabalharemos com essa base de
dados nos capítulos finais dessa apostila.
Logando no konsole como root digite o seguinte comando:
#aptget install mysqlserver
Obs.: em certo momento aparecerá uma tela pedindo a senha de root do banco de dados,
digite a senha que o seu instrutor definir, logo após confirme a senha digitandoa
novamente.
Para testarmos o nosso banco de dado utilize o seguinte comando:
#mysql u root p
u pede o usuário no caso o usuário do banco é o root.→
p pede a senha logo em seguida.→
Se tudo sair como planejado você devera logar no banco de dados:
mysql>
para sair digite exit e der um enter:
5.2.4. Instalação phpMyAdmin.
Instalaremos agora uma ferramenta para gerenciamento do banco de dados MYSQL.
O phpMyAdmin é uma ferramenta feita em PHP, onde podemos executar de forma visual muitos
dos comandos usados no MYSQL. Podese tambem configurar o próprio SGBD(Sistema de
gerenciamento de banco de dados).
O primeiro passo para instalação é estar logado no konsole como usuário root(sudo su, ou sudo
e o nome do usuário root).
Use o seguinte comando para instalar o phpMyAdmin:
#aptget install phpmyadmin
Logo após aparecerá uma tela pedindo a senha do banco de dados, justamente aquela que foi
digitada quando estava instalando o MYSQL.
Espere a instalação concluir.
Agora precisamos copiar o phpMyAdmin pra dentro da pasta var/www com o seguinte comando:
cp r /usr/share/phpmyadmin/ /var/www/
r → copia o diretórios recursivamente(substituindo caso já exista).
Para acessar essa ferramenta digite no Browser: http://localhost/phpmyadmin, digite login: root,
e a senha do banco de
dados que foi definida
na instalação do
MYSQL, se tudo
estiver correto temos
a seguinte tela como
mostra ao lado:

PHP e MySQL 58
5.3. Características de um programa PHP.
Assim como qualquer linguagem de programação, o PHP tem algumas características
importantes, ao criamos um arquivo PHP podemos usar a seguinte extensão:
*.php     Arquivo PHP contendo um programa.→
*.class.php     Arquivo PHP contendo uma classe(veremos o conceito de classe mais adiante).→
*.ini.php   Arquivo PHP a ser incluído, pode incluir constantes ou configurações.→
Outras extensões podem ser encontradas principalmente em programas antigos:
*.php3     Arquivo PHP contendo um programa PHP versão 3.→
*.php4     Arquivo PHP contendo um programa PHP versão 4.→
*.phtml Arquivo PHP contendo um programa PHP e HTML na mesma página.→
Vale ressaltar que o simbolo asterisco (*) simboliza qualquer nome a ser atribuído ao arquivo PHP.
Alem disso o código de um programa escrito em PHP deve estar contido entre os seguintes
delimitadores:

      ou
Ambos delimitadores são válidos, porém para o funcionamento do segundo delimitado é
necessário a ativação dessa opção no apache.
Dica: Em alguns servidores apache a ativação do short_open_tag é necessária,
passando o seu valo de 0 (desativado) para 1 (ativado), porém por padrão o seu
valor é 1, o mesmo é encontrado no arquivo php.ini .
Outro fator importante para quem está programando é sempre ter boas técnicas de programação,
entre elas podemos citar os comentários nos códigos fonte, sempre e aconselhável comentar os
trechos mais importantes, onde tanto o programador quanto outra pessoa ao analisar o código,
possa identificar pelos comentários trechos importantes que possa ser alterados ou não.
Para comentar uma única linha nos código PHP podemos utilizar tanto o separador “//” como
também “#”, observe o exemplo abaixo:
Lembrando que os comentários são trechos de código que não são executados, onde eles servem
somente para quem tem acesso aos códigosfonte ou está ligado diretamente a programação desse
código. Podemos também comentar muitas linhas, isso serve quando queremos que boa parte do

PHP e MySQL 59
código não execute ou simplesmente colocar um comentário mais extenso, observe o exemplo
abaixo:

ou
5.3.1. COMANDOS DE SAÍDA(OUTPUT)
São comandos utilizados para gerar uma saída em tela(output). Se o programa PHP for
executado via servidor de páginas web(Apache ou IIS), a saída será exibida na própria página
HTML gerada no Browser(navegador), assim será mostrado de acordo com o conteúdo existente na
saída, por exemplo, se tivermos o seguinte: “<h2> Hello Word! <h2>”, será mostrado no
navegador apenas a mensagem Hello Word! em um tamanho maior, pois tratase de um código
HTML dentro de comandos PHP.
Podemos então usar os seguintes comandos para gerar comandos de saída: echo e print.
echo
É um comando que imprime uma ou mais variáveis ou textos, onde os mesmos são colocados em
aspas simples ' ' ou duplas “ ”. Sintaxe:
echo 'a','b','c';
resultado:
abc
print
É uma função que imprime uma String(texto) no console. Exemplo:
print( ' apostila de PHP ' );
resultado:
apostila de PHP
Observe um exemplo com o uso de echo e print:
Código: Saída no Browser:

PHP e MySQL 60
1°) Como podemos definir PHP e qual a sua relação com HTML.
2°) Descreva um exemplo estrutural relacionando tag's HTML e delimitações PHP.
3°) Quais aplicativos básicos podemos instalar para criarmos um servidor de páginas em PHP.
4°) Em relação ao apache, qual a sua principal finalidade.
5°) Quais as principais extensões de arquivos PHP e diga a diferença entre elas.
6º) Crie dois exemplos de código PHP usando seus delimitadores.
7°) Qual as finalidades de usar comentários dentro de um códigofonte.
8°) Cite os principais comandos de saída usados em PHP.
9°) Qual a diferença entre echo e print.
10°) Observe o seguinte código e diga qual o item correto:
<?php
//página web.
echo '<h1>Olá, essa é sua primeira página!<h1>';
echo '<h2>Responda!</h2>' print 'O que é PHP?';
print 'Qual sua finalidade?'; echo '<h4>Resposta: item a!</h4>';
?>
I Esse código pode ser interpretado pelo apache normalmente.
II As tag's HTML são interpretadas pelo servidor.
III Esse código possui erros.
IV As tag's são interpretada pelo navegador do cliente.
a) I,II,IV estão corretas.
b) somente a I está correta.
c) III, IV estão correta.
d) somente IV está correta.
e) I e IV estão corretas.
Prático:
11°) Crie um arquivo PHP dentro da pasta www com o nome index.php, após isso pegue o código
anterior e adicione a esse arquivo, defina quais textos são visualizadas em seu navegador. Caso
exista erros,faça uma correção.
12°) Crie dois arquivos diferentes, um com nome index.php, outro com o nome teste.php, após
isso inclua o arquivo teste.php dentro do arquivo index.php, ambos arquivos deverá ter no seu
código impresso mensagens diferentes utilize o comando print.

PHP e MySQL 61
Capítulo 6. Atribuições em PHP
Objetivos
Mostrar a definição de variáveis e os seus tipos; Mostrar como podese atribuir um valor a ela, seu
uso e aplicação em PHP; Mostrar o definição de constantes e sua importância.
6.1. Variáveis
Variáveis são identificadores criados para guardar valores por determinado tempo. Em PHP elas
são declaradas e inicializadas, porém são armazenadas na memória RAM do servidor web. Esse é
um dos motivos pelo qual os servidores precisam de grande quantidades de memória.
Imagine um servidor com mais de 20 mil acessos simultâneos ao mesmo tempo, onde cada
usuário está acessando a mesma página feita em PHP. São criadas neste processo variáveis
diferentes para cada usuário, logo, isso faz com que muitos processos sejam gerados e processados
pelo servidor.
A tipagem em PHP é dinâmica, ou seja, as variáveis não precisam ser obrigatoriamente
inicializadas após a declaração. Uma variável é inicializada no momento em que é feita a primeira
atribuição. O tipo da variável será definido de acordo com o valor atribuído. Esse é um fator
importante em PHP, pois uma mesma variável pode ser de um mesmo tipo ou não, e pode assumir
no decorrer do código um ou mais valores de tipos diferentes.
Para criar uma variável em PHP, precisamos atribuirlhe um nome de identificação, sempre
procedido pelo caractere cifrão ($). Observe um exemplo:


Para imprimirmos as duas variáveis usamos aspas duplas no comando echo, no exemplo anterior
temos a seguinte saída:

Obs.: Podem acontecer erros na exibição das mensagens por conta das codificações de
acentuação. Caso isso aconteça, mude a codificação do seu navegador ou utilize as metas
de codificação.
Algumas dicas Importantes:
• Nomes de variáveis devem ser significativa e transmitir a ideia de seu conteúdo dentro
do contexto no qual está inserido.
• Utilize preferencialmente palavras em minúsculo (separadas pelo caracter “_”) ou somente as
primeiras letras em maiúsculo quando da ocorrência de mais palavras.
• Nunca inicie a nomenclatura de variáveis com números.   Ex: $1nota;

PHP e MySQL 62
• Nunca utilize espaço em branco no meio do identificados da variável.  Ex: $nome um;
• Nunca utilize caracteres especiais( ! @ # ^ & * / | [ ] { } ) na nomenclatura das variáveis.
• Evite criar variáveis com mas de 15 caracteres em virtude da clareza do códigofonte.
Exemplo:
<?PHP
$codigo_cliente;   //exemplo de variável
$codigoCliente;   //exemplo de variável
?>
Com exceção de nomes de classes e funções, o PHP é case sensitive, ou seja, é sensível a letras
maiúsculas e minúsculas. Tome cuidado ao declarar variáveis. Por exemplo a variável $codigo é
tratada de forma totalmente diferente da variável $Codigo.
Em alguns casos, precisamos ter em nosso códigofonte nomes de variáveis que podem mudar de
acordo com determinada situação. Neste caso, não só o conteúdo da variável é mutável, mas
também variante (variable variables). Sempre que utilizarmos dois sinais de cifrão ($) precedendo o
nome de uma variável, o PHP irá referenciar uma variável representada pelo conteúdo da primeira.
Nesse exemplo, utilizamos esse recurso quando declaramos a variável $nome (conteúdo de
$variável) contendo 'maria'.
Resultado = maria.
Quando uma variável é atribuída a outra, sempre é criada uma nova área de armazenamento na
memória. Veja neste exemplo que, apesar de $b receber o mesmo conteúdo de $a, após qualquer
modificação em $b, $a continua com o mesmo valor,veja:
Para criar referência entre variáveis, ou seja, duas variáveis apontando para a mesma região da
memória, a atribuição deve ser precedida pelo operador &. Assim, qualquer alteração em qualquer
uma das variáveis reflete na outra,veja:

PHP e MySQL 63
No exemplo anterior percebemos que tanto $a como $b apontam para a mesma referência na
memoria, dessa forma se atribuirmos um novo valor em $a ou em $b, esse valor será gravado no
mesmo endereço, fazendo com que, ambas variáveis possam resgatar o mesmo valor.
6.2. Tipos de Variáveis
Algumas linguagens de programação tem suas variáveis fortemente “tipadas”, diferentemente
disso o PHP tem uma grande flexibilidade na hora de operar com variáveis. De fato, quando
definimos uma variável dandolhe um valor, o computador atribuilhe um tipo. Isso permite que o
programador não se preocupe muito na definição de tipos de variáveis, uma vez que isso é feita de
forma automática. Porém deve ter cuidado com as atribuições de valores, evitando erros na hora de
iniciar uma variável em PHP.
6.2.1. Tipo booleano.
Um booleano expressa um valor lógico que pode ser verdadeiro ou falso. Para especificar um
valor booleano, utilize a palavrachave TRUE para verdadeiro ou FALSE para falso. No exemplo a
seguir, declaramos uma variável booleana $exibir_nome, cujo conteúdo é TRUE(verdadeiro). Em
seguida, testamos o conteúdo dessa variável para verificar se ela é realmente verdadeira
imprimindo na tela caso seja. Usaremos a estrutura IF, uma estrutura de controle que veremos com
mais detalhes no capitulo 4, para testar a variável. Observe:
Resultado = 1 (esse valor representa verdadeiro ou true).
Também podemos atribuir outros valores booleanos para representação de valores falso em
operação booleanas.
• Inteiro 0 ;
• Ponto flutuante 0.0 ;
• Uma String vazia “ ” ou “0” ;
• Um array vazio ;
• Um objeto sem elementos ;
• Tipo NULL .
6.2.2. Tipo inteiro
São os números que pertencem ao conjunto dos números inteiros, abrangendo valores negativos e
positivos, tratase de valores decimais.

PHP e MySQL 64
6.2.3. Tipo ponto flutuante:
Os números de ponto flutuante (floats e doubles) são números com casas decimais, onde a
vírgula é substituída por um ponto. Exemplo:
6.2.4. Tipo numérico
Números podem ser especificados em notação decimal (base 10), hexadecimal (base 16) ou octal
(base 8), opcionalmente precedido de sinal ( ou +), esse tipo abrange todos os valores abaixo:
Não entraremos em detalhes em relação a conversão desses valores, porém que fique claro a ideia
de que uma variável numérica pode assumir diferentes tipos de valores.
6.2.5. Tipo String
Uma string é uma cadeia de caracteres alfanuméricos. Para declarálas podemos utilizar aspas
simples ( ' ' ) ou aspas duplas ( “ ” ). Exemplo:
Observe na tabela abaixo o que podemos também inserir em uma String:
Sintaxe Significado
n Nova linha
r Retorno de carro (semelhante a n)
t Tabulação horizontal
A própria barra ( )
$ O símbolo $
’ Aspa simples
” Aspa dupla
Observe o exemplo:
Resultado: tipo de dado: 'inteiro'

PHP e MySQL 65
6.2.6. Tipo array
Array é uma lista de valores armazenados na memória, os quais podem ser de tipos diferentes
(números, strings, objetos) e podem ser acessados a qualquer momento, pois cada valor é
relacionado a uma chave. Um array também pode crescer dinamicamente com a adição de novos
itens. Veja no capitulo 6 como manipular esse tipo de estrutura.
6.2.7. Tipo objeto
Um objeto é uma entidade com um determinado comportamento definido por seus métodos
(ações) e propriedade (dados). Para criar um objeto devese utilizar o operador new. Para mais
informações sobre orientação a objeto, consulte o site http:// php.net   e pesquise sobre object.
6.2.8. Tipo recurso
Recurso (resource) é uma variável especial que mantém uma referência de recursos externos.
Recursos são criados e utilizado por funções especiais, como uma conexão ao banco de dados. Um
exemplo é a função mysql_connect(), que ao conectarse ao banco de dados, retorna um variável de
referência do tipo recurso. Exemplo:
Resource mysql_connect(...)
Outro exemplo:
mysql_fetch_row(...)
6.2.9. Tipo null
Quando atribuímos um valor do tipo null(nulo) a uma variável estamos determinando que a
mesma não possui valor, e  que seu único valor é nulo. Exemplo:
$abc = null;
6.3. Constantes
6.3.1. Constantes prédefinidas
O PHP possui algumas constantes prédefinidas, indicando a versão do PHP, o Sistema
Operacional do servidor, o arquivo em execução e diversas outras informações. Para ter acesso a
todas as constantes prédefinidas, podese utilizar a função phpinfo(), que exibe uma tabela
contendo todas as constantes prédefinidas, assim como configurações da máquina, sistema
operacional, servidor HTTP e versão do PHP instalada, como foi feito em exemplos anteriores.
6.3.2. Definindo constantes
Para definir constantes utilizase a função define. Uma vez definido, o valor de uma constante
não poderá mais ser alterado. Uma constante só pode conter valores escalares, ou seja, não pode
conter nem um array nem um objeto. A assinatura da função define é a seguinte:
define("NOME_DA_CONSTANTE","valor inalterável");
Exemplo:
   Resultado:
valor inalterável

PHP e MySQL 66
O nome de uma constante tem as mesmas regras de qualquer identificador no PHP. Um nome de
constante válida começa com uma letra ou sublinhado, seguido por qualquer número de letras,
números ou sublinhados. Você pode definir uma constante utilizandose da função define(). Quando
uma constante é definida, ela não pode ser mais modificada ou anulada.
Estas são as diferenças entre constantes e variáveis:
• Constantes podem ser definidas e acessadas de qualquer lugar sem que as regras de
escopo de variáveis sejam aplicadas;
• Constantes só podem conter valores escalares.
• Constantes não podem ter um sinal de cifrão ($) antes delas;
• Constantes só podem ser definidas utilizando a função define( ), e não por simples
assimilação;
• Constantes não podem ser redefinidas ou eliminadas depois que elas são criadas;
6.4. Conversão de variável
PHP utiliza checagem de tipos dinâmica, ou seja, uma variável pode conter valores de diferentes
tipos em diferentes momentos da execução do script. Por este motivo não é necessário declarar o
tipo de uma variável para usála. O interpretador PHP decidirá qual o tipo daquela variável,
verificando o conteúdo em tempo de execução.
Ainda assim, é permitido converter os valores de um tipo para outro desejado, utilizando o
typecasting ou a função settype (ver adiante).
Assim podemos definir novos valores para terminadas variáveis:
typecasting Descrição
(int),(integer) Converte em inteiro.
(real),(float),(double) Converte em ponto flutunte.
(string) Converte em string.
(object) Converte em objeto.
Exemplos:
Convertendo de ponto flutuante para inteiro.
Resultado:
208
Convertendo de String para Object.
Resultado:
stdClass Object ( [scalar] => Bem vindo ao site! )

PHP e MySQL 67
Convertendo de inteiro para ponto flutuante.
Resultado:  542
O resultado poderia ser 542.0, mas lembrando que o interpretador do PHP faz outra conversão ao
notar que o numero 542.0 tem a mesma atribuição de 542. O resultado seria o mesmo se tentarmos
atribuir $a = 542.0.
1°) Qual a principal finalidade de uma variável?
2°) O que significa tipagem automática.
3°) Cite algumas dicas importantes na  nomenclatura de variáveis:
4°) Das variáveis abaixo, quais possuem nomenclaturas válidas.
$a___b;                     $a_1_;               $_início;
$@nome;                  $val_!;               $nome;
$a_|_;                       $#valor;            $palavra;
$tele#;           $123;                 $__=__;
$VALOR_MAIOR;      $____;               $all;
Resposta: __________________________________________________________________________
5º) Crie dez variáveis atribuindo valores diversos, logo após use o comando echo pra imprimir na
tela do browser, exemplo:
<?php
$nome = “Maria Cavalcante”;
echo $nome;
....
?>
6°) Quais os tipos de variáveis que podemos citar em PHP.
8°) Como podemos distinguir um tipo de variável de outro, uma vez que a tipagem é feita de forma
automática em PHP.
9°) Faça a ligação com os seguintes tipos:
1 $var = 10;                        (  )ponto flutuante.
2 $var = “palavra”;             (  )tipo null.
3 $var = 10.22;                   (  )tipo objeto.
4 $var = true;                      (  )String.
5 $var = null;                      (  )numérico.
6 $var = new abc;                (  )booleano.
10°) Qual a principal finalidade de um constante e como elas são definidas em PHP.
11°) Em que momentos precisamos converter uma variável de um tipo em outro.
12°) Quais os typecasting usados em PHP.
14°) crie uma constante com o comando define e imprima com o comando print();
13°) Crie conversões e imprima na tela com o comando print() com as seguintes variável.
$var1 = “paralelepípedo”,  $var2 = 15.20, $var3 = 10.
a) converta a variável $var1 em objeto.
b) converta a variável $var3 em ponto flutuante.
c) converta a variável $var2 em inteiro.

PHP e MySQL 68
Capítulo 7. Operadores em PHP
Objetivos
Demostrar os tipos e quais os operadores; Falar do conceito de atribuição e concatenação de strings;
Exemplificar os operadores, sua importância e funcionamento.
Os operadores tem seu papel importante dentro de qualquer linguagem de programação. É
através deles que podemos realizar diversos operações dentro de um programa, seja ela de
atribuição, aritmética, relacional, lógico, dentre outros. Em PHP não é diferente, os operadores são
utilizados constantemente, porém existem algumas regras que veremos mais adiante.
7.1. Operadores de strings
São operadores utilizados para unir o conteúdo de uma string a outra, com isso podemos dizer
que há dois operadores de string. O primeiro é o operador de concatenação ('.') que já utilizamos
em exemplos anteriores, ele retorna a concatenação dos seus argumentos direito e esquerdo. O
segundo é o operador de atribuição de concatenação ('.='), que acrescenta o argumento do lado
direito no argumento do lado esquerdo.
Observe o exemplo abaixo:
Nesse exemplo podese observar a declaração da variável $d, logo após temos uma inicialização e
atribuição de concatenação em uma mesma linha, isso é possível em PHP, deixando o código mais
otimizado porém menos legível.
7.2. Operadores de atribuição
O operador básico de atribuição é "=" (igual). Com ele podemos atribuir valores as variáveis
como foi visto em exemplos anteriores. Isto quer dizer que o operando da esquerda recebe o valor
da expressão da direita (ou seja, "é configurado para"). Mas podemos usar algumas técnicas,
observe o exemplo abaixo:
Resultado: a = 9,b = 4
Além do operador básico de atribuição, há "operadores combinados" usados para array e string,
eles permitem pegar um valor de uma expressão e então usar seu próprio valor para o resultado
daquela expressão.

PHP e MySQL 69
Por exemplo:
Resultado: a = 8,b = Bom Dia!
Observe a expressão:  $a = 3 e logo após $a+=5. Isto significa a mesma coisa de $a = $a + 5,
ou,  $a = 3 +5. A ideia pode ser usada para string, como foi feito com a variável $b, onde $b =
“Bom”, logo após usamos ponto(.) e igual(=) para concatenar os valores, ficando assim:
$b.=”Dia!”. Lembrando que isso significa a mesma coisa que $b = $b.“Dia”. Observe mais um
exemplo:
Resultado:  Bom Dia turma
Podemos definir uma sequencia com duas concatenações, onde $a = “Dia”.“turma” e logo após
temos $b = “Bom”.“Dia turma”.
Os operadores de atribuição são usados para economizar linhas de código, deixando assim o
código mais funcional e otimizado. A tabela abaixo mostra os principais operadores de atribuição:
Operadores Descrição
= Atribuição simples.
+= Soma, depois atribui.
= Subtrai, depois atribui.
*= Multiplica, depois atribui.
/= Divide, depois atribui.
%= Modulo(resto) da divisão, depois atribui.
.= Concatena, depois atribui.
Exemplo:

PHP e MySQL 70
Observe mais um exemplo aplicando os demais operadores.
Resultado:
24
8
2
Vale ressaltar que a cada echo, o valor de $a sofre modificações. Isso devido a atribuição feita
após a operação. Usamos o operador ponto(.) para concatenar os valores obtidos com <br> código
usado em HTML para quebra de linha.
7.3. Operadores de decremento e incremento
São operadores  usados para atribuir em 1 ou 1 a variável, isso pode ser feito antes ou depois da
execução de determinada variável. A tabela abaixo mostra tais operadores:
++$a Préincremento. Incrementa $a em um e, então, retorna $a.
$a++ Pósincremento. Retorna $a, então, incrementa $a em um.
$a Prédecremento. Decrementa $a em um e, então, retorna $a.
$a Pósdecremento. Retorna $a, então, decrementa $a em um.
Exemplo:
Nesse exemplo temos uma forma aplicada do uso de decremento e incremento, lembrando que a
variável $a pode ter qualquer nome. Também podemos fazer um comparativo com o Préincremento
ou incrementoprefixado com operações que já conhecemos,  observe:
Operador Forma extensa. Forma simplificada
++$a $a = $a + 1 $a+=1
$a $a = $a 1 $a =1

PHP e MySQL 71
7.4. Operadores aritméticos
Os operadores aritméticos são operadores que já conhecemos, porém com a exceção de %
(modulo) onde ele retorna como resultado o resto da divisão entre dois valores.
+ Adição.
Subtração.
* Multiplicação.
/ Divisão.
% Módulo ou resto da divisão.

Exemplo:
Nesse exemplo fizemos algumas
operações, porém ao utilizar
parênteses, estamos
determinando quem executa
primeiro, no caso a soma de
$b+5.
7.5. Operadores relacionais
Os operadores relacionais, ou conhecidos também como operadores de comparação, são
utilizados para fazer determinadas comparações entre valores ou expressões, resultando sempre um
valor booleano verdadeiro ou falso(TRUE ou FALSE). Para utilizamos esses operadores usamos a
seguinte sintaxe:
( valore ou expressão ) + ( comparador) + ( segundo valor ou expressão )
Observe a tabela abaixo:
Comparadores Descrição
== Igual. Resulta em TRUE se as expressões forem iguais.
=== Idêntico. Resulta em TRUE se as iguais e do mesmo tipo de dados.
!= ou <> Diferente. Resulta verdadeiro se as variáveis foram diferentes.
< Menor ou menor que. Resulta TRUE se a primeira expressão for menor.
> Maior ou maior que. Resulta TRUE se a primeira expressão for maior.
<= Menor ou igual. Resulta TRUE se a primeira expressão for menor ou igual.
>= Maior ou igual. Resulta TRUE se a primeira expressão for maior ou igual.
Veja um exemplo prático:
$a <= $b
Compara se $a é menor ou igual a $b, onde, retorna verdadeiro (TRUE), caso contrário retorna
falso(FALSE).
Para testarmos essas comparações podemos utilizar o condicional “?:” (ou ternário), sua sintaxe
é a seguinte:

PHP e MySQL 72
(expressão booleana) ? (executa caso verdadeiro) : (executa caso falso);
Agora podemos ver um exemplo envolvendo as sintaxes e empregabilidade dos comparadores:
Nesse exemplo declaramos e iniciamos três variáveis. Usamos então o comando echo para
imprimir o resultado, onde o condicional “?:” foi utilizado. Iniciamos as comparações de $a, $b e
$c, caso a comparação individual retorne TRUE, imprime verdadeiro, caso retorne FALSE, imprime
falso. Observe que o comparador “===” compara o valor e o tipo, retornando FALSE por $b se
tratar de um tipo inteiro, e $c um tipo ponto flutuante, já o comparador “==” compara somente os
valores onde 45 é igual a 45.0 retornando verdadeiro. Também podemos usar o operador “!==”
onde tem a função semelhantemente ao operador “!=” , mas retorna TRUE se os tipos forem
diferentes. Se a variável for do tipo booleano, podemos comparálos assim:
$a == TRUE, $a == FALSE
7.6. Operadores lógicos ou booleanos
São chamados de operadores lógicos ou booleanos por se tratar de comparadores de duas ou
mais expressões lógicas entre si, fazendo agrupamento de testes condicionais e tem como retorno
um resultado booleano.
Na tabela abaixo temos os operadores e suas descrições:
Operador Descrição
( $a and $b ) E : Verdadeiro se tanto $a quanto $b forem verdadeiros.
( $a or $b ) OU : Verdadeiro se $a ou $b forem verdadeiros.
( $a xor $b ) XOR : Verdadeiro se $a ou $b forem verdadeiro, de forma exclusiva.
( ! $a ) NOT : Verdadeiro se $a for falso, usado para inverter o resultado da condição.
($a && $b) E : Verdadeiro se tanto $a quando $b forem verdadeiros.
($a || $b) OU : Verdadeiro se $a ou $b forem verdadeiros.
Obs.: or e and tem procedência maior que && ou ||, ou seja, em uma comparação
extensa, onde ambos estão aplicados. Eles tem prioridade de executar sua comparação
primeiro.
No próximo exemplo usamos os operadores lógicos que tem procedência maior:

PHP e MySQL 73
Em outro exemplo temos os operadores lógicos mais comuns:

Também podemos atribuir valores as variáveis usando os operadores lógicos:
O primeiro echo mostra 2 e 0, pois não atribui valor a $b
uma vez que a primeira condição já é satisfatória.
O segundo echo mostra 5 e 3, pois tanto a primeira quanto
a segunda precisam ser executadas.
7.7. Precedência de Operadores
Agora já conhecemos uma boa quantidade de operadores no PHP, falta agora conhecer a
precedência de cada um deles, ou seja, quem é mais importante, qual operador é avaliado primeiro
e qual é avaliado em seguida. Observe o seguinte exemplo:
O resultado será 17, pois o operador * tem maior precedência em relação ao operador +.
Primeiro ocorre a multiplicação 2*6, resultando em 12, em seguida a soma de 5 + 12. Caso desejar
realizar a operação com o operador + para só em seguida realizar a operação com o operador *,
temos que fazer conforme o exemplo abaixo:
Observe que utilizamos os parênteses para determinarmos quem deve ser executado primeiro,

PHP e MySQL 74
assim alterando o resultado para 42. Os parênteses determina qual bloco de código executa
primeiro, e também serve para isolar determinadas operações. Veja mais um exemplo onde as
operações são feitas separadamente. Primeiro executa a soma, em seguida a subtração e só então é
executado a multiplicação, imprimindo um resultado fina 21 :
Exemplo:
A tabela seguinte mostra a precedência dos operadores, da maior precedência no começo para os
de menor precedência.
Operador Descrição
! ++ Negativo, negação, incremento e decremento
* / % Multiplicação, divisão e resto da divisão
+ . Adição, subtração e concatenação
> < >= <= Maior que, menor que, maior ou igual e menor ou igual
== != <> Igual e diferente
&& E
|| OU
= += = *= /= %= Operadores de atribuição
AND E com menor prioridade
XOR Ou exclusivo
OR Ou com menor prioridade
É importante lembrar que primeiro o PHP executará todas as operações que estiverem entre
parênteses, se dentro dos parênteses houver diversas operações, a precedência dos operadores será
utilizada para definir a ordem. Após resolver todas as operações dos parentes, o PHP volta a
resolver o que esta fora dos parênteses baseandose na tabela de precedência de operadores.
Havendo operadores de mesma prioridade o PHP resolverá a operação da esquerda para direita.
Também podemos trabalhar com procedência de parênteses, fazendo associações com um ou
mais operadores, observe o seguinte exemplo:
Seguindo a ordem de procedência temos:
(5) * (6) / (16 ((7)*2)) >>> 5 * 6 / (16 (14)) >>> 5 * 6 / 2 >>> 30 / 2
Resultado : 15
Observe que primeiro executa todos os parênteses, e só então temos as procedência das demais
operações.

PHP e MySQL 75
1°) Qual a finalidade dos operadores de strings.
2°) Quais os operadores de decremento e incremento, cite alguns exemplos:
3°) Qual a finalidade do operador aritmético %(modulo).
4°) Cite os operadores relacionais, mostre alguns exemplos.
5°) Quais operadores lógicos ou booleanos.
6°) Quais os operadores de atribuição.
7°) Qual a sintaxe do uso de ternário e cite um exemplo.
8°) Quais os operadores utilizados e o resultado final do código abaixo:
<?php
$a =10;
$b = 12.5;
$c = $a+$b;
print($a>$b? “verdadeiro” : “falso”);
print($c>=$b? “verdadeiro” : “falso”);
?>
9°)Observe o código abaixo e diga quais das operações são executadas primeiro, coloque a resposta
em ordem decrescente.
$a = 8*5-3+4/2+19%5/2+1;
10°)Faça testes com os operadores relacionais substituindo o operados > do códigofonte abaixo.
<?php
$var1 = 2.2564;
$var2 = 2.2635;
print($var1 > $var2 ? “sim” : “não”);
?>
11°)Usando o operador de String “.” para montar a seguinte frase abaixo:
<?php
$a = “de”;
$b = “é um”;
$c = “comunicação”;
$c = “a”;
$d = “internet”;
$e = “meio”;
print( ..... );
?>
12°) Observe o códigofonte abaixo e diga qual o resultado booleano final. Justifique sua resposta.
<?
$a = 12.0 < 11.2;
$b = 10*2-3 > 19%3+10;
$c = 10;
print( ($a || $c = 10 && $b) ? "true" : "false");
?>

PHP e MySQL 76
Capítulo 8. Estruturas de Controle e Repetição
Objetivos
Mostra estruturas de controle e sua aplicação prática em PHP; Definir qual a principal finalidade
dessas estruturas; Mostrar exemplos em sua sintaxe; Mostrar aplicação e uso de foreach.
As estruturas que veremos a seguir são comuns para as linguagens de programação imperativas,
bastando descrever a sintaxe de cada uma delas resumindo o funcionamento. Independente do PHP,
boa parte das outras linguagens de programação tem estruturas iguais, mudando apenas algumas
sintaxes.
8.1. Blocos de controle
Um bloco consiste de vários comandos agrupados com o objetivo de relacionálos com
determinado comando ou função. Em comandos como if, for, while, switch e em declarações de
funções blocos podem ser utilizados para permitir que um comando faça parte do contexto
desejado. Blocos em PHP são delimitados pelos caracteres “{” e “}”. A utilização dos delimitadores
de bloco em uma parte qualquer do código não relacionada com os comandos citados ou funções
não produzirá efeito algum, e será tratada normalmente pelo interpretador. Outro detalhe
importante: Usar as estruturas de controle sem blocos delimitadores faz com que somente o
próximo comando venha ter ligação com a estrutura. Observe os exemplos:
Observe que o temos um comando IF, onde é passado a ele
uma expressão booleana que retorna verdadeiro ou falso.
O resultado da expressão é FALSE(falso), pois 0 não é
maior que 2, fazendo com que o IF não execute o echo com
“comando1”. Somente o segundo echo é executado, pois não
pertence ao IF declarado.
Mas se quisermos que mais de um comando pertença a
estrutura de controle, será usado blocos de comandos
( { comando; } ), onde através deles podemos delimitar e organizar os códigos.
No código ao lado, temos um bloco
onde inserimos dois comandos.
Observe que eles não serão executados,
pois a expressão booleana passada para
o IF é falsa.
8.2. IF e ELSE
Essa estrutura condicional está entre as mais usadas na programação. Sua finalidade é induzir um
desvio condicional, ou seja, um desvio na execução natural do programa. Caso a condição dada pela
expressão seja satisfeita, então serão executadas a instruções do bloco de comando. Caso a condição
não seja satisfeita, o bloco de comando será simplesmente ignorado. Em lógica de programação é o
que usamos como “SE(expressão) ENTÃO { comando:}”.
Sintaxe: exemplo:

PHP e MySQL 77
if (expressão)
comando;
if (expressão){
comando1;
comando2;
comando3;
}
Caso a condição não seja satisfatória (FALSE), podemos atribuir outro comando pertencente ao IF
chamado ELSE, como se fosse a estrutura SENÃO em lógica de programação.
Sintaxe: Exemplo:
if (expressão)
comando;
eles
comando;
if (expressão){
comando1;
comando2;
comando3;
} else {
comando1;
comando2;
comando3;
}
Nesse exemplo temos uma expressão booleana onde retorna falso, com isso o IF não executa,
passando a execução para o eles, que por sua vez executa e atribuí o valor “menor idade” a variável
$texto.
Em determinadas situações é necessário fazer mais de um teste, e executar condicionalmente
diversos comandos ou blocos de comandos. Isso é o que podemos chamar de “If's encadeados”, onde
usamos a estrutura IFELSE .Para facilitar o entendimento de uma estrutura do tipo:
Sintaxe: Exemplo:
if (expressao1)
comando1;
else
if (expressao2)
comando2;
else
if (expressao3)
comando3;
else
comando4;
Exercício rápido:
1°) Faça uma script em PHP que possua 4 notas de um aluno(cada uma em uma variável). Depois calcule

PHP e MySQL 78
e imprima a média aritmética das notas e a mensagem de aprovado para média superior ou igual a 7.0 ou a
mensagem de reprovado para média inferior a 7.0.
2°)Faça uma script em PHP que receba a idade de um nadador(representada por uma variável chamada
“$idade”) e imprima a sua categoria seguindo as regras:
Categoria Idade
Infantil A 5 - 7 anos
Infantil B 8 - 10 anos
Juvenil A 11- 13 anos
Juvenil B 14- 17 anos
Sênior maiores de 18 anos
8.3. Atribuição condicional (ternário)
Como já vimos exemplos de atribuição condicionais(ternários), podemos definilos usando a
sintaxe:
(expressão booleana) ? (executa  caso verdadeiro) : (executa  caso falso);
Isso se aplica quando queremos uma estrutura resumida, onde podemos ter um resultado mais
direto, como por exemplo, atribuir um valor a uma variável dependendo de uma expressão. Observe
o exemplo abaixo onde envolvemos uma variável do tipo string, porém o valor atribuído a essa
variável deverá ser de acordo com o valor da idade:
É uma estrutura parecida com  IF e ELSE, onde dependendo da expressão booleana podemos
executar um bloco ou não.
Exercício rápido:
1°) Faça uma script em PHP que receba um número representado por uma variável. Verifique se este
número é par ou ímpar e imprima a mensagem.
2°) Crie outro script baseando em um seguro de vida com as seguintes regras:
Idade: Grupo de Risco :
18 a 24 - Baixo
25 a 40 - Médio
41 a70 - Alto
8.4. SWITCH
Observe que quando temos muitos “if's encadeados” estamos criando uma estrutura que não é
considerada uma boa prática de programação. Para resolver esse problema temos uma estrutura
onde sua funcionalidade é semelhante ao  IFELSE. O comando SWITCH é uma estrutura que simula
uma bateria de teste sobre uma variável. Frequentemente é  necessário comparar a mesma variável
com valores diferentes e executar uma ação especifica em cada um desses valores.
Sintaxe: Exemplo:

PHP e MySQL 79
switch(expressão)
{
case “valor 1”:
comandos;
case “valor 1”:
comandos;
case “valor 1”:
comandos;
case “valor 1”:
comandos;
...
}
Resultado: opção 2:opção 3:opção 4:opção 5:
Nesse exemplo temos o numero = 2 onde o switch compara com os case's o valor recebido, o
bloco que é executado é do segundo case, porém os demais também são executados, para que
tenhamos um resultado satisfatório temos que usar em cada case um comando chamado break. No
qual tem a função de para o bloco de execução.
8.4.1. SWITCH com BREAK
Break é uma instrução(comando) passada quando queremos parar o fluxo da execução de um
programa. Em PHP, ele tem a mesma função que é “abortar” o bloco de código correspondente.
Observe o mesmo exemplo com o uso de break:
Temos agora como resultado “opção 2:”. O comando
break fez com que os demais case's abaixo do 'case 2' não
sejam executados.
Obs.: Além de números podemos também
comparar outros tipos como string, pontos
flutuantes e inteiros, veja um exemplo abaixo:
Mas o que aconteceria se não tivermos um valor que seja satisfatório aos casos existentes no
switch? A resposta pra isso é bem simples, nenhum dos blocos seria executados, porém temos um
comando onde determinamos uma opção padrão caso nenhuma das outras venha ter resultado que
satisfaça a expressão passada para o switch chamada default(padrão).
Veja um exemplo:

PHP e MySQL 80
Resultado: opção inválida
A instrução passada não condiz com nenhum dos caso existentes. Por esse motivo o bloco
pertencente ao comando default será executado.
O comando default pode ser inserido em qualquer lugar dentro do switch, porém caso
isso aconteça, o uso do comando break deve ser adicionado para evitar que os case's
abaixo sejam executados.
A partir de agora trabalharemos as estruturas de repetição. Elas muito utilizadas nas linguagens
de programação.
Exercício rápido:
1°) Faça um script em PHP usando switch, onde receba uma variável e mostre as seguintes opções:
1 - módulo.
2 - somar.
3 - subtrair.
4 - multiplicar.
5 - dividir.
8.5. WHILE
O WHILE é uma estrutura de controle similar similar ao IF, onde possui uma condição para
executar um bloco de comandos. A diferença primordial é que o WHILE estabelece um laço de
repetição, ou seja, o bloco de comandos será executado repetitivamente enquanto a condição
passada for verdadeira. Esse comando pode ser interpretado como “ENQUANTO(expressão)
FAÇA{ comandos...}”.
Sintaxe:
while (expressão)
{
comandos;
}
Quando estamos usando um laço de repetição, podemos determinar quantas vezes ele deve ou
não se repetir. Isso pode ser feito de forma manual, onde o programador determina, ou
automaticamente, onde quem vai determinar é fluxo de execução o códigofonte através de funções
do PHP, funções estas já existentes. Por exemplo a função “sizeOf”.
Para trabalharmos com essa contagem de quantas vezes o laço deve se repetir, usaremos
incremento ou decremento de uma variável conforme vimos no capitulo de operadores em PHP.

PHP e MySQL 81
Resultado: 123456789
Nesse exemplo criamos um laço de repetição que tem como condição $a < 10, a cada laço é
executado um incremento na variável $a, fazendo com que o seu valor aumente até a condição não
ser mais satisfatória.
Dica:. Tenha cuidado quando estiver trabalhando com loop's (laço de repetição), pois caso
a expressão passada esteja errada, pode ocasionar em um loop infinito fazendo com que o
bloco de código se repita infinitamente. Isso pode ocasionar um travamento do navegador
ou até mesmo do próprio servidor WEB.
Vamos ver agora um exemplo em que o laço se repete de forma automática, onde quem
determina o loop é uma função do PHP e não um numero determinado pelo programador.
A função strlen() recebe uma string e retora a quantidade de caracteres incluindo também os
espaços em branco. Ele poderia ser aplicado diretamente no echo, mas no exemplo, ele determina a
quantidade de loop's.
Resultado: a frase possui 14 caracteres
Exercício rápido:
1°) Faça um script que conte de 1 até 100.
2°) Faça um script que imprima na tela números de 3 em 3 iniciando com 0 até 90, ex: 0,3,6,9...
8.6. DO...WHILE
O laço do...while funciona de maneira bastante semelhante ao while, com a simples diferença que
a expressão é testada ao final do bloco de comandos. O laço do...while possui apenas uma sintaxe
que é a seguinte:
Sintaxe:
do {
comando;
. . .
comando;
} while (expressão);

PHP e MySQL 82
Exemplo:
Resultado: 123456789
Dica: Talvez na criação de alguma página ou sistema web, seja necessário executar um
bloco de código existente em um laço de repetição pelo menos uma vez, nesse caso
podemos usar o do...while.
Exercício rápido:
1°) Faça um script que conte de -1 até -100 usando “do while”.
2°) Faça um script que imprima na tela somente números pares de 2 até 20 com do while.
8.7. FOR
Outra estrutura semelhante ao while é o for, onde tem a finalidade de estabelecer um laço de
repetição em um contador. Sua estrutura é controlada por um bloco de três comandos que
estabelecem uma contagem, ou seja, o bloco de comandos será executado determinado número de
vezes.
Sintaxe:
for( inicialização; condição; incremento ){
comandos;
}
Parâmetros Descrição
inicialização Parte do for que é executado somente uma vez, usado para inicializar uma variável.
condição Parte do for onde é declarada uma expressão booleana.
incremento Parte do for que é executado a cada interação do laço.
Lembrando que o loop do for é executado enquanto a condição retornar expressão booleana
verdadeira. Outro detalhe importante é que podermos executar o incremento a cada laço, onde
possibilitamos adicionar uma variável ou mais. Mostraremos agora um exemplo fazendo um
comparativo entre a estrutura de repetição do while e também a do for de forma prática.
Exemplo:
while for

PHP e MySQL 83
Ambos exemplo geram o mesmo resultado:123456789
O for não precisa ter necessariamente todas as expressões na sua estrutura, com isso podemos
criar um exemplo de for onde suas expressões são declaradas externamente.
Observe nesse exemplo uma proximidade muito grande do comando while. Apesar de ser
funcional, não é uma boa prática de programação utilizar desta forma.
Exercício rápido:
1°) Faça um script que receba duas variáveis $a e $b, logo após imprima os números de
intervalos entre eles com o uso de “for”.ex: a=5 ,b = 11, imprime : 5,6,7,8,9,10,11.
8.8. FOREACH
O foreach é um laço de repetição para interação em array's ou matrizes, o qual estudaremos com
mais detalhes no próximo capítulo. Tratase de um for mais simplificado que compõe um vetor ou
matriz em cada um de seus elementos por meio de sua cláusula AS.
Sintaxe:
foreach( expressão_array as $valor){
comandos;
}
Exemplo:
Resultado:
    ana
    maria
    joão
    alex

PHP e MySQL 84
Veremos adiante que um array é uma variável composta por vários elementos. No caso do
exemplo anterior, esses elementos são nomes de pessoas. A finalidade do foreach é justamente a
cada laço, pegar um desses valores e atribuir a uma variável $nome até que tenha percorrido todo
array e assim, finalizar o laço. Também podemos saber em qual posição o elemento se encontra no
array, para isso basta adicionar uma nova variável logo após o AS seguido de =>.
Observe o exemplo:
   Resultado:
0ana
      1maria
      2joão
      3alex
Nesse exemplo observamos que cada elemento do array possui um índice(chave), imprimindo na
tela o numero da posição e o valor guardado.
8.9. BREAK.
Outro comando importante é o break, usado para abortar(parar) qualquer execução de comandos
como SWITCH, WHILE, FOR, FOREACH, ou qualquer outra estrutura de controle. Ao encontrar um
break dentro de um desses laços, o interpretador PHP interrompe imediatamente a execução do
laço, seguindo normalmente o fluxo do script.
Sintaxe:
while....
for....
break <quantidades de níveis>;
Vamos ver um exemplo com o uso de break dentro de um laço de repetição (no caso o for), onde
criamos um laço infinito, porém colocamos um if com a condição de parar o laço através do break.
Observe:
Podemos notar nesse exemplo a criação de um laço(loop) infinito, que ocorre quando tiramos a
condição do for, ou atribuímos “for( ; true ; )”, porém a condição fica na responsabilidade do if,
quando o valor de $a e igual a 10, faz com que o if execute o break, fazendo com que o laço pare
de funcionar.

PHP e MySQL 85
Mas se tivéssemos mais de um laço, como poderíamos definir qual deles deixaria de funcionar?
Para responder essa pergunta usamos a quantidades de níveis que pode existir em um break,
observe o exemplo abaixo:
Resultado:
Observe que definise qual nível podemos parar, ou seja, o primeiro nível é onde o break está
localizado, no exemplo citado temos dois níveis, e determinamos pelo “break 2;”  que o segundo
for( que é o de fora! ) deixaria de funcionar.
8.10. CONTINUE
A instrução continue, quando executada em um bloco de comandos for/while, ignora as
instruções restantes até o fechamento em “}”. Dessa forma, o programa segue para a próxima
verificação da condição de entrada do laço de repetição, funciona de maneira semelhante ao break,
com a diferença que o fluxo ao invés de sair do laço volta para o início dele. Veja um exemplo:
Resultado: 0,2,4,6,8,10,12,14,16,18,
   Podemos observar a seguinte lógica no exemplo acima:
Criamos um laço que tem 20 interações de repetição. Logo após temos um if,  onde,
quando o resto da divisão por 2 for igual a 0 (numero par), o valor booleano será “false”.
Quando não for igual a 0, significa que a variável $i é um numero impar( ex: 5%2 = 1),
então temos um valor booleano “true”. Isso significa que o if executa somente quando os
numero forem impares. Adicionamos um continue, que ao executar o if, faz com que volte
novamente para o início do for, impedindo de  alcançar o echo em seguida. Com isso, em
vez de mostramos os números impares, imprimimos somente os números pares incluindo o
0. Resumimos  que o código só passa adiante quando o if não executa o continue.
Fluxograma:

PHP e MySQL 86
Assim como o break, também podemos definir em qual nível queremos que a execução continue.
Veja o exemplo abaixo:
Resultado:
Podemos observar então o uso de continue dentro de um laço infinito. Ele faz com que o laço de
nível 3 seja executado toda vez que a execução passe pela linha 10 do código, logo, impede que o
programa fique sempre executando dentro do while de nível 1. Com isso, o while da linha 4 do
código tem um ciclo de vida de 5 laços.
Observe também que os dois últimos echo's nunca serão alcançados, pois o comando continue
impede que o fluxo do código passe adiante, fazendo voltar ao nível determinado.
Resumindo: O continue é usado dentro de estruturas de loops para saltar o resto da
execução do loop atual e continuar a execução na avaliação do estado, em seguida, o início
da próxima execução.
Fluxograma:

PHP e MySQL 87
1°) Qual a principal finalidade de uma estrutura de controle.
2°) Qual a principal finalidade de uma estrutura de repetição.
3°) Crie um código com a um condição ternária onde receba um valor booleano e de acordo com o
valor passado na expressão, deve imprimir “sim” ou “não”.
4°) Com o comando IF e ELSE crie um código que determine se uma expressão é verdadeira ou
falsa.
5°) Qual a finalidade da estrutura de controle SWITCH e cite um exemplo onde comparamos uma
opção com 4 casos diferente.
6°) Crie um contador de 1 até 20 usando a estrutura de repetição WHILE.
7°) Crie um contador de 1 até 100 usando DO WHILE.
8°) Crie um contador de 100 até 1 usando FOR.
10°) Qual a fonalidade de um FOREACH.
11°) Crie um código onde podemos para a execução de um laço infinito com o uso de BREAK.
12°) Como podemos determinar o uso de CONTINUE e qual a sua aplicação prática em PHP.
13°) Crie um código com as seguintes características:
a) Deverá receber um valor inicial e outro final (crie duas variáveis para esse fim).
b) Como o comado FOR crie um laço onde a contagem e determinada pelo valor inicial e final.
c) Dentro do for deverá conter um IF e ELSE responsável por compara os valores passado a ele e
imprimir os pares e impares. Exemplo:
IF($valor%2==0)
echo $valor. “é um numero par”;
ELSE
echo $valor. “é um numero impar”;
d)Exemplo prático: foi passado o numero inicial 8 e o final 15, então o script PHP deverá imprimir o
intervalo entre esse numero ou seja 8,9,10,11,12,13,14,15, mostrando quais deles são pares e quais
são impares.

PHP e MySQL 88
Capítulo 9. Manipulação de Arrays
Objetivos
Abordar de forma clara as principais estruturas de um array; Mostrar a sua criação e manipulações
possíveis; Definir arrays multidimensionais ou matrizes; Determinar formas de interações e acessos.
Um array no PHP é atualmente um conjunto de valores ordenado. Podemos relacionar cada valor
com uma chave, para indicar qual posição o valor está armazenado dentro do array. Ele é otimizado
de várias maneiras, então podemos usálo como um array real, lista (vetor), hashtable (que é uma
implementação de mapa), dicionário, coleção, pilha, fila e provavelmente muito mais. Além disso, o
php nos oferece uma gama enorme de funções para manipulálos.
A explicação dessas estruturas estão além do escopo dessa apostila, mas todo conteúdo aqui
abordado trás uma boa base para quem estar iniciando o conteúdo de array.
9.1. Criando um Array
Arrays são acessados mediante uma posição, como um índice numérico. Para criar um array pode
se utilizar a função array([chave =>] valor, …). Exemplo:
Sintaxe:
$nomes = array('Maria','João','Alice','Alex');
ou
$nomes = array(0=>'Maria', 1=>'João', 2=>'Alice', 3=>'Alex');
Nessa sintaxe temos duas formas de declarar uma variável do tipo array. Onde a chave o índice
podem ser de forma automática como no primeiro exemplo, ou manual como no segundo. Outro
detalhe importante é que: Todo array começa pela chave ou índice de numero 0, quando o mesmo
não é declarado.
Também temos outras formas de criar um array, onde simplesmente podemos adicionar valores
conforma a sintaxe abaixo:
$nome[] = 'Maria';
$nome[] = 'João';
$nome[] = 'Carlos';
$nome[] = 'José';
A figura abaixo representa um array que tem como valor representação de cores, e possui dez
posições, cada posição representa uma cor, seu índice(chave) vai de 0 até 9. Veja:

PHP e MySQL 89
Em código temos:
9.2. Arrays Associativos.
Aos arrays associativos associase um determinado valor ou nome a um dos valores do array.
O array associativo usa strings como índice, onde cada string pode representas uma chave.
Observe a sintaxe:
$var = array('texto1'=>'valor1','texto2'=>'valor2',...,'textoN'=>'valorN');
Observe que quando usamos arrays associativos, a compreensão é mais fácil, dando mais
legibilidade ao código. Porém não é utilizado quando usamos um array dentro de um laço(loop),
mas em outros casos sempre é bom utilizar arrays associativos. Veja um exemplo:
Outra forma de iniciarmos o mesmo array é adicionar valores conforme abaixo:
A imagem abaixo representa os exemplo anteriores:
Umas das vantagem do array associativo é quando
fazemos o acesso ao array, onde temos de forma clara
e compreensível o valor que aquela chave pode
conter. Como por exemplo nome, onde só vai existir
nome de pessoas. Veja abaixo um exemplo de acesso
ao valores armazenados em um array dessa natureza.

PHP e MySQL 90
Exemplo:
Dessa forma podemos acessar o array. Basta determinar o nome do array e qual a chave, onde
cada chave tem um valor já determinado. Resultará em um erro o uso de uma chave errada.
9.3. Interações
Quando falamos de interações em um array, estamos dizendo o mesmo que percorrer esse array
usando mecanismos da própria linguagem. Como isso as interações podem ser feitas de várias
formas, mas no PHP podem ser iterados pelo operador FOREACH que já vimos anteriormente.
Exemplo:
resultado:
Esse tipo de interação é muito utilizado, principalmente quando temos arrays associativos.
Dica: Sempre que se depararem com arrays, onde havendo a necessidade de percorrer
suas informações independentemente da chave, procure sempre utilizar mecanismos de
programação mais simplificados como FOREACH.
9.4. Acessando um Array
Quando criamos um array temos que ter em mente que estamos criando uma variável que possui
vários valores e que os mesmo podem ser acessados a qualquer momento. Cada valor está guardado
em uma posição que pode ser acessada através de uma chave.
A sintaxe para acesso simplificado de um array é a seguinte:
nome_do_array[ chave_de_acesso ];

PHP e MySQL 91
Temos que ter cuidado ao passar uma chave para o array, pois ela deve conter o mesmo nome de
qualquer umas das chaves existentes no array. Caso a chave não exista, o valor não poderá ser
resgatado. A sintaxe acima retorna um valor contido no array, por esse motivo temos que atribuir
esse valor como mostra o exemplo abaixo:
Resultado: telefone.
9.5. Alterando um Array
Podemos alterar qualquer valor de um array. É muito semelhante ao acesso, onde, a diferença
está na chamada do array. É nesse momento que atribuímos um novo valor.
Veja a sintaxe:
nome_do_array[ chave_de_acesso ] = <novo_valor>;
Resultados:
Vimos no exemplo anterior o valor da posição 1 do array ('telefone') foi alterada para sobrenome.
Vale ressaltar que esse array tem suas chaves definidas de forma automática. A primeira posição é 0,
a segunda é 1, e assim sucessivamente. Veja mais um exemplo onde alteramos o valor, mas usando o
operador de atribuição “+=” e concatenação “.=”:

PHP e MySQL 92

Resultados:
Arroz Tio João
1.98
Podemos observar que assim como as variáveis “comuns”, a forma de alterar o valor de um array
é igual. A diferença está na chamada do array, pois temos que passar a chave além do valor que
queremos atribuir. Outro detalhe importante é o tipo de valor, onde supostamente devemos atribuir
os tipos compatíveis. Ou seja, se o valor atribuído a chave produto for do tipo string, não podemos
usar os operadores de atribuição para atribuir um outro tipo, porém podemos mudar o tipo do valor
pelo operador de atribuição simples (=).
Exemplo:
$var[2] += 1.90; // o tipo é um ponto flutuante antes e depois.
$var[2] = 'bom dia' ; // agora temos a mudança de tipo ponto
flutuante para string.
9.6. Arrays multidimensionais
Os arrays multidimensionais são estruturas de dados que armazenam os valores em mais de uma
dimensão. Os arrays que vimos até agora armazenam valores em uma dimensão, por isso para
acessar às posições utilizamos somente um índice ou chave. Os arrays de 2 dimensões salvam seus
valores de alguma forma como em filas e colunas e por isso, necessitaremos de dois índices para
acessar a cada uma de suas posições.
Em outras palavras, um array multidimensional é como um “contêiner” que guardará mais
valores para cada posição, ou seja, como se os elementos do array fossem por sua vez outros arrays.
Outra ideia que temos é que matrizes são arrays nos quais algumas de suas posições podem
conter outros arrays de forma recursiva. Um array multidimensionais pode ser criado pela função
array():
Na figura abaixo temos a representação de um array com duas dimensões.

Uma diferença importante de um array comum
para um multidimensional é a quantidades de
chaves (índices), onde cada um dos índices
representa uma dimensão. Observe o código da
representação ao lado.


PHP e MySQL 93
Código:
Outra forma de inicia o array:
Observe que temos uma chave para representar a linha e outra para representar a coluna, assim,
determinando uma matriz 4x4. Podemos ver também que inicializamos um array dentro do outro.
Cada subarray é uma linha, e cada elemento do array maior representa as colunas.
Para acessarmos o valor de um array multidimensional, basta colocar as duas ou mais chaves da
posição que queremos acessar. É muito semelhante ao array de uma única dimensão.
Observe o acesso aos exemplos anteriores:
Sintaxe:
nome_do_array[ chave_1 ][ chave_2 ]...[chave_n] ;
Exemplo:
Dessa forma podemos acessar o elemento numérico 1.2 que estar guardado na posição linha 1
coluna 2, lembrando que o primeiro elemento de um array é 0.

PHP e MySQL 94
Abaixo, um exemplo que acessa todos os valores do array e imprime com quebra de linha:
resultado:
0.0 é igual a 0 ,1.0 é igual a 1 e
assim sucessivamente.
Explicando o código:
Linha 2 – criamos um array de duas dimensões.
Linha 7 – temos um foreach para percorrer o primeiro array, ele retorna na variável $linha os sub
arrys contido no array maior.
Linha 8 – agora temos outro foreach que vai percorrer os valores dos arrays passando pra variável
$linha.
Linha 9 – criamos uma variável $i para contar os elementos.
Linha 10 – Imprime os valores.
Linha 11 – temos um IF, quando $i for igual a 4, significa que podemos executar o código
pertencente ao If, determinando que chegou ao quarto elemento do array.
Linha 12 – Quebra de linha com o <br>.
Linha 13 – Zera a variável $i para começar a contagem de novo.
9.7. Funções com Arrays
Em PHP temos um conjuntos de funcionalidades e que já vem prontas para serem utilizadas.
Tratase de funções que já estão prédefinidas, você pode encontrálas facilmente no site php.net.
Abordaremos agora funções utilizadas exclusivamente para manipulação de array, funções de
acesso, ordenação, dentre outras. Obviamente que não falaremos de todas, pois existem muitas
funções, mas mostraremos as mais utilizadas, e outras que são definidas como principais.
var_dump
Essa função é muito usada por programadores que pretendem realizar debug(análise mais
detalhado para encontrar supostos erros). Observe um exemplo prático:

PHP e MySQL 95
Saída no Browser:
print_r
Imprime o conteúdo de uma variável assim como var_dump(), porém com um formato menos
detalhado e mais legível ao programador. Exemplo:
código:
Saída no Browser:
Dica: Ao olhar o código fonte da página aberta, notase o código bem organizado, porém
os comentários não podem ser vistos. Procure olhar o códigofonte sempre que tiver
dúvida de que código HTML o PHP está gerando. Clique com botão direito do mouse,
procure código fonte, e observe o que é gerado!
array_push
Adiciona elementos ao final de um array. Tem o mesmo efeito de utilizar a sintaxe:
var_dump( nome_do_array , novo_valor)
Exemplo: Resultado:

PHP e MySQL 96
array_pop
Remove um valor no final de um array. Sintaxe:
array_pop(nome_do_array);
Exemplo: Resultado:
array_shift
Remove um elemento do início de um array, sintaxe:
array_shift( nome_do_array )
Exemplo: Resultado:
Como já sabemos como lidar com essas funções, observamos que, basta conhecer a sintaxe, para
montarmos um exemplo. Apresentaremos agora de forma resumida as demais funções.
Obs.: Todas as funções aqui apresentadas são para mostrar ao aluno as formas de
trabalharmos com determinadas funções. Fica a critério do aluno se aprofundar ou não
nesse conhecimento, uma vez que exista inúmeras funções.
Observe a tabela abaixo com outras funções:
Funções Definição Sintaxe:
array_unshift Adicionar um elemento no inicio de um
array.
array_unshift(nome_array , novo_valor)
array_pad Preenche um array com valores,
determina a quantidade de posições.
array_pad(nome_array, tamanho ,valor)
array_reverse Recebe um array e retornao na ordem
inversa.
array_reverse( nome_array, valor_booleano)
array_merge Uni dois arrays criando um novo array. $novo_array = array_merge(array_1,array_2)
array_keys Retorna somente as chaves do array. array_keys(nome_array)
array_values Cria um novo array com os valores de
outro.
$novo_array = array_values(outro_array)
array_slice Extrai posições de um array. $var = array_slice(nome_array, inicio, tamanho)
count Conta quantos elementos tem um array $var = count(nome_array)

PHP e MySQL 97
Funções Definição Sintaxe:
in_array Verifica se um array possui determinado
valor.
in_array(valor_buscado, nome_array)
sort Ordena um array pelos valores. sort(nome_array)
rsort Ordena um array pelos valores de
ondem reversa.
rsort(nome_array)
explode Converte uma string em um array. explode(separador, nomer_string)
implode Converte um array em uma string implode(separador, nome_array)
Essa tabela mostra as funções mais comuns. Derrepentemente você pode de deparar com algumas
delas em códigos já feito, ou baixados da internet. Exemplo disso são as ferramentas CMS, como
joomla ou wordpress, que são feitas em PH. Existem muitas combinações dessas funções e outras a
mais em seu códigofonte. Veja um exemplos utilizando algumas das funções anteriores.
Resultado:

PHP e MySQL 98
1°) O que é um array, e qual a sua principal finalidade.
Declare um array chamado “nomes” com 8 posições, e grave  nomes de pessoas que você
conhece em cada uma delas. Após criar o array responsa as questões 2, 4, 5, 10, 11:
2°)Utilizado o array responda.
a)Qual nome é impresso no navegador se colocarmos o código:
echo nomes[3];
b)Quais nomes aparecerá se adicionamos os seguintes códigos:
for($i= 6; $i>1 ; i--)
echo nomes[$i];
c)O que acontece se chamarmos uma posição que não existe no array, exemplo:
nomes[15];
3°)O que é um array associativo, de exemplos:
4°)Usando o comando foreach, crie uma interação onde todos os nomes  possa ser impresso na tela.
5°)Utilizando o mesmo código, altere alguns nomes do array.
6°)O que é um array multidimensional?
Crie um array “palavras” multidimensional 5x3 com os valores da tabela abaixo, e responda as
questões 7,8,9:
“oi” “tudo” “estar”
“você” “vai” “?”
“com” “dia” “!”
“,” “bem” “sim”
“casa” “hoje” “em”
7°)Crie um código PHP onde com os valores do array possa ser impresso na tela com a frase “oi,
tudo bem com você?”.
8°)Utilizando as posições da sequencia [1][0],[1][1],[0][2],[4][2],[4][0],[4][1],[1][2] do array
palavras, qual frase podemos formular?utilize a função print() para mostrar na tela do navegador.
9°)Construa um código PHP para mostra uma resposta para a pergunta da qustão 7. (use o
comando echo para imprimir na tela.
10°)Utilizando a função sort, imprima em ordem alfabética os nomes do array “nomes”.
11°)Use o comando array_unshift() para adicionar mais dois nomes no array.

PHP e MySQL 99
Capítulo 10. Manipulação de Funções
Objetivos
Apresentar as estrutura de funções em PHP; Mostrar qual a definição entre variável global e estática e
sua relação com o uso de funções; Mostrar também o uso de passagem de parâmetros, recursão e qual
a sua principal finalidade.
Quando queremos um código funcional para determinado fim, com por exemplo fazer um cálculo
ou alguma interação dentro do PHP, usamos o que chamamos de função. As funções são um pedaço
de código com o objetivo específico, encapsulado sob um estrutura única que recebe um conjunto
de parâmetros e retorna ou não um determinado dado. Uma função é declarada uma única vez, mas
pode ser utilizada diversas vezes. É uma das estruturas mais básicas para prover reusabilidade ou
reaproveitamento de código, deixando as funcionalidades mais legíveis.
10.1. Declarando uma Função.
Declaramos uma função, com o uso do operador function seguido do nome que devemos
obrigatoriamente atribuir, sem espaços em branco e iniciando sempre com uma letra. Temos na
mesma linha de código a declaração ou não dos argumentos pelo par de parênteses “()”. Caso exista
mais de um parâmetro, usamos virgula(,) para fazer as separações. Logo após encapsulamos o
código pertencente a função por meio das chaves ({}). No final, temos o retorno com o uso da
cláusula return para retornar o resultado da função que pode ser um tipo inteiro, array, string,
ponto flutuante etc. A declaração de um retorno não é obrigatório. Observe a sintaxe:
function nome_da_função( $argmento_1, $argumento_2, $argumento_n )
{
comandos;
return $valor;
}
Observe um exemplo onde criamos uma função para calcular o índice de massa corporal de uma
pessoa (IMC), onde recebe como parâmetro dois argumentos. Um é a altura representada pela
variável $altura e o outro é o peso representada pela variável $peso. Passamos como parâmetros
para essa função o peso = 62 e a altura = 1.75. Observe:
Exemplo:
Resultado: 20.244897959184
Nesse exemplo temos a declaração e logo após a chamada da função, onde é nesse momento que
passamos os dois parâmetros na ordem que foi declarada na função. lembrando que essa ordem é
obrigatória.

PHP e MySQL 100
Observe mais um exemplo, onde a função declarada porém não possui a cláusula return.
        Resultado:
10.2. Escopo de Variáveis em Funções
Um conceito importante em programação são os tipos de declarações de variáveis, onde sua
visibilidade vai depender de onde ela é declarada. O acesso a essas variáveis podem ser definidas da
seguinte forma:
Variáveis locais   São aquelas declaradas dentro de uma função e não tem visibilidade fora→
dela. Veja um exemplo:
O valor da variável $a não é impresso na tela,
pois ela só existe dentro da função, qualquer
outra variável declarada com o mesmo nome
fora da função é uma nova variável.
Variáveis Globais → São variáveis declaradas fora do escopo de uma função, porém tem
visibilidade(pode ser acessada)  ao contexto de uma função sem passála como parâmetro. Para isso
declaramos a variável e fazemos a sua chamada logo após com o uso do termo global. Exemplo:
Resultado: 25
Variáveis estáticas → Podemos armazenar variáveis de forma estática dentro de uma função.
Significa que ao fazermos isso, temos o valor preservado independente da ultima execução. Usamos
o operador static para declaramos a variável. Exemplo:
Resultado: 10,20,30,
Observe que o valor é mantido e a cada
chamada é acrescentado +10, caso não
exista o static o resultado seria: 10,10,10, .

PHP e MySQL 101
10.3. Passagem de Parâmetro.
Como vimos anteriormente, podemos passar ou não parâmetros em uma função, porém existem
dois tipos de passagem de parâmetros: Por valor(by value) e por referência(by reference).
Por Valor → 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:
O exemplo acima mostra que passamos um valor de $a para a função, porém o valor temos a
garantia que o valor continua integro, ou seja, não foi modificado ao longo do código.
Por Parâmetro → Para passarmos um valor por parâmetro, simplesmente colocamos o operador
“&” na frente do parâmetro que queremos que o valor seja alterado, observe o exemplo abaixo:

Observe agora nesse ultimo exemplo que apenas acrescentamos o operador “&” no parâmetro que
queríamos que alterasse a variável passada como parâmetro, fazendo com que o resultado fosse a
soma de 23 + 26 = 49.
Por argumentos variáveis → O PHP permite outras formas avançadas de passagem de
parâmetros, onde o valor e a quantidade são definidas de forma automáticas por meio das funções
func_get_args() e func_num_args().
func_get_args() → diz os valores(argumentos) passado para a função.
func_num_args() → diz a quantidade de valores passados para a função.
Observe uma exemplo mais complexo abaixo:
Resultado: nome = Alex ,nome = Sara ,nome = Maria ,nome = Bruna ,

PHP e MySQL 102
10.4. 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 array's. As
operações aritméticas podem ser feita de forma direta no retorno. Observe um exemplo onde temos
uma operação direta:
Resultado:
O resultado é: 139.5
Também podemos determinar mais de um retorno desde que eles não sejam acessado ao mesmo
tempo, observe o exemplo abaixo:
Esse código mostra de forma clara que
não existe a possibilidade de retornarmos
mais de um return, caso isso ocorresse,
teríamos um erro, ou não funcionamento da
função.
10.5. Recursão.
Função recursiva é uma definição usada tanto na programação quanto na matemática, onde,
significa que uma função “faz a chamada” de si mesma na sua execução. Um exemplo é o calculo do
fatorial de um número. Observe:
Fatorial de 5: 5! = 5*4!, 4! = 4*3!, 3! = 3*2!, 2! = 2*1! ou 5*4*3*2*1 = 120.
Exemplo:
Resultado: 120

PHP e MySQL 103
1°) Diga com suas palavras uma definição para função, e como podemos declarála em PHP.
2°) Qual a diferença de variáveis globais para variáveis locais e como podemos definilas em PHP.
3°) O que é um parâmetro, e quais os tipos de parâmetros em PHP.
4°) Quais as funções que podemos usar para criarmos uma função onde seus parâmetros são
passados pro argumentos variáveis.
5°) O que é um valor de retorno e qual o comando usado quando queremos retornar algo dentro de
uma função.
6°) O que é recursão.
7°) Crie uma função que determine se um numero é par ou impa. E faça uma chamada dessa função
imprimindo o resultado.
8°) Crie uma função que calcule a fatorial de um número.
9°) Crie uma função para determina se um numero é primo ou não. Numero primo é aquele que
possui dois divisores, 1 e ele mesmo. Criem um laço de repetição e use estrutura de controle.
Anotações:

PHP e MySQL 104
Capítulo 11. Manipulação de arquivos e diretórios
Objetivos
Mostrar formar de manipulação de arquivos; Usar os principais comandos para trabalharmos com
arquivo e diretórios; Aprender a trabalhar com leitura e escrita de arquivos, listagem,e criação de
variáveis buffer de arquivos.
Assim como outras linguagens de programação, é muito importante trabalharmos com
manipulações de arquivos e diretórios em PHP, onde temos a possibilidade de manipular um arquivo
ou diretório dentro do servidor web, podendo criar arquivos responsáveis por guardar informações
referentes aquele sistema ou página. Essas informações podem ser resgatadas futuramente, ou
simplesmente são informações que ao invés de serem gravadas no bando de dados, foram gravadas
em um arquivo ou log(arquivos que grava informações sobre o sistema, erros etc...).
Ao trabalhar com arquivos, no mínimo duas operações devem ser realizadas: abrir e fechar o
arquivo.
11.1. Criando e Abrindo um Arquivo.
O comando utilizado para criar um arquivo é o mesmo que usamos para abrilo, porém no Linux
temos que dar permissões a pasta no qual o arquivo vai ser guardado.
Abra o konsole ou terminal do seu sistema(Linux). Digite:
chmod 777 /var/www
O comando chmod 777 dar todas as permissões possíveis na pasta www onde trabalharmos na
criação de nossos arquivos.
Para abrir ou criar um arquivo utilizaremos o seguinte comando abaixo:
fopen
Com esse comando podemos abrir um arquivo e retornar um identificador. Sua sintaxe e a
seguinte:
$identificador = fopen(“string_do_arquivo”,“modo_do_arquivo”)
string_do_arquivo é definido como o nome do arquivo mais a sua extensão, isso incluindo o→
caminho onde esse arquivo é localizado ou não, por exemplo:
“/home/aluno/meu_arquivo.txt”
Podemos observar um arquivo criado dentro da pasta alunos com o nome meu_arquivo.txt.
modo_do_arquivo nesse parâmetro podemos determinar a forma que o arquivo vai ser aberto→
com os seguintes valores:
“r” read, este modo abre o arquivo somente para leitura.→
“w” write, abre o arquivo somente para escrita→ , caso o arquivo não exista, tenta criálo.
“a+” append, abre o arquivo para leitura e escrita, caso o arquivo não exista, tenta criálo. →
Existem outros modos, mas trabalharemos somente com estes.

PHP e MySQL 105
Dica: para trabalharmos com arquivos é sempre importante sabermos se a pasta ou o
arquivo tem permissões dentro do Linux, caso isso não aconteça, o arquivo não será
criado, lido ou até mesmo gravado.
Veja um exemplo do uso do comando fopen:
Caso o arquivo não exista, ele é criando
dentro da pasta onde o arquivo *.php foi criado,
ou seja, no nosso exemplo o arquivo se chama
index.php e estar dentro da pasta www, após
executamos esse comando teremos um novo
arquivo com o nome meu_arquivo.txt.
11.2. Gravando em um arquivo.
Após o uso do comando fopen, temos um identificador apontando para o arquivo, e com ele que
podemos fazer alterações ou manipulações. Podemos gravar dados dentro do arquivo com o uso do
seguinte comando:
fwrite
sintaxe:
fwrite(“indentificador”,“conteúdo”)
identificador → é o parâmetro retornado pelo comando fopen.
conteúdo → é o conteúdo a ser gravado no arquivo.
Vale ressaltar que para podermos gravar no arquivo ele deve ter permissão dentro do linux e além
disso ter como parâmetro “w” ou “a+” passado para o comando fopen.
Observe um exemplo onde escrevemos(gravamos) duas linhas dentro de um arquivo de texto
criado com os comando visto até agora:
Exemplo: Resultado:
O uso de “n” antes da palavra rua faz com que ocorra uma quebra de linha escrevendo o resto
do conteúdo na linha abaixo. Após a execução do script (colocando http://localhost no navegador e
o nome do script criado), abrimos o arquivo de texto(meu_arquivo.txt) com um editor e
percebemos o resultado final.
Observe mais um exemplo: Resultado:

PHP e MySQL 106
No exemplo, fizemos a chamada do comando fwrite três vezes e escrevemos a cada chamada um
valor diferente concatenando com “n”.
11.3. Fechando um arquivo.
Até agora trabalhamos com o comando fopen e não fechamos o arquivo, simplesmente abrimos e
executamos os demais comandos. Isso faz com que, caso tenhamos de usar o mesmo arquivo em
outra parte do código, ele não poderá ser utilizado, pois para isso é preciso fechálo para ele poder
ser aberto novamente em outra parte do código. Para isso usamos o seguinte comando:
fclose
sintaxe:
fclose(“indentificador”)
exemplo:
Toda vez que abrimos um arquivo
com fopen, devemos fechálo com o
comando fclose conforme o exemplo ao
lado.
11.4. Lendo um arquivo.
Após abrirmos um arquivo, outra operação que podemos efetuar é a leitura do conteúdo existente
no arquivo. Essa operação é feita linha por linha, onde podemos resgatar valores existentes de
acordo com a chamada do comando fread ou o índice do array criado pelo comando file.
file
Lê um arquivo e retorna um array com todo seu conteúdo, de modo que a cada posição do array
representa uma linha do arquivo começando pelo índice 0.
sintaxe:
$array = file(“string_do_arquivo”)
string_do_arquivo → da mesma forma que é definida no comando fopen, usase o caminho com
o nome do arquivo ou simplesmente o nome do arquivo caso ele exista na mesma pasta onde o
arquivo PHP que contém o comando foi criado.
Exemplo: Resultado:
Nesse exemplo utilizamos o arquivo anterior onde foi escrito três linhas, porém efetuamos a
leitura somente da linha 1 (índice 0) e linha 2 (índice 1). Oura forma é percorrer o array usando
um foreach(),dessa forma podemos ler todas as linhas existentes no arquivo,veja:

PHP e MySQL 107
Exemplo: Resultado:
11.5. Copiando,Renomeando e Apagando um Arquivo
Em PHP também é possível copiarmos um arquivo de uma origem para um determinado
destino, como também apagar esse arquivo. Para isso usamos os seguintes comando:
copy
Cria um arquivo para outro local/nome. retornando um valor booleano verdadeiro(true) caso a
copia tenha ocorrido sem eros ou falhas, caso contrário retorna falso(false). Sintaxe:
copy(“string_origem”,”string_destino”)
exemplo:
Caso tudo ocorra corretamente, o resultado apresentado no navegador é “Cópia efetuada”, e será
criado uma cópia dentro da pasta com o nome “meu_novo_arquivo.txt”. Vale lembrar que podemos
também passar o caminho completo para onde deve ser copiado, como por exemplo:
/home/aluno/meu_novo_arquivo.txt
Para renomearmos um arquivo usamos:
rename
sintaxe:
rename(“nome_do_arquivo”, “novo_nome”)
Para apagarmos um arquivo usamos:
unlink
sintaxe:
unlink(“nome_do_arquivo”)
Observe um exemplo, onde renomeamos o arquivo “meu_novo_arquivo.txt” para
“arquivo_texto.txt” e apagamos o arquivo “meu_arquivo.txt”:

PHP e MySQL 108
Após executarmos isso
no navegador,
percebemos as
mudanças ocorridas
dentro do diretório.
11.6. Manipulando Diretório.
Alguns comandos básicos são necessários para manipulação de diretórios, mostraremos apenas
como obter o diretório atual, como criar e apagar um diretório, para isso usamos os seguintes
comandos:
mkdir
Cria um diretório de acordo com a localização e o modo. Sintaxe:
mkdir(“string_localização”, “int_modo”);
string_localização é definido como o caminho com o nome do diretório,ou somente o nome.→
int_modo é onde definimos as permissões de acesso(como se fosse o chmod do Linux).→
Dessa forma podemos criar um diretório e já atribuirmos as permissões a ele.
getcwd
Retorna o diretório corrente, este comando é usado caso precise obter o diretório onde o arquivo
PHP que possui este comando está guardado.
sintaxe:
getcwd()
rmdir
Apaga um diretório.Sintaxe:
rmdir(“nome_diretório”);

PHP e MySQL 109
Observe o exemplo envolvendo os três comandos abaixo:
Exemplo: Resultado:
Observe que o comando getcwd obtêm o caminho completo de onde o arquivo PHP que contém o
códigofonte estar guardado.
1°)O que é manipulação de arquivos.
2°)Observe o códigofonte abaixo:
1 <?php
2 $arquivo = fopen("all.txt","w");
3 fwrite($arquivo, "oi tudo bem!");
4 fclose($arquivo);
5 ?>
a)Que tipo de arquivo é gerado na linha 2 e aonde o mesmo é criado.
b)Que o parâmetro “w” da linha 2 do código representa.
c)Qual a finalidade do comando fwrite da linha 3 do código.
d)Qual o principal motivo de fecharmos o arquivo com o comando fclose da linha 4 do código.
Crie um arquivo de texto chamado “frases.txt” usando o comando fopen, e responsa as questões
3,4,5,6,7
3°)Grave uma mensagem dentro do arquivo criado.
4°)Com base no arquivo criado, utilize o comando fwrite para ler o mesmo imprimindo na tela do
navegador o conteúdo do arquivo.
5°)Abra o arquivo “frases.txt” com um editor de texto, adicione cinco palavras, cada uma em uma
linha diferente, após isso utilize o comando file, para efetuar a leitura do arquivo, e imprima na tela
a primeira e ultima palavras com o comando echo.
6°)Crie uma cópia do arquivo renomeando o novo arquivo para “palavras.txt”.
7°)Agora apage o arquivo “frases.txt” com o comando unlink.
8°)Crie um diretório com o comando mkdir e copie o arquivo “palavras.txt” para a pasta criada e
apague o anterior, tudo com comandos PHP.
9°)Crie um código que imprima na tela todo o cominho de pastas onde se localiza o arquivo
“palavras.txt”.

PHP e MySQL 110
Capítulo 12. Interações PHP com HTML
Objetivos
Apresentar ao aluno como trabalhar com interações PHP dentro do código HTML; Mostrar exemplos
de formulário, o uso de métodos POST e GET, cookies, listagem, seção e suas interações com o Browser.
Abordaremos nesse capitulo algumas formas de interações utilizando a linguagem de
programação PHP e a linguagem de marcação HTML. Além disso, mostraremos alguns componentes
mais utilizados para a construção de um sistema ou uma página web, e de que forma o PHP pode
receber, processar, e enviar essa informação.
Utilizamos linguagens para exibir os dados da aplicação, seja ela para simples conferência, em
relatório ou ainda possibilitando a adição e exclusão de registros. Criaremos a principio formulários
e listagem.
12.1. Formulários
Podemos definir fomulário como um conjuntos de campos disponíveis ao usuário de forma
agrupada para serem preenchidos com informações requisitada pela aplicação ( sistemas web ou
páginas). Um formulário é composto por vários componentes, além de possuir botões de ação, no
qual define o programa que processará os dados.
Em uma aplicação determinamos então a entrada de dados( no caso os formulários ), e a saída de
dados, que é toda e qualquer informação apresentada ao usuário pelo browser, de forma que ambas
tenham uma ligação lógica e possa retornar um resultado onde todos os componentes da aplicação
trabalhem de forma coerente.
Elementos de um formulário.
Para criarmos um formulário, utilizamos a tag <form> e dentro dela podemos dispor diversos
elementos, onde, cada um deles representa uma propriedade em particular. A seguir explicaremos
os principais componentes de um formulário.
Criando um formulário:
Todo formulário deve conter no minimo as seguintes características, observe:
name Nome atribuído ao formulário para sua identificação.→
method Método POST ou GET como veremos mais adiante.→
action Caminho do arquivo que receberá os dados do formulário ao ser enviado.→
Os elementos do formulário serão preenchidos com os componentes input onde a tag é <input>
conforme o exemplo abaixo:
A tag input pode ser composta por vários elementos onde neles podemos definir o tipo,nome, e o

PHP e MySQL 111
valor padrão além de outras propriedades que não apresentaremos nessa apostila.
name Nome atribuído ao componente para sua identificação.→
value Valor padrão que pode ser atribuído no formulário.→
type Tipo de input, é nele onde definimos o tipo elemento o input vai representar.→
Observe a tabela abaixo com a definição dos tipos que podemos atribuir ao elemento type do
input.
type Descrição Exemplo:
texto Elemento utilizado para entra de texto simples,
é um dos mais utilizados.
password Elemento utilizado para entrada de senhas,
exibe “*” no lugar dos caracteres inseridos pelo
usuário.
checkbox Utilizado para exibir caiar de verificação, muito
utilizado para perguntas booleanas.
radio Exibe botões para seleção exclusiva, utilizado
para seleção de apenas um item.
file Utilizado para seleção de arquivos, esse tipo é
muito comum quando queremos enviar algo
pelo navegador(browser).
hidden É utilizado para armazenar um campo
escondido dentro do formulário.
Não é visível ao usuário.
button Usado para exibir um botão na tela, porém sua
ação é definida por outra linguagem como
javascript.
submit Botão usado para submeter os dados do
formulário no servidor, ele envia as informações
de acordo com as informações preenchidas na
tag <form>.
reset Utilizado para limpar todos os campo do
formulário, voltando ao valor inicial.
select Tipo utilizado para exibir uma lista de valores
contido na lista de seleção do usuário (cada
valor é guadardo rm uma tag <option>, porém
só pode ser selecionado uma opção.
Tag:
<textarea>
Área de texto disponibilizado ao usuário, possui
múltiplas linhas(rows) e colunas (cols) que
podem ser determinados dentro de sua tag. Não
é um tipo de input, mas é uma tag HTML para
formulário.
A tag <textarea> pode ser definida conforme o exemplo de código abaixo:

PHP e MySQL 112
Observe que definimos uma caixa de texto com 5 linhas e 27 colunas, isso define o tamanho que
essa caixa vai ter dentro do formulário.
12.2. Exemplo de formulário.
Veremos agora exemplos de alguns formulários comumente encontrados, usando os componentes
apresentado anteriormente. Não entraremos em detalhes do HTML, sendo apresentado de maneira
direta, pois está subentendido que o aluno já conheça HTML. Observe os exemplos abaixo:
Tela de login:
códigofonte:
Resultado:
Tela de Cadastro:
códigofonte:

PHP e MySQL 113
Resultado com dados preenchidos:
Tela de envio de dados e arquivos:
códigofonte:
Resultado:
Com esses exemplos, já podemos trabalhar com as informações até agora mostrada. Para isso
vamos conhecer os dois principais métodos de envio de dados de um formulário para um arquivo
PHP.

PHP e MySQL 114
12.3. Método Post e Get
Quando falamos em como enviar dados para um formulário, deve vir em mente os métodos GET
e POST, que são os métodos utilizados. Mas quando fazemos uma requisição HTTP, sempre
utilizamos um desses métodos, normalmente o GET.
Se você digita um endereço na barra de endereço seu navegador e aperta a tecla enter (ou clica
no botão ir), o navegador faz uma requisição HTTP para o servidor do endereço digitado e o
método dessa requisição é o GET. Se você clica em um link em um site, o navegador também se
encarrega de fazer um requisição HTTP com o método GET para buscar o conteúdo da página que
você clicou.
Esse mecanismo funciona da seguinte forma. Primeiro temos em um formulário, um botão ou
link. Quando clicamos em umas dessas propriedades, estamos enviando uma requisição. A forma de
enviar pode ser definida pelo método get ou post e deve ser enviada para algum arquivo, que ao
receber, processe a informação devolvendo resultado ou não. Veja a ilustração abaixo:

12.3.1. Método Get
O método GET utiliza a própria URI (normalmente chamada de URL) para enviar dados ao
servidor. Quando enviamos um formulário pelo método GET, o navegador pega as informações do
formulário e coloca junto com a URI de onde o formulário vai ser enviado e envia, separando o
endereço da URI dos dados do formulário por um “?” (ponto de interrogação) e “&”.
Quando você busca algo no Google, ele faz uma requisição utilizando o método GET, você pode
ver na barra de endereço do seu navegador que o endereço ficou com um ponto de interrogação no
meio, e depois do ponto de interrogação você pode ler, dentre outros caracteres, o que você
pesquisou no Google.
Abaixo temos um exemplo de uma URL do gmail da google, Observe:
Podemos notar a passagem de dois valores:
?hl = ptbr, logo após &shva=1, ou seja, temos então a criação da “variável” hl que recebe o valor
ptbr, e também a “variável” shva que recebe como valor 1. Veja exemplos de códigos com links
enviando valores por métodos GET.
Ao clicarmos em um desses links, podemos observar o seguinte comportamento na URL do
navegador:

PHP e MySQL 115
Link informação estamos enviando dois valores via método GET, um contendo 3, e o outro 4,→
para o arquivo gravar.php .
Link Entrar estamos enviando dois valores via método GET, um contendo 24, e o outro→
anonimo, para o arquivo gravar.php .
Formulário(<form>) Envias as informações preenchidas no input nome via GET para o→
arquivo gravar.php .
Recebendo dados via método GET
Agora trabalharemos com o arquivo PHP, onde podemos resgatar os valores enviados pelo método
$_GET,sua sintaxe é a seguinte:
$_GET['nome_da_campo'] retorna o valor passado pelo campo.→
$_GET retorna um array com todos os valore enviados e seus supostos índices.→
Quando queremos um valor especifico, colocamos o nome da “variável” da URL ou o nome
atribuído na propriedade name do input do formulário.
Exemplo com links:
código – HTML:
código – PHP(nome do arquivo: gravar.php): Resultado:
Exemplo com Formulário:
código – HTML:
Resultado no
Browser:
código – PHP(nome do arquivo: gravar.php):

PHP e MySQL 116
Resultado:
Em casos que precisamos de mais segurança, onde o ocultamento de informação é necessário, o
método GET não é uma boa opção. Observe no exemplo anterior que qualquer valor passado pela
URL fica visível, e o usuário pode ver informações pessoais como um login e uma senha.
Dica: Em casos semelhante, utilize sempre o método POST.
12.3.2. Método Post
Muito semelhante ao método GET, porém a principal diferença está em enviar os dados
encapsulado dentro do corpo da mensagem. Sua utilização é mais viável quando trabalhamos com
informações segura ou que poder ser alteradas somente por eventos do Browser. Sintaxe:
$_POST['nome_da_campo'] retorna o valor passado pelo campo.→
$_POST retorna um array com todos os valore enviados e seus supostos índices.→
Veja o mesmo exemplo anterior, porém com o uso de POST:
Exemplo com Formulário:
código – HTML:
código – PHP(nome do arquivo: gravar.php):
Resultado após o envio dos dados preenchidos:
Com o uso do método post, as informações ficam invisíveis ao usuário, isso evita que alguma
causa malintencionada venha tornar os dados inconsistentes( dados sem fundamentos ou falsos).
Mudança no método

PHP e MySQL 117
12.4. Interações com o Browser
PHP também permite interagir com informações do browser automaticamente. Isso pode ser
muito útil quando queremos coletar informações sobre o cliente, como por exemplo, o tipo de
browser(navegador), ou qual o sistema operacional, dentre outras informações.
O código a seguir mostra informações sobre o browser do usuário:
A variável global $HTTP_USER_AGENT tem como finalidade retornar informações do cliente que
está acessando o arquivo PHP pelo browser, abaixo um exemplo desse retorno:
Já vimos que a variável $HTTP_USER_AGENT retorna uma string com várias informações, com
isso podemos utilizar a função strpos(), que tem como finalidade procurar valores de uma string
menor dentro de uma string maior. Podemos desta forma otimizar o nosso código. Sintaxe:
strpos( “string_maior” , “string_menor” )
Observe outro código com o uso da função strpos() :
Nesse exemplo procuramos as palavras “Firefox” e “MSIE” dentro do valor retornado pela variável
global $HTTP_USER_AGENT. Dessa forma, podemos tratar o resultado comparandoo com “0”, ou
seja, se a palavra existir, significa que seu valor é diferente de “0”. O resultado impresso na tela é de
acordo com o navegador do cliente.
Exemplo de requisição HTTP_USER_AGENT:

PHP e MySQL 118
12.5. Cookies
Cookies são mecanismos para armazenar e consultar informações. Eles são armazenados na
maquina do cliente que acessa ao servidor php, e possui várias atribuições que são definida pelo
programador, por exemplo: imagine uma loja virtual, onde o cliente colocou em seu carrinho de
compras vários produtos, mas por algum motivo ele não concluiu a compra, tendo que desligar a
maquina que foi utilizada para fazer o acesso. No dia seguinte o cliente entra no mesmo site e
percebe que todos os itens ainda estão no carrinho de compra do jeito que ele deixou, esperando a
conclusão da compra. Nesse exemplo, podemos perceber que as informações foram gravadas na
maquina do cliente através dos cookies, que são simplesmente arquivos gerados pela página
acessada dentro de alguma pasta do navegador que existe exclusivamente para esses arquivos.
O PHP atribui cookies utilizando a função setcookie que deve ser utilizada antes da tag <html>
numa página. Além disso o uso de cookies não é recomendado quando se trata de informações
sigilosas. Os dados dos cookies são armazenados no diretório de arquivos temporários do visitante,
sendo facilmente visualizado por pessoas mal intencionadas.
Além da opção “aceitar cookies” que pode ser desativada a qualquer momento pelo visitante. Mas
em cada navegador essa opção pode mudar de nome. Observe o comando abaixo:
setcookie
Sua sintaxe possui muitos parâmetros, abaixo está representada todos os valores que podem ser
atribuído ao setcookie, mas vale ressaltar que não utilizaremos todos eles, somente os principais,
veja sua sintaxe.
Setcookie(“nome_do_cookie”,”seu_valor”,”tempo_de_vida”,”path”,
”domínio”,”conexão_segura”)
Onde na tabela abaixo temos a descrição de cada atributo:
Atributo Descrição
nome_do_cookie É o nome que, posteriormente, se tornará a variável e o que o servirá
de referência para indicar o cookie.
seu_valor É o valor que a variável possuirá. Esse valor pode ser de todos os tipos.
seu_valor É o tempo, em segundos, que o cookie existirá no computador do
visitante. Uma vez excedido esse prazo o cookie se apaga de modo
irrecuperável. Se esse argumento ficar vazio, o cookie se apagará
quando o visitante fechar o browser.
path endereço da página que gerou o cookie – automático
domínio domínio ao qual pertence o cookie – automático
conexão_segura Indica se o cookie deverá ser transmitido somente em uma conexão
segura HTTPS.
Observe um código onde criamos um cookie:


PHP e MySQL 119
Criamos então uma string, logo após a função setcookie recebendo como parâmetro somente o
seu nome e o valor a ser gravado.
Usaremos o navegador Mozilla Firefox para visualizarmos o cookie criado, para isso basta digitar
o endereço http://localhost na url, e logo após ir na opção: Ferramentas Propriedades da→
página Segurança Exibir cookie.→ → Lembrese de criar o código acima primeiro e depois fazer a
chamada pelo navegador de sua maquina. Se tudo ocorrer corretamente deverá aparecer a seguinte
tela:
Veja que outras informações como
caminho, enviar, e validade não foram
especificados, porém podemos determina
los na hora da criação do cookie dentro do
código php.
Mostraremos agora um código onde
atribuímos o tempo de vida do cookie, para
isso devemos capturar o tempo com a
função time() atual e somálo ao tempo que
queremos em segundos, isso faz com que o
cookie exista na maquina do cliente de
acordo com a quantidade de tempo
determinado pelo programador, observe um
exemplo onde atribuirmos mais esse
parâmetro o função setcookie:
Exemplo:
O novo resultado é o seguinte:
Esse cookie tem a validade de 3600
segundos, ou seja 1 hora, com isso
concluímos que o navegador fez seu acesso
as 14:47:36. Isso é muito importante para a
programação dos cookies. Se quisermos
que ele exista por um determinado tempo,
temos que calcular tudo em segundos da
seguinte forma:
$tempo = time()+(3600*24*7);
Esse cookie tem seu tempo de vida de 7
dias, pois 3600 segundos = 1 hora, 24
horas = 1 dia e 7 * horas_de_um_dia
resulta em 7 dias.
Exemplo:
Valor do cookie
Nome do Cookie
Data de vencimento do cookie,
após ela ele é deletado
automaticamente

PHP e MySQL 120
Validade:
Validade de 7 dias a partir do dia 12.
Acessando um cookie:
Para acessarmos o valor gravado em um cookie é bem simples, basta utilizar o comando
$_COOKIE['coloque_aki_o_nome_do_cookie'], exemplo:
Resultado: valores a serem gravados
Observe agora um exemplo de um código utilizado para contar as visitas de um site usando
cookie:
O resultado é de acordo com a quantidade de vezes que o cliente entrou no site ou atualizou o
mesmo.
12.6. Sessão
Sessões são mecanismos muito parecidos com os tradicionais cookies. Suas diferenças são que
sessões são armazenadas no próprio servidor e não expiram a menos que o programador queira
apagar a sessão.
As sessões são métodos de manter (ou preservar) determinados dados a mantêlos ativos
enquanto o navegador do cliente (o internauta) estiver aberto, ou enquanto a sessão não expirar
(por inatividade, ou porque em algum ponto você mandou que ela expirasse).
Para criarmos uma sessão utilizaremos a função abaixo:
Dessa forma estamos iniciando um conjunto de regras. essa
função deve sempre estar no início do códigofonte, com
exceção de algumas regras.
Agora trabalharemos com essa sessão, primeiro podemos determinar o tempo de vida da sessão
com o seguinte comando:
Neste caso, session_cache_expire vem antes de session
start. Porque primeiro ele avisa que a sessão, quando
iniciada, deve expirar em 5 minutos, e depois a inicia.

PHP e MySQL 121
Com o comando $_SESSION podemos gravar valores na sessão, veja um exemplo:
Criamos uma sessão com o nome minha_sessao(não é uma boa prática de programação usar
acentos em nomes de variáveis ou qualquer outra nomeação) e atribuímos a ela o valor gravado na
variável string $var. Essas informações ficam gravadas no servidor, logo após podemos resgatar o
valor da seguinte forma:
Observe que o comando $_SESSION tem seu tratamento igual a uma variável do tipo Array. Para
resgatar o valor da sessão, basta fazer a chamada do comando passando o nome da sessão, no caso
“minha_sessao”. O exemplo anterior foi adicionado em um outro arquivo, por esse motivo temos
que chamar novamente o comando session_start(), para trazermos ao arquivo todas as regras
usadas em sessão no PHP.
Abaixo temos um exemplo com o uso da função isset(), que verifica se uma variável existe ou
não, retornando um valor booleano( true ou false ):
O resultado é de acordo com a
existência ou não da sessão.
Para desativarmos uma sessão podemos utilizar dois tipos de mecanismos: um deles é o uso da
função session_destroy() que tem como finalidade destruir todas as sessões criada pelo usuário, a
outra forma é desalocarmos a sessão criada com o uso da função unset().
Uso de session_destroy():
Uso de unset():
Usamos unset() quando queremos desalocar uma determinada sessão, imaginamos que o usuário
ao acessar uma determinada página, tenha criado várias sessões com nomes diferente. Os nomes
das sessões são determinada pelo programador, porém ao clicar em um link, o mesmo tem que
destruir a seção escolhida. O exemplo abaixo destrói a sessão especificada:
Dessa forma desalocamos(destruirmos) a
sessão “minha_sessao”, porém se existirem
outras, elas ainda continuarão ativas.

PHP e MySQL 122
12.7. Requisição de Arquivos
Assim como em muitas outras linguagens de programação também é possível incluir dentro de
um script PHP outros arquivos contendo outras definições, constantes, configurações, ou até mesmo
carregar um arquivo contendo a definição de uma classe. Para isso podemos usar os seguintes
comandos:
include<arquivo>:
A instrução include() inclui e avalia o arquivo informado. O código existente no arquivo entram
no escopo do programa que foi inserido, tornandose disponível a partir da linha em que a inclusão
ocorre. Se o arquivo não existir, produzirá uma mensagem de advertência(warning).
Exemplo onde temos dois arquivos:
código do arquivo_teste.php código do arquivo index.php
Resultado:
Nesse exemplo podemos notar que o código existente no “arquivo_teste.php” foi inserido dentro
do arquivo index.php, tendo como resultado a execução dos dois códigos como se fossem apenas
um, esse recurso é muito utilizado, pois podemos incluir até mesmo códigos de páginas inteiras em
um arquivo.
require<arquivo>:
Comando muito parecido ao include. Difere somente na manipulação de erros. Enquanto o
include produz uma warning, o require uma mensagem de Fatal Error caso o arquivo não exista.
Sintaxe: require 'nome_do_arquivo.php';
include_once<arquivo>:
Tem funcionalidade semelhante ao include, a diferença é que caso o arquivo informado já esteja
incluído, esse comando não refaz a operação, ou seja, o arquivo é incluído apenas uma vez. Este
comando é útil para garantir que o arquivo foi carregado apenas uma vez. Caso o programa passe
mais de uma vez pela mesma instrução, evitará sobreposição de arquivo.
Sintaxe: include_once 'nome_do_arquivo.php';
require_once<arquivo>:
Tem funcionalidade parecida com o comando require. A diferença é justamente caso o arquivo já
tenha sido incluído no programa, pois ele não carrega novamente o código. É muito semelhante ao
include_once, evitando redeclarações ou sobreposições, porém a mensagem exibida caso o arquivo
não exista é de Fatal Error.
Sintaxe: require_once 'nome_do_arquivo.php';

PHP e MySQL 123
12.8. Tratamentos de erro.
São muito comuns erros na programação PHP, que podem partir do programador como pessoa
física, do servidor, ou outros fatores envolvidos que juntos venham ocasionar em um erro. Existem
quatro tipos de erros no PHP para indicar a gravidade do erro encontrado ou ocorrido. Eles são:
1. Erros de funções (function errors).
2. Avisos (warnings).
3. Erros de processamento (parser error).
4. Observações (notice).
Os programadores devem prestar muita atenção nas mensagens de erro, afinal nenhum
programador quer por no ar um sistema que quando o primeiro visitante entra apareça uma
mensagem de erro. Para evitar essas inconveniências use sempre um “@” antes de cada chamada as
funções. Se a opção track_errors no arquivo php.ini estiver habilitada, a mensagem de erro
poderá ser encontrada na variável global $php_errormsg. Para exibir a mensagem direta no
navegador procure ativar a opção display_errors, as funções serão ativadas para On(ligada) ou
Off(desligada).
O arquivo php.ini no linux geralmente fica na pasta: “/etc/php5/apache2/php.ini” .
Veja o Exemplo:
Imprimindo a mensagem de erro:
Resultado:
Mensagem de erro com a opção display_errors = On do php.ini ativada:
Warning: strtolower() expects exactly 1 parameter, 0 given in /var/www/index.php on line 2
O erro mostra que devemos passar um parâmetro para a função strolower() na linha 2, mas
podemos ignorar o erro usando o “@”.
Essa função deixaria todos os caracteres em minúsculo, mas seu erro foi ignorado, não
exibindo nenhuma mensagem de erro.
Lembrando: podemos utilizar tag's curtas no PHP “ <? ?>” em vez de tags normais
“<?php ?>”, mas isso vai depender da configuração do PHP (php.ini), em alguns
casos não funciona.

PHP e MySQL 124
1°)Crie um formulário HTML com os seguintes campos:
“nome”, “endereço”, “email”, “senha”, e o botão “enviar”.
2°)Utilize o método Get para visualizar os dados do array na URL do navegador ao clicar no
botão enviar.
3°)Qual a diferença do método POST e GET.
4°)Como podemos receber dados via método GET. Exemplifique.
5°)Como podemos receber dados via método POST. Exemplifique.
6°)Crie um arquivo chamado dados.php, nesse arquivo deverá conter os seguintes
requisitos:
Os dados do formulário da questão 1 deverá ser enviado para esse arquivo via metodo
POST.
O aquivo dados.php deverá conter cinco variáveis, cada uma para determinado campo,
exemplo:
$nome = $_POST['nome'];
Os valores deverá ser impresso na tela.
7°)Qual a finalidade da variável global $HTTP_USER_AGENTE.
8°)Crie um cookie gravando nele o seu nome, logo após abra o Firefox e Exiba o valor gravado.
9°)Crie um arquivo chamado “criar_sessao.php”, utilize comando PHP para cria uma seção com a
durabilidade de 3 minutos e adicione o valor “sessão ativa”.
10°)Crie um novo arquivo chamado “ler_sessao.php” para verificar se a sessão criada na questão 9
existe ou não. Utilize o comando $_SESSION para ler o valor nela contido e imprima na tela.
11°)Quais os possíveis erros existentes em PHP e qual a definição de cada um deles.

PHP e MySQL 125
Capítulo 13. Introdução ao MySQL
Objetivos
Apresentar ao aluno as principais estruturas do banco de dados MYSQL de forma prática e explicativa.
Abordar os principais comando SQL.
13.1. O que é o MYSQL?
O MySQL é um completo sistema de gerenciamento de bancos de dados relacional. Tem como
características mais marcantes a estabilidade e agilidade. Foi
criado por uma empresa sueca chamada TcX e vem sendo
desenvolvido por mais de 10 anos. O seu intuito ao criálo foi
de prover a seus clientes um produto altamente estável, rápido
e seguro. Atualmente é um dos SGBDs (Sistema Gerenciador de
Banco de Dados) mais utilizados na Internet. Várias linguagens
de programação têm interface com este, como o PHP, Java
(JDBC), Perl, TCL/TK, Python, C/C++, etc, e ainda ODBC.
Outro ponto forte é sua portabilidade. Exitem versões para os
mais diversos sistemas operacionais como Linux, FreeBSD, OpenBSD, NetBSD, Solaris, Windows
95/ 98/ NT/ 2000/ XP/ Vista/ Windows 7, HPUX, AIX, etc.
Já virmos a instalação do MYSQL no Linux no capítulo1.2.3, onde instalamos também o
PhpMyAdmin para administrarmos o banco de dados no modo gráfico e pelo navegador.
13.2. Trabalhando com MYSQL.
Para logarmos no mysql temos que abir o Konsole(terminal) e digitar o seguinte comando:
mysql -u root -p
u usuário, define o nome do usuário.→
p password, pedido de senha.→
Logo após esse comando uma senha será pedida. Digite a senha que foi definida na instalação do
banco. Depois de logarmos visualizaremos a seguinte tela:
Agora estamos logado no gerenciador de banco de dados MYSQL. Para sair do banco digite: quit
ou exit e logo após der um enter.
Um banco de dados trabalha basicamente com tabelas, e cada tabela possui uma determinada
quantidade de linhas(registros) e colunas(campos). As informações
são gravadas para futuramente serem inseridas,
alteradas(atualizadas), ou deletadas.
O primeiro passo é visualizarmos alguns bancos de dados que
vem como padrão, para isso utilizamos comando show databases,
veja ao lado:
Sempre utilize “;” para finalizar qualquer comando. Podemos
perceber que na maquina que foi utilizado esse comando, foram
encontrados cinco banco de dados.
Nome do usuário.

PHP e MySQL 126
13.2.1. Estruturas de Dados
Os tipos de dados possuem diversas formas e tamanhos, permitindo ao programador criar tabelas
específicas de acordo com suas necessidades. Podemos definir a hierarquia de banco de dados da
seguinte forma: Banco de dados > Tabela > Registro > Tipo de dados, conforme a figura abaixo:
O MySQL provê um conjunto bem grande de tipos de dados, entre eles podemos citar os
principais:
Tipo de dado Descrição
CHAR(M) strings de tamanho fixo entre 1 e 255 caracteres.
VARCHAR(M) strings de tamanho flexível entre 1 e 255 caracteres.
VARCHAR ocupa sempre o menor espaço possível, no entanto é 50% mais lento que o tipo CHAR.
INT(M)[Unsigned] números inteiros entre 2147483648 e 2147483647. A opção "unsigned" pode ser usada
na declaração mudando o intervalo para 0 e 4294967295 para inteiros não sinalizados.
FLOAT [(M,D)] números decimais com D casas decimais.
DATE: armazena informação relativa a datas. O formato default é 'YYYYMMDD' e as datas
variam entre '00000000' e '99991231'. MySQL provê um poderoso conjunto de
comandos para formatação e manipulação de datas.
TEXT/BLOB: strings entre 255 e 65535 caracteres. A diferença entre TEXT e BLOB é que no primeiro
o texto não é sensível ao caso e no segundo sim.
BIT ou BOOL um número inteiro que pode ser 0(falso) ou 1(verdadeiro).
DOUBLE número em vírgula flutuante de dupla precisão. Os valores permitidos vão desde
1.7976931348623157E+308 até 2.2250738585072014E308, 0 e desde
2.2250738585072014E308 até 1.7976931348623157E+308
Existem outros tipos de dados, para mais detalhes consulte o site oficial do MYSQL
(http://www.mysql.com/).
Abaixo temos exemplos dessas estruturas:
Tipos de dados e seus
respectivos tamanhos
Nomes dos campos.

PHP e MySQL 127
13.2.2. Criando Banco e Tabelas
Agora que conhecemos algumas estruturas (tipos de dados), podemos começar a trabalhamos
com alguns comandos, de acordo com a hierarquia criaremos o banco de dados e depois as tabelas:
CREATE DATABASE
Após logar no MYSQL podemos cria qualquer base de dados com a seguinte sintaxe:
CREATE DATABASE 'nome_do_banco';
Exemplo:
Criamos então um banco de dados chamado alunos
Dica: Os comando funcionam normalmente em minusculo, mas por padrão é bom sempre
utilizar os comando SQL em maiúsculo para diferenciálos dos nomes e atribuições,
facilitando assim a organização.
Novamente com o comando SHOW DATABASE podemos visualizar todos os bancos de dados
inclusive o que acabamos de criar:
Após criamos o banco de dados alunos,
temos que conectarmonos a ele para iniciar
qualquer operação.
Para isso é utilizado comando USE com a
seguinte sintaxe:
USE 'nome_do_banco';
Exemplo:
Com esse comando, todas as operações que forem realizadas afetará
de forma direta somente o bando de dados alunos. A mensagem
Database changed significa bando de dados alterado.
CREATE TABLE
Uma base de dados pode possuir várias tabelas, onde cada uma tem seu papel especifico e estão
relacionadas de forma direta ou não, para criarmos uma tabela usaremos a seguinte sintaxe:
CREATE TABLE 'nome_da_tabela' (
'nome_dos_campos' tipo_de_dado(tamanho) 'comandos...',
... ,
...
);
Exemplo:
Nem todo tipo de dado tem um tamanho, como por
exemplo o tipo DATE. Além disso o comando NULL
significa que a informação inicial daquele campo é nulo.
Para visualizar detalhes da tabela criada utilize o
comando DESCRIBE 'nome_da_tabela', veja o exemplo:
Aqui estar nosso
bancos de dados.

PHP e MySQL 128
Exemplo:
Para exibir as tabelas use o comando
SHOW TABLES;
DROP
Para apagar o banco de dados ou a tabela, usamos o comando DROP com a seguinte sintaxe:
DROP DATABASE 'nome_do_banco'; //Usado para apagar o banco de sados
DROP TABLE 'nome_da_tabela'; //Usado para apagar tabelas.
Exemplo:
Apaga o banco de dados nomes. Apaga a tabela dados.
13.2.3. Manipulando dados das tabelas
Para manipulação dos dados de uma tabela usamos os seguintes comandos:
INSERT
Usado para inserir informações em uma tabela. Possui a seguinte sintaxe:
INSERT INTO nome_da_tabela(campo1,campo2,...,...)
VALUES(valor1,valor2,...,...);
O valor é inserido na tabela na mesma ordem que é definida os campos, ou seja, o campo1
receberá o valor1, o campo2 o valor2 e assim sucessivamente.
Exemplo:
SELECT
Permite recuperar informações existentes nas tabelas. Sintaxe:
SELECT 'campo1','campo2',...,... FROM 'nome_da_tabela';
Exemplo:
Abaixo temos a exibição somente dos campos especificados após o SELECT. Caso queira visualizar
todos os dados utilize asteriscos(*) conforme a segunda figura.
ou

PHP e MySQL 129
UPDATE
Usado para atualização dos dados, que altera os valores dos campos em uma tabela especificada
com base em critérios específicos. Sintaxe:
UPDATE nome_da_tabela
SET campo1 = 'novo_valor',campo2 = 'novo_valor',...,...
WHERE critério;
Exemplo:
Imagine mais de 1000 registros e
você precise alterar somente 1,
nesse caso usamos o critério sendo
definido com o id, ou seja, a alteração é feita aonde o id = 1, em nosso exemplo.
DELETE
Remove registros de uma ou mais tabelas listadas na cláusula FROM que satisfaz a cláusula
WHERE. Sintaxe:
DELETE FROM nome_da_tabela WHERE critério;
Exemplo:
Foi deletado a informação do id 3;
Obs.: muito cuidado quando usar o comando DELETE. Caso o critério saia errado por um
erro do programador, poderá ser deletado todos os dados da tabela.
COMANDOS ADICIONAIS
Vimos até agora alguns comandos principais, ainda existem outros comando que adicionado nos
comando SELECT,UPDATE, DELETE forma uma conjunto de manipulações.
Comandos Descrição
DISTINCT Elimina linhas duplicadas na saída.
AS um aliás para o nome da coluna.
FROM Lista as tabelas na entrada.
WHERE Critérios da seleção.
ORDER BY Critério de ordenação das tabelas de saída. ASC ordem ascendente, DESC ordem
descendente.
COUNT(*) Usado no SELECT, conta quantos registros existem na tabela.
AND Usado para dar continuidade a mais de um critério.
PRIMARY KEY Chave primaria definida na criação da tabela, evitando duplicidade de dados em um
mesmo campo.
FOREIGN KEY Chave estrangeira definida na criação da tabela, usada para fazer ligações entre tabelas
de um banco de dados relacional.
Dica: Para mais detalhes consulte materiais disponíveis na internet, livros, tutoriais, vídeo
aulas e outras apostilas de MYSQL ou SQL.

PHP e MySQL 130
13.3. Trabalhando com PhpMyAdmin.
O phpMyadmin é basicamente um frontend para administração de bancos de dados MySQL.
Ele dispõe de uma série de recursos interessantes para administração do banco de dados. Com
essa ferramenta é possível fazer desde atividades básicas de administração como criar, alterar,
renomear tabelas, ou ainda fazer consultas usando SQL, como também gerenciar as conexões com o
banco.
Vimos a sua instalação no capítulo 1.2.4, onde copiamos para a pasta var/www o seu conteúdo.
Para fazer o login na ferramenta abra o navegador e digite http://localhost/phpmyadmin/,
aparecerá a seguinte tela:
Utilize o usuário e a senha que foi
definida na instalação:
Exemplo:
Usuário: root
Senha: 1234
Após o login visualizaremos a seguinte tela:
Acima temos a figura da página inicial do phpMyAdmin. No frame do lado esquerdo está a lista
de todos os bancos de dados que existem no servidor. Clicando nesses bancos é possível navegar
através das tabelas do banco escolhido e chegar até os campos desta tabela. Na página inicial do
phpMyAdmin, mostrada acima, ainda é possível ver documentação e existe um box para criação de
um novo banco de dados.
Todas as funcionalidade que utilizamos no Konsole(Terminal), anteriormente pode ser feito de
forma mais simples e prática usando a interface gráficas do PhpMyAdmin.
Informações do
servidor
Lista de banco de dados
Menus
Painel de criação de
banco de dados.

PHP e MySQL 131
Veremos agora algumas funcionalidades.
13.3.1. Manipulando banco de dados no PhpMyadmin.
Podemos observar na tela inicial a opção para criarmos um banco. Insira um nome e clique em
criar:
Após criarmos o banco de dados podemos observálo na lista de bancos ao lado esquerdo. Clique
no banco que acabamos de criar.
Após clicarmos podemos criar as tabelas com a opção abaixo:
Após executarmos a tabela, visualizaremos uma serie de informações detalhadas dos campos da
tabela criada. Definimos então, os tipos de dados que a tabela vai suportar e seus respectivos
tamanhos.
A tabela abaixo mostra os campos adicionados.
Campo Tipo tamanho nulo índice Auto incremento
id int 11 primary x
nome varchar 30 x
rua varchar 40 x
bairro varchar 40 x
cidade varchar 40 x
Em índice, definimos o id como chave primária, onde os valores não podem ser duplicados, e
também auto incremento, onde tem a finalidade de incrementar valores automaticamente sem
precisar inserilos de forma manual. Nulo significa que ao inserirmos um valor, os demais campos
não tem a obrigação de serem preenchidos, com isso seu valor pode ficar null(nulo). Os demais
itens do campo podem ser deixado do jeito que estão, agora é só clicar em Salvar
Nome da tabela. Quantidades de campos da tabela.

PHP e MySQL 132
Dica: observe que a cada procedimento o comando a ser executado é exibido.
Tela de comandos:
Após criarmos a tabela podemos inserir valores em seus campo, para isso entre no banco de
dados criado e escolha a tabela conforme a figura abaixo:
Ao clicar aparecera uma nova tela, escola a opção inserir.
Ao entrar na opção inserir, será exibido a seguinte tela:
Agora basta inserir os
valores e executar em
seguida, lembrando que
não se deve preencher o
campo id, pois ele é auto
incremento.
Para alterar os valores dos campos entre novamente na tabela e observe a seguinte tela:
Temos apenas um registro.
Opção para inserir dados.
Esta opção edita os valores do campo.
Apaga o registro.

PHP e MySQL 133
Ao clicar teremos a seguinte tela:
Agora basta editar os
valores.
Até agora colocamos em prática os seguintes comandos:
INSERT quando inserimos dados.→
SELECT quando visualizamos as informações da tabela.→
UPDATE quando editamos os valores adicionados.→
DELETE ao apagamos o campo da tabela.→
Abaixo temos uma tabelas com algumas da principais funcionalidades do PhpMyAdmin.
Menu Funcionalidade
Visualizar   Aqui é possível visualizar os registros da tabela e também modificar cada
registro individualmente.
Estrutura Nesta opção é possível ver os campos da tabela, também modificar estes
campos e até mesmo excluílos.
SQL   A opção SQL permite você digitar livremente um comando SQL diretamente
numa caixa de texto.
Procurar   É possível realizar pesquisas nos registros da tabela. Este recurso é muito útil
quando se deseja encontrar determinado registro em uma tabela muito extensa.
Inserir Permite inserir um registro na tabela.
Exportar Com a opção Export (Exportar), é possível gerar um arquivo texto com todo o
conteúdo da tabela, juntamente com sua estrutura.
Importar Importa um arquivo com comandos sql para dentro do banco.
Operações Igual e do mesmo tipo permite realizar modificações na tabela, como renomear,
alterar ordem, movêla para outra database, alterar seu tipo e outras operações.
Privilégios Área onde é feita a administração de usuários e suas permissões.
Designer Mostra todas as tabelas e seus relacionamentos em diagramas.
Obs.: Não abordamos definições de chave primaria (PRIMARY KEY), e chave
estrangeira(FOREIGN KEY), pois esse assunto é mostrado com mais detalhes em
modelagem de banco de dados.

PHP e MySQL 134
1°) Qual a definição que podemos atribuir ao conceito de banco de dados.
2°) Como podemos logar pelo Konsole no MYSQL.
3°) O que é estrutura de dados em MYSQL.
4°) Faça o seguinte exercício prático:
a)crie uma tabela com os campos nome e sobrenome.
b)após criar visualize a tabela.
c)insira alguns valores na tabela, no caso nomes e sobrenomes de pessoas conhecidas.
d)crie um SELECT para visualizar todas as informações gravadas no banco.
e)agora atualize alguns dos campos com o comando UPDATE.
5°)Abra o PhpMyAdmin e visualize a tabela criada na questão 4.
6°)Qual a finalidade da ferramenta PhpMyadmin.
7°)Pesquise sobre banco de dados relacional e diga porque o MYSQL é considerado um
bando de dados relacional.
8°)Pesquise e defina o que é chave primeira e chave estrangeira em banco de dados
relacionais.

PHP e MySQL 135
Capítulo 14. PHP com Banco de dados MYSQL.
Objetivos
Fazer conexão com o banco de dados usando comandos do PHP; Mostrar ao alunos as principais
interações com consultar, inserir, atualizar e deletar informações de um database(banco de dados).
14.1. Criando e Selecionando a Conexão
Para acessar uma base de dados num servidor MySQL, é necessário antes estabelecer uma
conexão. Para isso, deve ser utilizado o comando mysql_connect, ou o mysql_pconnect. A diferença
entre os dois comandos é que o mysql_pconnect estabelece uma conexão permanente, ou seja, que
não é encerrada ao final da execução do script. As assinaturas dos dois comandos são semelhantes,
como pode ser verificado na sintaxe abaixo:
mysql_connect
mysql_connect('endereço_do_servidor_mysql':'porta','login','senha');
mysql_pconnect
mysql_pconnect('endereço_do_servidor_mysql':'porta','login','senha');
Ambas conexões retornam um id que será usado posteriormente. Também podemos colocar essas
funcionalidades dentro de um IF para tratarmos a conexão. Veja o exemplo abaixo :
Utilizamos o “@” ignorar o
erro da conexão, porém caso
tenha algum erro será tratado
de acordo a programação do
IF.
O endereço do nosso servidor é localhost ou o ip 127.0.0.1, mas há casos que o servidor é externo
e é preciso utilizar o ip ou domínio com a porta, isso vai depender se o serviço de banco de dados
está na mesma maquina ou não. Vale ressaltar que o login e a senha são as mesmas utilizada na
instalação do MYSQL, e caso ocorra algum erro o código acima, entrará no else e exibirá a
mensagem “Erro ao conectar!”.
Depois de estabelecida a conexão, é preciso selecionar a base de dados a ser utilizada, através do
comando mysql_select_db, que segue a seguinte sintaxe:
mysql_select_db('nome_do_banco' , 'id_conexão');
mysql_select_db() define o banco de dados ativo no servidor que é associado ao identificador de
conexão especificado. Se nenhum identificador de conexão é especificado, a ultima conexão aberta
é assumida. Veja um exemplo de seleção de database:
Após toda execução do
código, podemos utilizar o
comando mysql_close(); para
fechar a conexão.
Passamos no exemplo o nome do banco que criamos no capítulo anterior, caso não exista
crie o banco conforme foi mostrado no capitulo 9.2.2 ou 9.3.1 .

PHP e MySQL 136
14.2. Manipulando Dados do Database
Após a execução dos dois comandos anteriores, podemos fazer as mesmas manipulações que
fizermos diretamente no Konsole(Terminal) ou no PhpMyAdmin usando comandos e funções
existentes no PHP.
mysql_query
Esse comando é utilizado quando queremos enviar uma query para o banco de dados ativo no
servidor da conexão informada pela conexão. Sintaxe:
mysql_query('comando_SQL','id_conexão');
Podemos utilizar comando SQL dentro dessa função para manipularmos informação. Veja o
Exemplo:
Resultado em Konsole:
Podemos observar que qualquer comando SQL pode ser executado de
forma direta na função mysql_query como se fosse no Konsole, com a
exceção de comandos que retorne resultados como o SELECT,
DESCRIBE (DESC), dentre outros. Essa função retorna somente o Id da
query, e não a string com valores do banco.
mysql_result
Este comando deve ser utilizado apenas para resultados seletivos onde podemos determinar de
qual linha e coluna da tabela queremos obter o valor. Podemos determinar somente a linha, porém a
coluna tem que ser determinada no comando SQL. Sintaxe:
mysql_result('comando_SQL','numero_da_linha','numero_da_coluna');
Exemplo:
poderíamos ter definido somente a linha da seguinte forma:
Observe que o resultado imprime
a linha 0 (primeira linha) da coluna
cidade(coluna 4).
Nota: A string da query não deve terminar com ponto e virgula(;).
Tabela criada.
Comando SQL.
Resultado do
mysql_query().
Linha 0 Coluna 4
Select retorna todos (*)
resultados da tabela
dados_pessoais

PHP e MySQL 137
mysql_fetch_array
Esse comando retorna um array de valores contido no bando de dados, muito usado quando
queremos percorrer um conjunto de valores retornado pela query. Dessa forma, é possível obtermos
todas as linhas da tabela especificada, onde cada linha é gravada em uma posição do array. Sintaxe:
mysql_fetch_array('id_resultado_query');
Esse comando recebe como parâmetro “id_resultado_query” que é o retorno do comando
mysql_query. Dessa forma, ele monta um array com os valores de acordo com o comando SQL.
Veja como chegamos em um resultado usando HTML, PHP e comandos SQL no MYSQL conforme
o exemplo abaixo:
1° Criamos uma tabela cadastro no banco de dados alunos com o PhpMyAdmin com as seguintes
características:
Obs.: Caso o banco de dados não exista, leia o tópico: “Manipulando banco de dados em PHP”.
2º Após isso, insira alguns valores na tabela. No caso alguns nomes e telefones. Exemplo:
Agora podemos trabalhar com códigos PHP para fazer a consulta de todos os valores e ordenar
em uma tabela HTML.
3º Criamos então uma conexão e selecionamos o database(banco de dados).
4º Agora criamos um query(comando SQL) para selecionar os valores e gravamos em uma
variável, lembrando que isso é uma string e não tem funcionalidade até então.
5º Criamos então um “id_resultado_query” com o comando mysql_query, recebendo a query e a
conexão como parâmetro.
6º – Agora usamos o comando
mysql_fetch_array para criar um array de
informações, porém adicionamos dentro de um
while e criamos a cada loop uma linha na
tabela criada em HTML. Essa é a estrutura da
tabela que iremos usar, basta adicionar as tag's
PHP dentro do documento. Lembrando que esse
arquivo se chama index.php e tem que estar
dentro da pasta ver/www.

PHP e MySQL 138
Com as tags PHP o código fica assim:
A variável $linha a cada
loop, tornase um array de 3
posições, e cada posição é
definida pelos nomes do
campos da tabela.
Código completo: Resultado:
14.3. Criação de CRUD.
Um dos termos mais comuns quando estamos falando de programação e banco de dados, é a
criação de um CRUD(acrônico de Create, Retrieve, Update e Delete em língua Inglesa) que significa
as quatros operações básicas de um banco de dados, que são elas: criar, recuperar, atualizar e
deletar(apagar).
Criaremos então um aplicativo em PHP onde podemos estabelecer de forma clara essas
operações. Preste muita atenção, pois trabalharemos com mais códigofonte. Trabalharemos com o
banco de dados criado anteriormente e criaremos quatro arquivos com os seguintes nomes:
index.php arquivo inicial do aplicativo WEB, nele ficará o formulário de cadastro e os códigos→
de consulta(listagem).
conexao.php → arquivo responsável pela conexão e seleção do banco de dados, não utilize
acentos nas nomenclaturas do arquivos.
editar.php arquivo responsável pela edição dos dados da tabela. →
evento.php Arquivo responsável por eventos da aplicação, ele possuirá códigos para→
cadastrar(INSERT), editar(UPDATE), deletar(DELETE).
Observe uma figura representando o CRUD a ser criado e a relação entre seus arquivos:
Observe que a conexao.php é incluído nos três
arquivos, index.php envia informação para editar.php ou
evento.php, editar.php envia informação para evento.php
ou pode voltar para index.php, evento.php pode voltar
para index.php após executar algum comando.
Vamos agora criar os arquivos e seus códigosfonte.

PHP e MySQL 139
1º Criação do arquivo conexao.php, deverá conter os códigos conforme abaixo:
Podemos observar o comando
mysql_close() no final do arquivo,
onde sua funcionalidade é fechar a
conexão. Além disso podemos
observar cada parâmetro sendo
guardado em uma variável para
facilitar a organização do código
fonte. Esse arquivo é criado e
depois incluído nos demais
arquivos. Isso otimiza o código
uma vez que não precisamos usálo
de forma repetitiva toda vez que
precisarmos de uma conexão.
2° Trabalharemos agora com o arquivo index.php, o primeiro passo é criarmos um formulário
para envio de informação:
O método usado é o
post, o arquivo que
receberá as informações é
o evento.php, porém além
disso e passado uma
variável do tipo GET
chamada cadastro=true, para identificarmos mais adiante qual a ação desejada.
O segundo passo é criarmos o código de listagem no mesmo arquivo, onde através dele podemos
visualizar as informações existente no bando de dados:
Dentro do while montamos
uma tabela com os valores
obtidos do bando de dados.
Criamos também um link
para deletar e outro para editar.
Tanto o formulário quanto o
código de listagem, devem estar
no mesmo arquivo.
Para melhor compreensão observe o link de forma detalhada conforme abaixo. Deletar:
Envia para o arquivo evento a variável do tipo GET com o id obtido no loop, ou seja, cada linha
possui um link para excluir, ele envia a variável deletar = “numero do id obtido”.
O link editar é muito parecido com o deletar, porém as informações são mandadas para o arquivo
editar juntamente com uma variável GET chamada editar, que recebe também o id referente a linha
Comando SQL.
Incluí a conexão

PHP e MySQL 140
que foi montada.
3° Criaremos agora o arquivo editar.php conforme o código abaixo:
O primeiro passo é criarmos o código que vai retornar um array com os valores dos campos do
database, porém existe uma condição usada no comando SQL. A consulta deve retornar o resultado
quando o id passado via GET pela variável “?editar” for igual ao id existente na tabela. Observe o
códigofonte responsável por essa consulta:
Depois temos que criar um formulário parecido ao de cadastro, mudando os valores do action, e
adicionando tag's PHP para preencher os valores de cada referencia, embaixo adicionamos um link
para voltar ao inicio:
Observe que o action do formulário envia as informações para o arquivo evento.php com uma
variável GET editar= “id_passado pela consulta”, dessa forma podemos fazer todos os tratamento
no arquivo responsável pelo evento.
4º E por ultimo criaremos um arquivo responsável por todas as ações do aplicativo. Todo código
abaixo pertence ao arquivo evento.php:
O primeiro passo é incluirmos a conexão:
Criaremos primeiro o código responsável pelo cadastro (INSERT).
Cada evento é diferenciado pelo IF através do comando isset, que verifica se determinada variável
existe ou não. Dessa forma, todas as requisições passada para o arquivo evento.php são
diferenciadas.
Código responsável por editar(UPDATE) valores no banco de dados.
Outro detalhe é a forma de concatenação da string passada para a variável $sql, pois valores que
não são numéricos tem que ser gravados em “ ' ” aspas simples, usamos a aspras dupla para separar
Comando SQL compara id gravado no banco
com o id parrado via método GET.
Aqui criamos um array com os valores
referente ao id passado.
Comando SQL responsável por
Inserir valores na tabela.

PHP e MySQL 141
a os blocos string ex: “bloco_string ' ”.$variavel.“ ' bloco_string”. Veja que a $variavel esta dentro
das aspas simples: ' …. ' .
Código responsável por deletar(DELETE) valores no banco de dados.
Assim encerramos o arquivo evento.php com um link “Voltar” no final.
Podese notar que, cada bloco de código é muito semelhante, mudando apenas o comando SQL e
a verificação isset dentro do IF. Caso determinada variável GET exista, o IF a ser executado é aquele
que tem ligação com evento passado.
Veja o resultados de algumas telas:
1°)Como podemos criar uma conexão entre a tecnologia PHP e MYSQL.
2°)Escreva uma sequencia de comandos PHP que possa ter a seguinte finalidade:
1conectar como o servidor localhost, onde o login é usuários e a senha é 1526.
2Selecionar a base de dados chamada “dados_site”.
3Executar um comando SQL para visualizar todos os dados. Dica: crie uma string com o
comando SQL, após passe a variável como parâmetro para a função mysql_query().
5imprimir todo o conteúdo do banco com o comando print_r.
3°)Em linguagem de programação, como podemos definir a termo CRUD.

PHP e MySQL 142

Joomla 1.5 145
Capítulo 15. História do Joomla
15.1. Introdução
O nome Joomla! tem origem da palavra, em Swahili, “Jumla” que significa “todos juntos”.
Joomla! (pronunciase djumla) é um CMS (Content Management System) desenvolvido a partir do
Mambo. É escrito em PHP e roda no servidor web Apache ou IIS e banco de dados MySQL.
Tratase do resultado da separação entre a equipe de desenvolvedores do Mambo e a empresa
Miro, detentora dos direitos sobre o Mambo. A separação ocorreu porque a empresa Miro transferiu
o controle do Mambo para uma fundação a Mambo Foundation onde os desenvolvedores teriam
apenas uma participação passiva e pouco representativa. Os desenvolvedores, preocupados com a
integridade do projeto e com o futuro dos utilizadores, não aceitaram e criaram o Joomla 1.0,
também open source a partir do código fonte do Mambo 4.5.2.
Hoje, mesmo com pouco mais de um ano desde a primeira versão, o Joomla! é o CMS em maior
expansão, sendo provavelmente o CMS mais procurado, com a maior comunidade e recursos
disponíveis. A grande vantagem do Joomla é sua diversidade de extensões extras, feitas não
necessariamente pelos desenvolvedores do projeto. Componentes, módulos e plugins são
atualizados constantemente e possuem grande valia para profissionais de web interessados em um
site bem feito.
O Joomla é um projeto de código aberto (licença GNU/GPL) e a sua última versão estável é a
1.5.XX. No entanto a programação da nova versão 1.6 já se encontra em andamento. Instalar o
Joomla é relativamente simples e requer apenas conhecimentos básicos de informática, sem a
necessidade de conhecer nenhuma linguagem de programação. Com um servidor de internet e uma
base de dados, é possível obter um site completo, sem erros e seguro.
Joomla Open Source
Exemplo de um software proprietário e um open source
15.2. Vantagens de utilizar o Joomla!
Dentre os vários CMS disponíveis na web, o Joomla, criado em 2005, está se tornando um dos
mais populares, com uma comunidade atuante e crescente. Está fora do escopo deste artigo

Joomla 1.5 146
apresentar argumentos para adoção do Joomla!, mas podemos enumerar alguns muito importantes:
 Joomla! é decididamente software livre e não há perspectiva de mudança com relação a isso
(isto é, vai continuar disponível gratuitamente);
 Já existem vários módulos e componentes disponíveis, criados a partir da base herdada do
Mambo;
 A popularidade do Joomla! está crescendo rapidamente, logo, a sua comunidade também;
 A equipe por trás do Joomla!, composta por membros chave criadores do Mambo, está
fortemente comprometida com o projeto e está disposta a modernizar o software
continuamente;
 É um dos CMS com mais recursos disponíveis e de fácil utilização;
 Foi escrito com PHP e MySql, dois dos softwares open source mais populares da Internet.
O Joomla é uma ferramenta de CMS muito poderosa, prova disto é o prêmio recebido, o Linux
Awards, além de possuir uma comunidade ativa, que está sempre buscando inovações.
15.3. O Joomla tem como principais características:
 Codigo aberto (Licença GPL);
 Sistema simples de fluxo de aprovação;
 Arquivamento para conteúdo não utilizados (Lixeira);
 Gerenciamento de banners;
 Sistema de publicação para o conteúdo;
 Sumário de conteúdo no formato RSS;
 Busca otimizada (qualquer palavra registrada);
 Frontend já traduzido em várias línguas;
 Fácil instalação para novos templates, módulos e componentes;
 Hierarquia para grupos de usuários;
 Estatísticas básicas de visitantes (existem módulos mais complexos que podem ser
adicionados);
 Editor de conteúdo WYSIWYG;
 Sistema de enquete simples (com acompanhamento de resultado em tempo real);
 Sistemas de índices de avaliação;
 Extensões livres em diversos sites (Módulos, Componentes, Templates, Traduções).
15.4. Ferramentas CMS – Sistema de Gerenciamento de Conteúdo
As ferramentas CMS (Content Management System) são sistemas gerenciadores de
conteúdo que auxiliam no processo de desenvolvimento de portais web, assim como no
processo de gerenciamento do conteúdo mantido nesses portais.
Podemos dizer que um CMS é um framework, “um esqueleto” de website préprogramado,
com recursos básicos e de manutenção e administração já prontamente disponíveis. É um
sistema que permite a criação, armazenamento e administração de conteúdos de forma
dinâmica, através de uma interface de utilizador via Internet.

Joomla 1.5 147
Um CMS permite que a empresa tenha total autonomia sobre o conteúdo e evolução da sua
presença na internet e dispense a assistência de terceiros ou empresas especializadas para
manutenções de rotina. Nem mesmo é preciso um funcionário dedicado (webmaster), pois
cada membro da equipe poderá gerir o seu próprio conteúdo, diminuindo os custos com
recursos humanos. A habilidade necessária para trabalhar com um sistema de gestão de
conteúdo não vai muito além dos conhecimentos necessários para um editor de texto.
A aparência de um website criado com um CMS é customizável, através da utilização de
templates que podem ser facilmente substituídos.
Em suma, o grande diferencial de um CMS é permitir que o conteúdo de um website possa
ser modificado de forma rápida e segura de qualquer computador conectado à Internet. Um
sistema de gestão de conteúdo reduz custos e ajuda a suplantar barreiras potenciais à
comunicação web reduzindo o custo da criação, contribuição e manutenção de conteúdo.
Um grande exemplo de CMS é o Wordpress, um sistema em PHP, Open Source e de
altíssima qualidade para gerir blogs ou portais cada vez mais completos.
O Wordpress é um CMS totalmente customizável por themes (ou templates).
Outro grande
exemplo de CMS é o
Joomla!, onde é
facilmente realizada a
edição de conteúdos,
a partir do próprio
site, podendo também
ser usado para o
gerenciamentos de
intranet.
Capítulo 16. Instalação do Joomla
Para instalar o Joomla no seu micro, antes deverá ser instalado um servidor Web
(preferencialmente o servidor web Apache), um interpretador PHP e o banco de dados
MYSQL, que pode ser feito automaticamente utilizando o XAMPP.

Joomla 1.5 148
16.1. Iniciando os Servidores
16.1.1. Passos para instalação do Joomla
16.1.2. Copiando o Joomla para a Pasta HTDOCS
Para criar o site chamado "meusite", basta criar a pasta de nome "meusite", abaixo da pasta
htdocs ("C:xampphtdocsmeusite") e colocar todos os seus arquivos do site nesta pasta.
Você poderá criar quantos sites quiser com o nome que desejar, bastando criar várias pastas,
uma para cada site. Para acessar seu site, simplesmente acesse no navegador
http://localhost/meusite.
Feito isso, precisamos agora entrar no MSQL para criarmos um “BANCO” para instalação do
Joomla. Crie um banco com o nome “joomla”

Joomla 1.5 149
Capítulo 17. Vamos a Instalação
Neste capítulo veremos agora passo a passo toda a instalação do Joomla.
Baixe a versão mais nova do Joomla! em http://www.joomla.org. Extraia o arquivo na
pasta raíz do seu servidor web. Assumindo que a instalação está sendo feita na própria
máquina do usuário, digite no browser o endereço http://localhost/. No caso de uma
instalação feita num servidor remoto digite o endereço do seu domínio (por exemplo:
http://www.seudominio.xxx).
Ao acessar o endereço acima, o instalador é automaticamente iniciado. A imagem abaixo
ilustra a tela do Passo 1.
17.1. 1º Passo Idiomas
No seu navegador acesse http://localhost/joomla (ou outro nome que você deu a pasta no
diretório htdocs)
Deverá aparecer a seguinte tela no seu navegador:

Joomla 1.5 150
Após escolher o idioma de instalação clique no botão “Próximo”, disponível no canto
superior direito. No Passo seguinte, o Joomla! verifica as configurações do servidor e do
PHP.
É altamente recomendável que todas as configurações sejam compatíveis com o Joomla!
Para assegurar um perfeito funcionamento e garantir a segurança.
17.2. 2º Passo – PréInstalação
Esta tela é de verificação de PréInstalação do Joomla, verifique se está tudo Ok conforme
imagem abaixo e clique em próximo novamente.
17.3. 3º Passo Licença
Mostra a tela de Licença GNU / GPL

Joomla 1.5 151
O Joomla! é distribuído sob a licença GNU/GPL que está disponível para leitura no
momento da instalação. Para ler uma versão em português da licença acesse o site:
(http://creativecommons.org/licenses/GPL/2.0/legalcode.pt). Concordando com a licença
continue a instalação clicando no botão “Próximo”. O próximo Passo da instalação é a
configuração do Banco de Dados. O Joomla! 1.5 oferece suporte a mais de uma opção de
banco de dados: MySQL e o MySQLi. Será usado o MySQL nesta instalação, por ser o banco
de dados mais popular na Internet.
17.4. 4º Passo – Banco de Dados
As seguintes informações devem ser preenchidas neste passo da instalação:
Nome do Servidor – quando o banco de dados encontra se no mesmo servidor que o●
Joomla! o nome do servidor é localhost.
Nome de Usuário – no caso de uma instalação local use o usuário root que é o padrão de●
toda instalação do MySQL, no caso de uma instalação num servidor remoto utilize o
usuário que foi informado pelo administrador.
Senha – esta é a senha do usuário do banco de dados. Numa instalação padrão do●
MySQL, a senha do usuário em branco não está definida, por tanto deixe esse campo em
branco. No caso de uma instalação num servidor remoto utilize a senha que foi informada
pelo administrador.
Nome do Banco de Dados – escolha o nome do banco de dados que o Joomla! Irá criar●
ou então utilize o nome do banco de dados que foi fornecido pelo administrador do
servidor. Por exemplo: joomla.
Conforme figura abaixo:
Ainda no Passo 4, algumas configurações avançadas podem ser feitas:
Excluir Tabelas Existentes – caso uma base de dados já existente seja reutilizada, o●
Joomla! oferece a opção de excluir as tabelas existentes nela.
Backup das Tabelas Antigas – na reutilização de uma base de dados, o Joomla! Pode●
realizar o backup dos dados já existentes antes de criar suas tabelas.
Prefixo da Tabela – importante para diferenciar as tabelas do Joomla! de outras, caso●
coexistam na mesma base de dados. Por padrão será usado o prefixo predefinido “jos_”.
Note que as Configurações Avançadas são opcionais, sendo que não é necessário alterar

Joomla 1.5 152
seus valores padrões no caso de uma instalação básica.
17.5. 5º Passo – Configuração do FTP
Esta opção somente deve ser configurada caso sua instalação seja feita em um servidor
remoto, ou seja, na Internet.
Deixe tudo em branco e Clique no botão “Próximo” para continuar.
17.6. 6º Passo Configuração
O passo seguinte é a Configuração Principal do Joomla!.
Os quatro campos seguintes devem ser preenchidos:
Nome do site – Exemplo:“”●
Seu email – coloque neste campo o seu email para receber informações do sistema. Caso●
sua senha seja recuperada, ela será enviada para o email aqui preenchido, portanto,
coloque um email válido.
Senha do admin – insira a senha de sua preferência para o usuário administrador do site.●
Confirme a senha do admin – repita a senha inserida no campo anterior.●
Clique no botão “Próximo” para ir ao último passo da instalação.

Joomla 1.5 153
17.7. 7º Passo Fim
O Passo 7 somente exibe uma tela de confirmação de instalação do Joomla! e um aviso para
remover o diretório /installation. Este diretório deve ser deletado, somente após sua
exclusão que é possível acessar o novo site.
No canto superior direito são exibidos dois botões:
Site – ao clicar nele sistema redireciona para a página principal do site. Conforme ilustra●
a imagem abaixo.

Joomla 1.5 154
Admin – ao clicar nele o sistema redireciona para a página de login da interface de●
administração. Conforme ilustra a imagem abaixo.
Pronto, o Joomla está instalado e funcionando, a única coisa a fazer agora é:
Para acessar o seu site, http://localhost/nomedapasta e, para acessar o Painel de
Administração,
http://localhost/nomedapasta/administrator/
Capítulo 18. Frontend e Backend
Quando instalamos o Joomla em um servidor web, automaticamente são instaladas duas
áreas: Área de usuários (Frontend) e Área de administração (Backend), que correspondem
respectivamente, ao site principal e um site de administração do site principal.
18.1. Frontend – Área de Usuários
O Frontend é um site normal na web, com a diferença que podemos alterar partes de seu
conteúdo diretamente no site.
Este, como qualquer site web, está acessível para todos os usuários.
1. Podese criar um template (Design) próprio para apresentação das informações;
2. Utilizar um template gratuito disponível pela comunidade Joomla;
3. Adequar um site para ter seu conteúdo mantido com os recursos do Joomla.

Joomla 1.5 155
18.2. Backend – Área de Administradores
Este é um site que permite a administração do site principal em relação ao seu conteúdo.
É nesta área onde informamos as partes que irão aparecer no site principal (Módulos,
componentes, etc.), como por exemplo, menu de opções, notícias, áreas de registros, links,
download de arquivos, etc.
Basicamente a área de administração abre exibindo o Painel de Controle e um menu
superior.
Os itens a serem exibidos no menu e no painel de controle dependerão de como está
definido o seu nível de usuário para área de administração.
18.2.1. Login de Acesso
Para acessar a área de administração, devemos fazer o login na mesma, digitando no
navegador o endereço do site, incluindo no final a palavra administrator.
Ex.: http://localhost/seusite/administrator

Joomla 1.5 156
18.2.2. Nível de usuário – Papel
Cada usuário que acessa o site principal ou de administração possui um papel. Dependendo
deste papel, o usuário poderá fazer mais ou menos ações/atividades, tanto no site quanto
na área de administração.
18.2.3. Papéis no Site principal (Frontend)
 Anonymous  Registered  Autor  Editor  Publisher.
Obs.: Os usuários do frontend não possuem acesso ao backend.
18.2.4. Papeis na Área de administração (BackEnd)
 Manager  Administrator  Super Administrator.
Obs.: Todos os usuário do BackEnd possuem acesso total também ao frontend.
Capítulo 19. Conhecendo a Área de Administração
O Joomla, por ser um sistema de gerenciamento de conteúdo genérico, precisa utilizar um forma
de organizar o conteúdo do site que se adapte a diversas estruturas e situações. Em seguida, iremos
descrever os principais tipos de conteúdo suportados pelo Joomla, e a organização de cada um
deles.
19.1. Acessos
Para organizar o acesso às seções do site, e para as permissões de publicação de conteúdo, o
Joomla utiliza diversas categorias de usuários. A primeira divisão é entre usuários registrados e não
registrados. Os usuários registrados se dividem em diversas categorias, com diversos graus de
acesso às funções do Joomla.
19.2. Registrando os usuários
Os administradores são responsáveis pelo registro de usuários, mas você pode permitir que

Joomla 1.5 157
visitantes do site façam seus registros. Esta possibilidade é interessante no caso do site ter
um informativo que é enviado para o seu público, ou em casos semelhantes. O usuário pode
registrarse clicando em “Cadastrese!”, que fica logo abaixo dos campos de login para os
usuários já registrados.
O visitante que se registra desta forma fica com o status de Usuário Registrado (veja a
definição das categorias de usuários do Joomla logo abaixo). Caso você não queira que
visitantes possam se registrar no site, acesse a Interface de Administração e, na seção
Global Configuration, aba Site, marque Não no item Allow User Registration. Assim, o link
Cadastrese será removido de seu porta.
19.3. Categorias de Usuários Registrados
Os usuários registrados dividemse em duas categorias principais: os que irão trabalhar
principalmente com o conteúdo do site, que realizam suas tarefas, através da interface do
Portal, após terem se logado; e os que irão trabalhar na administração do site, utilizando a
Interface de Administração, acessível pela pasta/administrator.
19.4. Usuários Responsáveis pelo Conteúdo
As categorias listadas estão organizadas pelo grau de acesso às funções do Joomla.
19.4.1. Usuário Registrado.
Não pode inserir conteúdo no site, mas possui acesso, como leitor, às seções reservadas para
usuários cadastrados.
19.4.2. Autor.
Pode inserir conteúdo no site (textos, imagens, etc.) Este conteúdo, porém, não é publicado
imediatamente no site. Ele precisa ser revisado e ter a sua publicação autorizada por um
usuário que seja Publicador (Publisher), ou por quaisquer usuários das categorias de
Administração (Gerenciador, Administrador, SuperAdministrador).
Após a publicação, o autor pode modificar os textos de sua autoria. Não pode, entretanto,
modificar o conteúdo criado por outros usuários.
19.4.3. Editor.
Além de inserir conteúdo, da mesma forma que o Autor, também pode alterar qualquer
item do site, mesmo que não tenha sido criado por ele. Por exemplo, esta deve ser a
categoria das pessoas responsáveis pela revisão dos textos de um site. É importante colocar
que o Editor não pode autorizar a publicação de conteúdos enviados pelos usuários
cadastrados como Autores ou Editores; ele pode apenas alterar textos cuja publicação já
tenha sido realizada pelos Publicadores ou pelos usuários das categorias de Administração.
19.4.4. Publicador (publisher)
Pode autorizar a publicação de material enviado pelos Autores ou Editores, e também pode
alterar qualquer item do site.

Joomla 1.5 158
19.5. Usuários de Administração.
Esses usuários realizam as tarefas de administração através da Interface de Administração,
acessível no endereço url do site/administrator. Entre as suas atividades, estão: o
cadastramento de usuários, criação das seções do site e instalação de módulos e
componentes, bem como a escolha do template (que define o visual do site) e do idioma do
site.
19.5.1. Super Administrador
Tem acesso a todas as funções de administração do site. Pode criar e deletar outros
usuários, inclusive os Administradores e Gerenciadores.
19.5.2. Administrador
Em relação ao Super Administração, as restrições dos Administradores são:
1.Alterar as informações do Super Administrador (senha, email)
2.Acessar as configurações globais (Global Configuration) da Interface de
Administração. Nestas configurações, estão a senha para o acesso ao banco de
dados, e a definição do idioma default do portal.
3.Permissão para enviar email aos usuários registrados no site;
4.Escolha do template para o site.
Os responsáveis pelo cadastramento de usuários devem ser registrados como
Administradores. No caso de projetos educacionais, os professores ou quem for responsável
pelo cadastramento de alunos, deve estar cadastrado como Administrador.
19.5.3. Gerenciador (Manager)
Utilizado por aqueles que precisam gerenciar o conteúdo do site, mas que não precisam ter
acesso às funções de criação e gerenciamento de usuários. Os Gerenciadores apresentam as
seguintes restrições, em relação aos Administradores:
• Gerenciar usuários;
• Instalar módulos e componentes;
• Restrições de acesso a alguns componentes.
Capítulo 20. Gerenciando as Categorias e Seções
Para editar um texto do site, você terá que identificar o que é o texto que você quer editar,
ou seja, se ele é um item, ou a descrição de uma categoria ou de uma seção. Apenas itens
podem ser editadas dentro do próprio site; descrições de categorias e de seções só podem
ser editadas no Painel de Administração.
• Primeiro você deve criar uma seção para o determinado conteúdo;
• Segundo você cria a categoria da seção.
Exemplo: Seção: Notícia / Categoria: Ultimas Notícias

Joomla 1.5 159
20.1. Como criar uma Seção
Para criar uma seção de conteúdo no Joomla, siga os seguintes passos:
• Loguese no Painel de Administração;
• Clique em Conteúdo > Administra Seção.
• Após abrir a opções acima, você verá a lista de seções atualmente existente no seu
site, clica no botão Novo, no menu de ícones, no canto superior direito.
• Agora, preencha o formulário escolhendo o título e a descrição da Seção. A descrição
poderá ou não ser exibida (isto poderá ser configurado no item de menu que leva à
categoria)
• Quando estiver ponto, clique em Salvar.

Joomla 1.5 160
20.2. Como criar uma categoria
1.Loguese no Painel de Administração;
2.Clique em Conteúdo > Administra Categoria.
3.Siga todos os passos da seção, lembrando agora que temos que setar a seção.
Observação: veja que vai aparecer um campo para você especificar a seção que foi criada
anteriormente.
Capítulo 21. Inserindo um Novo Texto
Se o seu site utilizar o modo Tabelas (e não Blogs) para exibir o conteúdo, você poderá
inserir novos textos pelo próprio site, sem precisar acessar o Painel de Administração. Caso
o seu site utilize Blogs, você deverá se logar no Painel de Administração, e seguir as
instruções abaixo, reparando nas observações.
21.1. Para inserir um texto, siga os seguintes passos:
 Realize o login (por hábito, o formulário para digitação de nome de usuário e senha
sempre está presente na capa do site, e fica, em geral, no canto superior esquerdo ou
nas laterais) no site ou no Painel de Administração;
 Após realizar o login, Clique em Conteúdo – Administrar Artigos
 Preencha o formulário para inserção de novo texto. Os campos principais são:
• Título;

Joomla 1.5 161
• Seção e Categoria: escolha a seção onde o texto deve ficar;
• Texto principal: aqui, coloque o conteúdo do texto.
 Após terminar toda a configuração, pode salválo.
Capítulo 22. Como criar um link no menu para um
item de conteúdo
Para criar um link num menu para um item de conteúdo (um texto) no seu site, você deve
primeiro decidir em que menu será criado o link. O Joomla permite ao seu site ter vários
menus, sendo que alguns podem ser exibidos em apenas algumas páginas, e outros podem
estar presentes em todas as páginas (as páginas em que um menu está ou não presente
podem ser configuradas).
22.1. Criando um link para o item de conteúdo
Sabendo em que menu deseja incluir o link, os procedimentos são os que seguem. Para este
exemplo, vamos incluir um link no menu principal de um site criado com o Joomla.
 Loguese no Painel de Administração;
 No menu Menu, escolha o menu onde deseja
incluir o link. No nosso caso, é o mainmenu.

Joomla 1.5 162
 Será exibida uma lista com os links atualmente existentes no menu;
 Clique no ícone Novo, no menu de
ícones no canto superior direito;
 Agora, é preciso escolher o tipo de
link que estamos criando. Escolha
Link – Conteúdo do Item.
 No formulário a seguir, escolha o
nome do link (este nome é o texto
que será exibido no menu) e o
item de conteúdo para o qual
estamos criando o link;
 Neste formulário, você também
pode definir o nível do link. O
Joomla permite que você crie links
que sejam 'filhos' de outros links,
que só são exibidos quando o link
pai é selecionado. No nosso caso,
não queremos criar um submenu;
por isso, deixamos o Parent Item
padrão, Top.
 Clique em Salvar quando estiver
concluído.

Joomla 1.5 163
22.2. Administração dos menus
É importante observar que, normalmente um site desenvolvido com o Joomla possui
diversos menus, bem como outros instrumentos de navegação.
Para podermos fazer as alterações nos menus, devemos entrar na opção “Itens de Menu”,
logo após aparecerá outra tela com as opções de publicação e ordem dos menus.
22.2.1. Tela de configuração de menus
Nessa tela encontramos os seguinte itens:
1. Item de menu: O nome do menu e suas especificações;
2. Publicado: Se o menu será publicado ou não na página;
3. Reordenar: Com as cetas para cima e para baixo, podemos ordenar a posição do
menu;
4. Ordem salvar: Podemos colocar a numeração de ordem manual e salvar;
5. Acesso: Definição de acessos públicos ou privados;
6. Item ID: Número de identificação do menu;
7. Tipo:Tipo de link em que o menu foi adicionado;
8. CID: Número identificador do conteúdo.

Joomla 1.5 164
22.3. Especificação de Alguns Itens de Menu
22.3.1. Conteúdo
1. Blog Arquivo de Conteúdo da Categoria: Exibe uma lista de artigos arquivados
numa categoria específica;
2. Blog Arquivo de Conteúdo da Seção: Exibe uma lista de artigos arquivados numa
seção específica;
3. Blog Categoria de Conteúdo: Exibe uma página de itens de conteúdo de múltiplas
categorias em formato de BLOG;
4. Blog Seção de Conteúdo: Exibe uma página de itens de conteúdo de múltiplas
seções em formato de BLOG;
5. Enviar – Conteúdo: Cria um botão enviar para os usuários enviarem conteúdos;
6. Link Conteúdo Estático: Cria um link a um item de conteúdo estatístico;
7. Link Item de Conteúdo: Cria um link do item de conteúdo estatístico publicado
com visualização completa;
8. Tabela Categoria de Conteúdo: Exibe uma tabela com os artigos de uma categoria
específica;
9. Tabela Conteúdo de Seção: Cria uma listagem de categoria de conteúdo de uma
seção específica.
22.3.2. Miscellaneous
1. Separador / Espaço em branco: Cria espaço em branco ou separador do menu;
2. Wrapper: Cria um iframe com uma  página  de site dentro do Joomla;
3. Enviarconteúdo: Cria um botão enviar para os usuários enviarem conteúdos.
22.3.3. Componentes
• Componente: Exibe a interface do site público para um componente;
• Link Item de Componente: Cria um link a um componente existente no Joomla;
• Link Item de Contato: Cria um link a um item de contato publicado;
• Link Notícias Externas: Cria um link a uma única notícia externa publicada;
• Tabela Categoria de Contato: Exibe uma tabela com os itens de contato;
• Tabela Categoria de Notícias Externas: Exibe uma tabela com os itens de notícias
externas de uma categoria específica;
• Tabela Categoria de Weblink: Exibe uma tabela com os itens de weblink de uma
categoria de weblink específica.
22.3.4. Links
• Link Conteúdo Estático: Cria um link para um item de conteúdo estatístico;
• Link Item de Componente: Cria um link para um componente existente no Joomla;
• Link Item de Contato: Cria um link para um item de contato publicado;
• Link Item de Conteúdo: Cria um link do item de conteúdo estatístico publicado com
visualização completa;
• Link Notícias Externas: Cria um link para uma única notícia externa publicada;
• Link – Url: Cria um link para uma URL (endereço na web).
Capítulo 23. Administração de Mídia
Essa área do painel é específica para administração de arquivos e imagens, sua
configuração está apontada para pasta “IMAGES” da estrutura do site. Nela, podemos

Joomla 1.5 165
baixar arquivos e imagens fazendo upload do nosso próprio PC.
23.1. Observando a imagem acima, teremos os seguintes tópicos:
23.1.1. Primeiro tópico
1. Enviar;
2. Criar;
3. Cancelar;
4. Ajuda.
23.1.2. Segundo tópico
• Criar Diretório: Local onde é definido o nome da pasta ou diretório que será criado.
23.1.3. Terceiro tópico
1. Imagem / Url Código: É exibido o caminho do arquivo ou imagem quando
selecionado.
23.1.4. Quarto tópico
1. Diretório: Você seleciona o nível do diretório.
23.1.5. Quinto tópico
1. Procurar: Local utilizado para localizar o arquivo que será feito o upload.
23.1.6. Sexto tópico
1. Pastas e Arquivos: Área onde é exibido todo conteúdo que está armazenado.
Capítulo 24. Conhecendo alguns componentes
O conceito de componentes do Joomla! talvez seja uma das grandes vantagens em relação à
maioria dos CMS disponíveis. O componente é uma forma de gerenciar conteúdos ou
agregar funcionalidades muito específicas que não seria possível com as funções padrões do
Joomla!
24.1. Componente Weblinks
O componente Web Links permite gerenciar a área de links do site. O Joomla oferece a
possibilidade de se criar, facilmente, uma seção de links para o seu site. Esses links podem
ser agrupados em categorias, de forma que você pode separálos por assunto. Por exemplo,
o site de uma escola poderia ter como categorias de links: Materiais para Professores, Sites
para Adolescentes, Sites para os Pais, etc.

Joomla 1.5 166
• Primeiro, criamse as categorias.
• Segundo, criamse os itens.
1. Administramse os itens.
24.2. Componente Contatos
Os contatos são utilizados para a implementação da seção Fale Conosco/Contato, presente
nos sites atuais. Você pode criar diversos contatos (dependendo do interesse do usuário,
você pode querer encaminhálo para um contato diferente), que são agrupados em
categorias. Ao criar um item de menu que leve à seção Contatos, você poderá escolher se
quer exibir um contato específico, ou a lista de contatos disponíveis.
Para começarmos a trabalhar com os contatos, precisamos estabelecer primeiro a categoria
dos contatos que serão cadastrados.

Joomla 1.5 167
Após ter criado a categoria, prosseguese para a criação dos contatos na opção “Administrar
contatos”.
Cada contato pode ter informações como endereço e telefone, e também oferecer um
formulário, para que o usuário envie mensagens através do site. Estas mensagens são
enviadas para o email do contato.
Também é possível configurar as informações de contato que serão exibidas. Por exemplo, a
página de contato pode exibir um telefone de contato, ou endereço de correspondência,
além do formulário de envio de mensagens eletrônicas.
Preencha os campos do formulário que será apresentado. Em Parâmetros, você poderá
escolher que informações do contato serão exibidas ao visitante de seu site.

Joomla 1.5 168
Na página com a lista de contatos, você poderá criar outros contatos. Isso permitirá que o
visitante do seu site escolha para onde a mensagem será enviada.
24.3. Componente Banner
É possível criar diversos avisos/banners, e pedir ao sistema que sorteie um dos avisos/
banners disponíveis, exibindoo no site. Um novo item é sorteada cada vez que a página é
carregada.
Para publicação dos banners, seguese os mesmos passos dos outros componentes já vistos,
criandose primeiro sua categoria e depois o próprio banner que será administrado.

Joomla 1.5 169
Capítulo 25. Módulos e Componentes
Um módulo é uma extensão pequena e flexível usada para compor uma página. Os módulos
são usados em pequenas áreas da página e podem ser associados a diversos componentes.
Alguns exemplos são os menus, o formulário de login, visitantes online e outros tantos que
são instalados por padrão junto com o Joomla.
Observação: Vale observar que na tabela acima existe um campo chamado “TIPO”, esse
campo mostra o tipo de arquivo que é usado. O nome do módulo é fictício somente para
efeito de visualização, seu nome real é indicado pelo tipo.

Joomla 1.5 170
25.1. Criando um módulo utilizando o próprio Joomla
Podemos criar um módulo utilizando as próprias ferramentas do Joomla, neste caso, abrimos o
administrador de módulo e utilizamos a opção “NOVO” no menu.
25.1.1. Veja os pontos necessários para criação de um módulo:
• Definição de um título para o módulo;
• Escolha se quer que ele seja exibido ou não no frontpage;
• Em qual posição ele será exibido no frontpage;
• Ordem em que ele ficará ajustado aos outros módulos;
• Definição do nível de acesso, a quem ele será exibido;
• Se vai estar publicado ou não;

Joomla 1.5 171
• Utilização de um css personalizado no módulo;
• Utilização dos plugins existentes na instalação do Joomla;
• Escolha das páginas em que ele será exibido;
• Criação do conteúdo.
25.2. Instalação de Módulos
Existem vários módulos já prontos que podem ser encontrados na internet, módulos com
diversas finalidades como: galerias de fotos, newslatter, login etc.
25.2.1. Passos para instalar um novo módulo:
• Menu do Painel de Administração > instaladores > módulos;
• Procurar o arquivo “mod_nomedomodulo”;
• Enviar e instalar
25.3. Componentes
O conceito de componentes do Joomla! talvez seja uma das grandes vantagens em relação à
maioria dos CMS disponíveis. O componente é uma forma de gerenciar conteúdos ou agregar
funcionalidades muito específicas que não seria possível com as funções padrões do Joomla!
Por exemplo: O componente Web Links permite gerenciar a área de links do site. O componente
Banners permite gerenciar banners, rotacionando aleatoriamente e contando o número de cliques.
Existem centenas (ou milhares) de componentes como galerias de fotos (RSGallery2, zOOm
Gallery), sistemas de tradução (JoomFISH), gerenciadores de formulários, etc. Grande parte dos
componentes são gratuitos (GNU GPL), porém alguns possuem licença comercial (que geralmente
são de baixo custo).
Caso não exista um componente adequado à necessidade do site, pode ser feita a adaptação de
um componente existente ou podese criar um componente específico.
Obervação: Para instalação dos componentes, seguese os mesmos passos vistos na
instalação dos módulos.

Joomla 1.5 172
Capítulo 26. Estrutura.
O Joomla dividese na seguinte estrutura.
26.1. Designer
Todo o designer está ligado a um CSS colocando os estilos e modelando todo o Template ou
Tema, utilizado tanto na FrontEnd como no BackEnd.
26.2. Programação
Podemos editar toda sua programação utilizando o editor de HTML dentro do BackEnd,
como o próprio arquivo PHP por um editor como Dreamweaver ou um simples bloco de
notas.
26.3. Conteúdo MySQL
Banco de dados mysql, podemos acessálo pelo localhost e editar as tabelas, normalmente o

Joomla 1.5 173
Joomla cria suas tabelas com extensões de prefixo _JOS.
26.4. Posições de Módulos
Todo o tema está estruturado por posições onde cada módulo será apontado. As posições
são feitas no código PHP do arquivo principal do Tema (index.php), e depois classificadas
dentro do Painel de Administração, para que possam ser reconhecidas.
26.4.1. Vejamos exemplo no Código PHP:
26.4.2. Vejamos agora o exemplo no Painel de Administração (BackEnd)
Observação: Sempre que criarmos uma nova posição dentro do código, não podemos
esquecer de também criála no Painel de Administração.
26.5. Estendendo a Estrutura do Template (Tema)
Vejamos alguns códigos do php abaixo para entender melhor a formatação da template.
26.5.1. Você pode usar os seguintes atributos para os módulos:
<?php mosLoadModules('top'); ?>
A leitura desse código seria algo assim: Aparecer os módulos que estão na posição top;
<?php mosLoadModules('top',); ?>
M ó dulo le ft:
N este e xem p lo , cria d o p a ra
c o nte r o m enu late ral esq uerd o .
M ó dulo ba nne r:
N este exe m p lo , c ria d o p a ra
co nte r o b a nner d o site .
P o s iç õ e s le ft e b a n n e r
V e ja a s m e s m a s p o s iç ã o c ria d a
d o P a in e l d e A d m in is tra ç ã o

Joomla 1.5 174
Seria o default, que chama tabelas;
<?php mosLoadModules('top',1); ?>
Serve para voltar só o módulo, sem tag’s a mais;
Serve para voltar como xhtml;
Serve para retornar valores, para se fazer cantos arredondados;
<?php echo $mosConfig_live_site;?>
Serve para imprimir o path (caminho) do site, com isso quando mudar o nosso site para o
servidor, não precisa ficar alterando caminhos;
<?php mosPathWay(); ?>
O pathway faz uma navegação do site, nada demais;
<?php mosMainBody();?>
Local onde será definido todo o conteúdo dinâmico do site;
<?php defined( ‘_VALID_MOS’ ) or die( ‘Direct Access to this location is not allowed.’ ); ?>
Faz com que tenhamos certeza que o arquivo não será acessado diretamente;
<meta httpequiv=”ContentType” content=”text/html; <?php echo _ISO; ?>” />
Que set de caracteres estamos usando, _ISO é uma constante especial que define o set de
caracter em uso(encoding);
<link href="<?php echo $mosConfig_live_site;?>
/templates/rhuk_solarflare_ii/css/template_css.css" rel="stylesheet" type="text/css" />
Esta linha linka o arquivo CSS no template;
<img xsrc="<?php echo $mosConfig_live_site;? /templates/zymic/images/slogan_box.gif"
alt="slogan box" />
Esta linha linka a imagem no template.

Joomla 1.5 175
Veja o modelo abaixo:

Joomla 1.5 176
Abaixo seguem alguns links interessantes para você baixar arquivos para o Joomla.

Joomla e suas versões, Módulos, Componentes, Tutoriais e Vídeo Tutoriais;
Joomla Amazonia
http://www.dicasetutoriais.com/
Joomla Brasil
http://www.joomla.com.br/
Joomla.org
http://www.joomla.org/
Comunidade Portuguesa
www.joomlapt.com

Cid Ferreira Gomes
Governador do Estado do Ceará
Maria Izolda Cela de Arruda Coelho
Secretária da Educação do Estado
Maurício Holanda Maia
Secretário adjunto da Secretaria da Educação do Estado
Professor Cláudio Ricardo Gomes de Lima Msc.
Reitor do Instituto Federal de Educação, Ciência e Tecnologia do Ceará
Professor Edson da Silva Almeida Msc.
Diretor Executivo do CPQT
Andrea Araújo Rocha
Coordenadora Geral do Projeto eJovem – SEDUC
Professor Cícero R. B. Calou Msc.
Gerente de Projetos do CPQT
Coordenador do Projeto eJovem Módulo II IFCECPQT
Júlio César Cavalcante Bezerra
Coordenador do Projeto eJovem Módulo II – SEDUC
Eraldo Ferreira da Silva Filho
Projeto eJovem Módulo II
Edição de Conteúdo
(Joomla)
Alex de Sousa Pulvirenti
Edição de Conteúdo
(Lógica de Programação / PHP & MySQL)
Fabrício Silva Rosal
Revisão de Conteúdo
(Lógica de Programação / PHP & MySQL)
Jucimar de Souza Lima Junior
Formatação Final

Logica Programacao Php Joomla

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Logica Programacao Php Joomla

Logica Programacao Php Joomla