PHP Com Programação Orientada a Objectos by Grupo Lidel

EDIÇÃO FCA – Editora de Informática, Lda. Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 fca@fca.pt www.fca.pt DISTRIBUIÇÃO Lidel – Edições Técnicas, Lda. Rua D. Estefânia, 183, R/C Dto. – 1049-057 Lisboa Tel: +351 213 511 448 lidel@lidel.pt www.lidel.pt LIVRARIA Av. Praia da Vitória, 14 A – 1000-247 Lisboa Tel: +351 213 511 448 * Fax: +351 213 522 684 livraria@lidel.pt Copyright © 2016, FCA – Editora de Informática, Lda. ISBN edição impressa: 978-972-722-837-9 1.ª edição impressa: julho 2016 Impressão e acabamento: Tipografia Lousanense, Lda. – Lousã Depósito Legal n.º 412483/16 Capa: José M. Ferrão – Look-Ahead

Marcas Registadas de FCA – Editora de Informática, Lda. –

Todos os nossos livros passam por um rigoroso controlo de qualidade, no entanto aconselhamos a consulta periódica do nosso site (www.fca.pt) para fazer o download de eventuais correções. Não nos responsabilizamos por desatualizações das hiperligações presentes nesta obra, que foram verificadas à data de publicação da mesma. Os nomes comerciais referenciados neste livro têm patente registada. Reservados todos os direitos. Esta publicação não pode ser reproduzida, nem transmitida, no todo ou em parte, por qualquer processo eletrónico, mecânico, fotocópia, digitalização, gravação, sistema de armazenamento e disponibilização de informação, sítio Web, blogue ou outros, sem prévia autorização escrita da Editora, exceto o permitido pelo CDADC, em termos de cópia privada pela AGECOP – Associação para a Gestão da Cópia Privada, através do pagamento das respetivas taxas.

ÍNDICE GERAL 1. INTRODUÇÃO .................................................................................................. 1 1.1 Breve história do PHP ........................................................................................................................ 1 1.2 Vale a pena aprender PHP? ............................................................................................................... 2 1.3 O que instalar: PHP 5 ou PHP 7? ...................................................................................................... 3 1.4 O servidor Apache ............................................................................................................................... 4 1.5 Arquitetura cliente/servidor ............................................................................................................... 5 1.6 Recursos necessários............................................................................................................................ 6 1.7 Instalação nativa em Mac OS X .......................................................................................................... 7 1.7.1 Instalação do servidor Apache ............................................................................................... 7 1.7.2 Linguagem PHP......................................................................................................................... 8 1.7.3 Servidor MySQL ........................................................................................................................ 9 1.8 Instalação do XAMPP ........................................................................................................................ 9 1.8.1 Instalação em plataformas Windows .................................................................................... 10 1.8.2 Instalação em plataformas Mac OS X .................................................................................. 12 1.8.3 Instalação em plataformas Linux .......................................................................................... 12 1.9 “Regras” de programação ............................................................................................................... 13 1.9.1 Ficheiros, comentários e resultados ...................................................................................... 13 1.9.2 Blocos de código e indentação .............................................................................................. 15 1.9.3 Tipos de dados ......................................................................................................................... 16 1.9.4 Padronização ............................................................................................................................ 17 1.9.5 Erros gerais ............................................................................................................................... 18 Resumo ..................................................................................................................................................... 18 2. CONCEITOS GERAIS ........................................................................................ 19 2.1 Introdução .......................................................................................................................................... 19 2.2 Strings ................................................................................................................................................. 20 2.2.1 Criação e utilização de strings ................................................................................................ 20 2.2.2 Funções para strings ................................................................................................................ 21 2.3 Arrays .................................................................................................................................................. 21 2.3.1 Criação e utilização de arrays ................................................................................................. 21 2.3.2 Funções para arrays ................................................................................................................. 23 2.4 Estruturas de controlo e decisão ...................................................................................................... 24 2.4.1 FOR e WHILE ............................................................................................................................. 24 2.4.2 IF, ELSE e ELSEIF ................................................................................................................. 25 2.4.3 SWITCH/CASE ......................................................................................................................... 26 2.4.4 FOREACH ................................................................................................................................... 28 2.4.5 CONTINUE e BREAK ................................................................................................................. 28 2.5 Variáveis.............................................................................................................................................. 29 2.6 Constantes........................................................................................................................................... 30 2.7 Funções criadas pelo utilizador ....................................................................................................... 30 2.7.1 Criação de função ................................................................................................................... 31 © FCA – Editora de Informática

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

2.8 Ficheiros e pastas .............................................................................................................................. 33 Resumo ..................................................................................................................................................... 35 3. PROGRAMAÇÃO ORIENTADA A OBJETOS ............................................................... 37 3.1 Introdução .......................................................................................................................................... 37 3.2 Conceitos gerais ................................................................................................................................ 38 3.3 Classe ................................................................................................................................................... 40 3.4 Objeto .................................................................................................................................................. 41 3.5 Exemplo da relação classe/objeto ..................................................................................................... 45 3.5.1 Criação da classe ...................................................................................................................... 45 3.5.2 Criação do objeto ..................................................................................................................... 47 3.6 Herança .............................................................................................................................................. 48 3.7 Polimorfismo ..................................................................................................................................... 56 3.8 Abstração ............................................................................................................................................ 59 3.8.1 Classes e métodos abstratos .................................................................................................. 59 3.8.2 Classes e métodos finais ........................................................................................................ 62 3.9 Encapsulamento ................................................................................................................................ 63 3.9.1 PRIVATE ................................................................................................................................... 64 3.9.2 PROTECTED .............................................................................................................................. 66 3.10 Associação, agregação e composição............................................................................................. 67 3.10.1 Associação .............................................................................................................................. 67 3.10.2 Agregação ............................................................................................................................... 68 3.10.3 Composição ............................................................................................................................ 68 Resumo ..................................................................................................................................................... 68 4. DESIGN PATTERNS .......................................................................................... 69 4.1 Introdução ........................................................................................................................................... 69 4.2 Design patterns: o que são? ................................................................................................................ 70 4.3 Utilização de padrões ........................................................................................................................ 74 4.3.1 Padrão “fábrica” ...................................................................................................................... 75 4.3.2 Padrão singleton (instância única) ......................................................................................... 79 Resumo ..................................................................................................................................................... 80 5. AUTOLOAD, ERROS E EXCEÇÕES ......................................................................... 81 5.1 Funções para classes e objetos .......................................................................................................... 81 5.2 Interfaces ............................................................................................................................................. 82 5.3 “Métodos mágicos” ........................................................................................................................... 83 5.3.1 __construct() e __destruct() .................................................................................... 84 5.3.2 __set() ................................................................................................................................... 86 5.3.3 __get() ................................................................................................................................... 88 5.3.4 __call()................................................................................................................................. 88 5.4 __autoload() e spl_autoload_register() ...................................................................... 89 5.4.1 __autoload() ....................................................................................................................... 90 5.4.2 spl_autoload_register() ............................................................................................. 92 5.5 Erros .................................................................................................................................................... 93 5.5.1 Tipos de erros ........................................................................................................................... 94 © FCA – Editora de Informática

ÍNDICE GERAL

VII

5.5.2 Tratamento de erros ............................................................................................................... 95 5.5.2.1 die() ........................................................................................................................... 96 5.5.2.2 Flags .............................................................................................................................. 96 5.5.2.3 trigger_error() e set_error_handler() ................................................ 97 5.6 Exceções .............................................................................................................................................. 98 5.6.1 Criação de uma exceção.......................................................................................................... 98 5.6.2 Ampliar a exceção ................................................................................................................. 100 5.6.3 Exception ou PDOException?........................................................................................ 103 Resumo ................................................................................................................................................... 107 6. XML E MYSQLI ........................................................................................... 109 6.1 Introdução ao XML .......................................................................................................................... 109 6.2 Documento XML .............................................................................................................................. 110 6.3 SimpleXML ....................................................................................................................................... 112 6.3.1 Leitura do ficheiro XML ....................................................................................................... 112 6.3.2 Escrita no ficheiro XML ........................................................................................................ 115 6.4 XMLWriter ....................................................................................................................................... 116 6.5 Bases de dados em PHP ................................................................................................................. 118 6.5.1 Comunicação entre bases de dados e PHP......................................................................... 118 6.5.2 Base de dados clinica ....................................................................................................... 119 6.6 mysqli .............................................................................................................................................. 120 6.6.1 Métodos e funções ................................................................................................................. 121 6.6.2 Classe mysqli ....................................................................................................................... 122 6.6.3 Ligação à base de dados ...................................................................................................... 123 6.7 Consultas na base de dados com mysqli .................................................................................... 125 6.7.1 Seleção de dados .................................................................................................................... 125 6.7.2 Inserção de dados .................................................................................................................. 128 6.7.3 Alteração e eliminação de dados ......................................................................................... 129 6.8 Prepared statements............................................................................................................................ 130 6.8.1 Classe mysqli_stmt ........................................................................................................... 130 6.8.2 Consultas na base de dados com mysqli_stmt .............................................................. 131 6.8.2.1 Seleção de dados ...................................................................................................... 131 6.8.2.2 Inserção de dados ..................................................................................................... 134 6.8.2.3 Alteração e eliminação de dados ............................................................................ 136 Resumo ................................................................................................................................................... 136 7. PHP DATA OBJECTS ..................................................................................... 137 7.1 Introdução ......................................................................................................................................... 137 7.2 Ligação à base de dados .................................................................................................................. 138 7.2.1 Ligação com PDO .................................................................................................................. 140 7.2.2 Erros e ligação com a exceção try/catch ........................................................................ 141 7.2.3 Métodos e funções ................................................................................................................. 143 7.2.4 Métodos bindParam() vs. bindValue() ....................................................................... 144 7.2.5 Método fetch() .................................................................................................................. 148 7.3 Consultas na base de dados ............................................................................................................ 151 7.3.1 Consultas de seleção com query() ................................................................................... 151 © FCA – Editora de Informática

VIII

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

7.3.2 Consultas de seleção com prepared statements .................................................................... 152 7.3.2.1 Método 1: consultas de seleção com placeholder “?” ............................................ 153 7.3.2.2 Método 2: consultas de seleção com parâmetros nomeados ............................... 156 7.3.3 O problema do LIMIT .......................................................................................................... 159 7.3.4 Consultas de inserção ........................................................................................................... 162 7.3.5 Consultas de alteração e eliminação ................................................................................... 164 Resumo ................................................................................................................................................... 167 8. TRANSAÇÕES E STORED PROCEDURES ................................................................ 169 8.1 Transações......................................................................................................................................... 169 8.1.1 Conceito ................................................................................................................................. 170 8.1.2 Métodos e funções ................................................................................................................. 171 8.1.3 Métodos COMMIT e ROLLBACK ........................................................................................... 172 8.1.3.1 Método 1: sem tratamento de erros ....................................................................... 174 8.1.3.2 Método 2: com tratamento de erros ........................................................................ 177 8.1.3.3 Método 3: utilização de funções .............................................................................. 180 8.2 Stored procedures com PDO ............................................................................................................. 183 8.2.1 Preparação do stored procedure ............................................................................................. 184 8.2.2 Utilização do stored procedure ............................................................................................... 184 Resumo ................................................................................................................................................... 187 9. CREATE, READ, UPDATE AND DELETE ................................................................. 189 9.1 Introdução ......................................................................................................................................... 189 9.2 Layout ................................................................................................................................................ 190 9.2.1 Bootstrap: instalação ............................................................................................................... 190 9.2.2 Bootstrap: utilização ............................................................................................................... 191 9.3 Desenvolvimento do sistema CRUD ............................................................................................ 193 9.3.1 Ligação à base de dados ....................................................................................................... 195 9.3.2 Criação da classe CRUD ......................................................................................................... 196 9.3.2.1 Acesso à base de dados ........................................................................................... 196 9.3.2.2 Função de inserção de dados: operação Create ..................................................... 196 9.3.2.3 Função de leitura de dados: operação Read ........................................................... 197 9.3.2.4 Função de atualização de dados: operação Update .............................................. 199 9.3.2.5 Função de eliminação de dados: operação Delete ................................................ 200 9.3.2.6 Junção de todas as operações .................................................................................. 200 9.4 Desenvolvimento das páginas Web ............................................................................................. 203 9.4.1 Cabeçalho e rodapé .............................................................................................................. 203 9.4.1.1 Cabeçalho .................................................................................................................. 203 9.4.1.2 Rodapé ........................................................................................................................ 204 9.4.2 Página de entrada .................................................................................................................. 204 9.4.3 Página de inserção de dados ................................................................................................ 206 9.4.4 Página de visualização de dados ......................................................................................... 210 9.4.5 Página de atualização de dados........................................................................................... 211 9.4.6 Página de eliminação de dados ........................................................................................... 215 Resumo ................................................................................................................................................... 218

ÍNDICE GERAL

10. PHP 7..................................................................................................... 219 10.1 Introdução ....................................................................................................................................... 219 10.2 Instalação do PHP 7 ....................................................................................................................... 220 10.3 Funcionalidades descontinuadas ................................................................................................. 221 10.3.1 ereg() ................................................................................................................................. 222 10.3.2 SWITCH/DEFAULT .............................................................................................................. 223 10.3.3 mysql() ............................................................................................................................... 222 10.4 Operadores e funções .................................................................................................................... 224 10.4.1 Operadores ........................................................................................................................... 224 10.4.2 Funções ................................................................................................................................. 225 10.5 Erros................................................................................................................................................. 226 10.6 Classes anónimas ........................................................................................................................... 229 Resumo ................................................................................................................................................... 230 GLOSSÁRIO DE TERMOS – PORTUGUÊS EUROPEU / PORTUGUÊS DO BRASIL .................... 231 ÍNDICE REMISSIVO .......................................................................................... 233

INTRODUÇÃO

Neste capítulo pretende-se dar a conhecer o que é o PHP, quais os paradigmas de programação possíveis com esta linguagem e como instalá-la. Além disso, serão dadas algumas noções gerais sobre a Programação Orientada a Objetos (POO) que são transversais a várias linguagens de programação, seja para ambiente Web ou não.

1.1

BREVE HISTÓRIA DO PHP

A linguagem PHP (Hypertext Preprocessor), atualmente na versão PHP 7, surgiu em 1994 pela mão de Rasmus Lerdorf, com a designação inicial de Personal Home Page Tools. Posteriormente foi desenvolvida a versão PHP 3 e, mais tarde, surge a versão PHP 4, a qual já incluía recursos que permitiam a programação orientada a objetos. Em junho de 2004 é apresentada a versão PHP 5, mas a última versão estável é a 5.6, pese embora já exista a versão 7, que virá mudar alguns dos hábitos de programação por objetos que conhecemos atualmente para esta linguagem. Quanto à versão 6, não chegou (nem chegará) a ser lançada como uma verdadeira versão do PHP, pois tinha como objetivo colmatar a falha apontada às versões 5.2 e anteriores de não terem suporte nativo para Unicode. Assim, em 2005 chegou a ser constituído um grupo de trabalho para desenvolver uma versão (PHP 6) que tivesse esse suporte, mas em 2009 foi lançada a versão 5.3 com algumas funcionalidades previstas para o PHP 6, só que mantendo-se sem o suporte Unicode. Em resultado disso, os recursos que supostamente seriam incorporados na versão PHP 6 foram sendo integrados a partir das versões 5.3 e 5.4, razão pela qual o PHP 6 deixou de fazer sentido como uma versão principal. Contudo, este assunto não foi pacífico e chegou a ser uma matéria discutida entre os programadores, desde 2014, com vista a saber se a versão posterior à 5.x deveria ser designada por “PHP 6” ou “PHP 7”1, acabando por se adotar a última. No que toca à versão PHP 7, esta foi lançada em definitivo no final de 2015, razão pela qual serão incluídas neste livro as devidas referências a esta versão, sempre que tal nos pareça adequado e se justifique. Apesar da introdução desta versão, é expectável que

1 As opiniões e a discussão em torno do nome da versão de PHP que deveria ser adotado encontram-se disponíveis online em https://wiki.php.net/rfc/php6#vote.

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

demore algum tempo até que a mesma seja usada em pleno, na medida em que há um período de adaptação, quer de máquinas quer de programadores, que tem de ser tido em conta. Contudo, na parte final do livro dedicaremos um capítulo a esta nova versão, uma vez que os conteúdos apresentados ao longo do resto da obra lhe podem ser aplicados.

1.2

VALE A PENA APRENDER PHP?

A resposta a esta pergunta, considerando que este é um livro sobre PHP, acaba por ser óbvia. Contudo, se esquecermos o facto de estarmos a falar de um livro sobre PHP, a resposta é, sem dúvida, sim! Isto porque, apesar de toda a discussão em torno de qual o nome que deve ser adotado na próxima versão de PHP, se é uma linguagem tipada ou se é a melhor linguagem para desenvolvimento Web, o certo é que esta linguagem se tem mantido ao longo do tempo como uma poderosa linguagem de programação. Isto sobretudo para a construção de páginas Web ou aplicações que se pretende que sejam usadas em ambientes Intranet, representando atualmente a linguagem utilizada em cerca de 80% dos sites conhecidos, com uma larga vantagem sobre linguagens mais “maduras” como o ASPX ou até linguagens mais modernas e mais em voga, como o Ruby on Rails ou o Python (https://w3techs.com/technologies/overview/programming_language/all). A seu favor – e tal como outras linguagens existentes –, a linguagem PHP permite, de modo rápido e fiável, a construção de páginas Web, sendo cada vez maior a quantidade de bibliotecas que estão disponíveis, seja para o desenvolvimento orientado a objetos, seja para programação MVC (Model View Controller), o que permite aos programadores a criação de todo o tipo de páginas, além da reutilização do código desenvolvido, entre outras funcionalidades. Sendo uma linguagem robusta e bastante completa, é ainda possível incorporar variadíssimas funções que vão desde o trabalho de bases de dados, passando pela apresentação de gráficos, exportação de ficheiros nos formatos PDF ou XLSX (o chamado formato “Excel”), entre outros. Além disso, é uma linguagem desenvolvida por uma comunidade bastante alargada, o que permite a qualquer utilizador (desde o simples amador ao profissional) encontrar respostas para as suas dúvidas em sites, fóruns ou até revistas dedicadas a esta linguagem de programação. Existe ainda a possibilidade de desenvolver aplicações com aspeto semelhante às que se desenvolvem em C++/C#, utilizando a extensão PHP-GTK, mas cujo tratamento não será abordado neste livro. No entanto, realçamos que o capítulo da segurança tem sido cada vez mais trabalhado e aprimorado, além do tratamento de erros e bugs que vão sendo detetados. Apenas a título de curiosidade, refira-se que, atualmente, até o SQL Server da Microsoft já permite a integração com o PHP, apesar de esta empresa possuir a sua própria linguagem para ambiente Web (ASP/ASPX), o que demonstra a importância do PHP nos dias de hoje ao nível da programação para a Internet e do seu suporte pelos diferentes servidores Web. © FCA – Editora de Informática

CONCEITOS GERAIS

No Capítulo 1 tratámos da instalação e configuração dos recursos necessários, bem como de algumas práticas de programação que podem (e devem) ser seguidas. Neste capítulo vamos relembrar e afinar critérios específicos da linguagem PHP, como sejam as variáveis, as estruturas de controlo e decisão, as funções ou a a manipulação de ficheiros, entre outros.

2.1

INTRODUÇÃO

O objetivo deste capítulo é, sobretudo, relembrar alguns conceitos de programação inerentes à linguagem PHP, já que é conveniente ter algumas noções sobre esta linguagem antes de o leitor “meter mãos à obra” e passar ao paradigma da POO (ou, mais simplesmente, programação por objetos), sobretudo ao nível da sintaxe que esta utiliza. Deste modo, considera-se que o leitor já tem (ou teve) algum contacto com a linguagem PHP, ainda que não tenha sido com a forma de programar orientada a objetos ou, em alternativa, já tenha tido contacto com alguma linguagem que utilize o paradigma da POO, na medida em que tal facilita a compreensão e aprendizagem (ou transição para a linguagem PHP) que será efetuada com a leitura deste livro. Assim, veremos apenas algumas das estruturas mais comuns em PHP que, por nem sempre serem utilizadas, poderão necessitar de lembrança, não obstante existirem muitas outras a que nos vamos referindo ao longo do livro e que não estão referenciadas neste capítulo. Sempre que necessário, o leitor poderá recorrer ao próprio manual do PHP, tendo em atenção as alterações recentes introduzidas pela versão 7, que se encontra disponível no endereço http://php.net/manual/pt_BR/index.php. Se já possui algumas noções ou conhecimento de programação com PHP, é também recomendável que verifique as mais recentes alterações da linguagem, caso proceda à atualização da versão que está a utilizar, uma vez que há itens que vão sendo alterados e outros descontinuados, para que a transição seja o mais bem conseguida possível.

2.2

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

STRINGS

Uma string é um conjunto de carateres alfanuméricos encadeados, que pode ser declarado utilizando apenas as aspas ou as plicas. O que for declarado “dentro” destas aspas (ou plicas) é tido como uma string e, caso seja utilizada uma variável, esta poderá conter o texto que se pretender.

2.2.1

CRIAÇÃO E UTILIZAÇÃO DE STRINGS

Aquando do uso de strings em PHP, é possível utilizar várias operações para obter um determinado resultado, sendo utilizado o ponto como caráter de concatenação entre os diversos elementos, seja uma string ou um número. No entanto, existem situações em que a utilização das aspas ou das plicas poderá tornar-se algo confusa, como quando temos de lançar a pesquisa (query) à base de dados, em que teremos de inseri-la “dentro” de aspas. Ora, se for necessário indicar strings nesta situação, a alternância entre aspas ou entre aspas e plicas pode originar confusões. Imagine-se, por exemplo, que pretendíamos declarar a variável $nome e escrever o seguinte texto: "O meu nome é Manuel". Tal tomaria a seguinte forma: $nome = "O meu nome é Manuel";

Só se quiséssemos colocar o nome “Manuel” dentro de aspas é que a string já seria do tipo $nome = "O meu nome é "Manuel"";. Ora, no PHP, isto iria originar um erro, uma vez que a aspa antes de Manuel seria interpretada como sendo o final da string, pelo que seria necessário utilizar carateres de escape. Para resolver este problema, deveria colocar-se, então, uma indicação de que seria utilizado um caráter de escape, que é representado pela barra ao contrário (\). Este tipo de carateres especiais vai permitir, entre outros aspetos, que se utilizem as aspas “dentro de aspas”, ainda que estejamos a declarar uma string. Como exemplos deste tipo de carateres destacam-se os seguintes: \t – indica que há uma tabulação; \" – indica que vão ser utilizadas aspas e que estas devem ser apresentadas; \\ – indica que deve ser apresentada a própria barra ao contrário; \$ – indica que deve ser mostrado o símbolo $.

Deste modo, se o objetivo fosse apresentar o nome “Manuel” dentro de aspas, deveria utilizar-se a seguinte instrução: $nome = "O meu nome é \"Manuel\".";

PROGRAMAÇÃO ORIENTADA A OBJETOS 1

Neste capítulo dedicamo-nos ao paradigma da Programação Orientada a Objetos (POO) em PHP, com a referência às noções introdutórias sobre este tipo de programação. Além disso, são descritos comandos básicos que servirão de base para o estudo dos próximos capítulos por conterem os elementos essenciais à compreensão da programação por objetos.

3.1

INTRODUÇÃO

Em tempos idos, a programação seguia um modelo diferente do seguido nos dias de hoje, uma vez que os programas de computador eram escritos com vista a serem lidos e executados de forma sequencial. Esta forma de programar, apesar de padecer de alguns problemas, era suficiente para satisfazer as necessidades da época, naquilo que hoje nos pareceriam ser programas bastante arcaicos e simples. Tais programas – construídos para serem executados sequencialmente, como já foi referido – acabaram por dar lugar a formas estruturadas, em que é possível “dividir” o programa em subprogramas executados de modo autónomo, no que é conhecido como função ou procedimento. Por exemplo, uma função pode receber dados, realizar uma operação e devolver um determinado resultado, sendo possível reutilizá-la várias vezes. É também “autónoma”, uma vez que o resultado obtido depende do valor inserido. Esta linguagem, que revolucionou o mundo da programação, teve muitas outras novidades, tendo o paradigma ficado conhecido como programação estruturada. Com o advento dos ambientes gráficos, o desenvolvimento de múltiplos sistemas, o aumento das capacidades dos computadores e a multiplicidade de aplicações informáticas, sem esquecer o advento da Internet e dos dispositivos móveis e portáteis, surgiram também inúmeras linguagens de programação específicas para determinado tipo de aplicações, que seguiam esse modelo de programação. Apesar de os programadores seguirem determinadas práticas no modo de programar, também começaram a surgir programas que permitiam “programar” sem ser necessário dominar toda a linguagem de programação associada. Ora, isso levou a múltiplas

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

formas de programar que nem sempre são as mais adequadas, gerando código que nem sempre tem uma utilidade direta na prática1. Assim, surgiu um outro paradigma que é o de Programação Orientada a Objetos (POO), do inglês Oriented Object Programming (OOP). Este tipo de programação tem, na sua génese, a ideia subjacente de que o código deve seguir um determinado padrão ao nível da sua estrutura, podendo ser interpretado e conhecido por todos, o que também permite que seja reutilizado. Note-se que o objetivo não é o alinhamento do código (indentação) ou apenas a sua reutilização, dado que isso podia ser feito utilizando, por exemplo, uma função (function). É, sobretudo, conseguir estruturar o código de uma forma tal que seja compreensível por todos os programadores, quer estes se conheçam ou não, o que acaba por ser conseguido na POO, uma vez que são usadas interfaces, classes e métodos que definem o padrão e a orientação a ser seguida por todos e compreendida também por todos.

3.2

CONCEITOS GERAIS

O paradigma da POO é transversal a inúmeras linguagens, sejam ou não orientadas para ambiente Web, como é o caso da linguagem Java. Também a linguagem PHP permite a aplicação deste tipo de programação, em que se torna necessário compreender alguns conceitos que não estão evidenciados na programação estruturada. A POO é um paradigma de programação baseada em “objetos”, que são estruturas que contêm dados e que possuem atributos. Daí que como conceitos principais surjam os de classe, objeto e propriedade, além de outros, como herança, construtor ou polimorfismo. Mas para compreendermos melhor os conceitos que acabámos de referir, pensemos num automóvel. Se quisermos descrever algumas das caraterísticas do automóvel, podemos dizer que é grande, potente, confortável, que tem cinco lugares, etc., mas isto são apenas algumas delas. Já se dissermos que está parado ou em andamento, não estamos a referir-nos às caraterísticas daquele automóvel, mas sim àquilo que ele faz. Trata-se, assim, de propriedades diferentes mas todas correspondem ao mesmo automóvel! Ora, transpondo agora estes conceitos para o mundo da programação, diríamos que os automóveis em geral representam a classe, já que são um objeto real, do dia a dia, que queremos usar na programação. No entanto, os automóveis não são todos iguais, pois existem diversos modelos, marcas, cores, fabricantes, etc., pelo que teremos de criar um objeto que, embora partilhe as caraterísticas gerais da classe, seja diferente conforme as suas caraterísticas particulares. Trata-se, assim, de uma instância da classe automóvel!

1 É o caso, por exemplo, de alguns programas que com poucos cliques permitem a construção de uma página Web em código HTML, ainda que o programador não necessite de escrever o código e muito deste possa ser redundante.

DESIGN PATTERNS

Neste capítulo abordaremos um conceito presente na POO – o de “padrões de desenho”, do inglês design patterns, também conhecidos como padrões de projeto. Estes permitem estruturar o código de uma forma mais eficiente e rápida através de um conjunto de operações padronizadas que se repetem com frequência.

4.1

INTRODUÇÃO

Não são poucas as vezes em que o programador encontra dificuldades que já foram sentidas por outros profissionais! Atualmente, os programadores já dispõem de um conjunto de referências e de comunidades nas quais podem encontrar resposta às suas dúvidas, pelo que não é preciso “reinventar a roda”; mas, perante certas dificuldades, é possível aplicar conceitos comuns à programação por objetos. Além disso, quanto mais vezes ocorrer uma determinada situação, mais pessoas dedicarão tempo à descoberta de uma solução, pelo que se houver um padrão nos obstáculos encontrados ao longo da programação, será mais fácil encontrar a ajuda necessária. A utilização deste conceito não é nova e foi na década de 80 do século passado que se deram os primeiros passos relativamente à ideia de padrões (patterns) que fossem reutilizáveis. Esta proposta surge por intermédio de Christopher Alexander1 que, nas obras Notes on the Synthesis of Form, The Nature of Order, The Timeless Way of Building e A Pattern Language, definiu as caraterísticas que um padrão deve ter, além do modo como deve ser formado. Embora o autor que acabámos de citar não esteja diretamente relacionado com a computação nem com a informática, foi em 1987 que Kent Beck e Ward Cunningham criaram os primeiros padrões especificamente destinados à utilização em computadores, tendo mais tarde desenvolvido outros projetos. Contudo, remonta aos anos 90 do século passado o seu forte desenvolvimento, tendo ganhado bastante expressão em 1995 com a publicação, do livro Design Patterns: Elements of Reusable Object-Oriented Software.

1 Mais referências a este autor e ao trabalho por ele desenvolvido, bem como à sua carreira, podem ser encontradas no endereço https://www.patternlanguage.com/leveltwo/ca.htm.

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

Os seus autores – Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides – ficariam conhecidos para a história como Gang of Four, tendo apresentado diferentes conceitos relativos a padrões de criação, estruturais e comportamentais, que veremos na secção seguinte, e que ainda hoje são utilizados, sobretudo na POO. Assim, e como temos vindo a referir, a POO em PHP foi introduzida a partir da versão 5.0, o que trouxe a possibilidade de se criarem bibliotecas com diferentes soluções, sendo que os padrões de desenho foram uma delas. Estes padrões, também designados por design patterns, permitem que a estruturação do código e do projeto da aplicação seja mais fácil de manter e também de ser entendida. Os design patterns funcionam de modo ligeiramente diferente do que temos vindo a abordar até aqui, uma vez que passamos a mover-nos dos conceitos básicos, como as classes e os objetos, para dar lugar à compreensão de problemas e a potenciais soluções para os nossos projetos, fazendo a passagem de “o quê?” para “porquê?”. Note-se, porém, que neste livro não seria possível fazer um tratamento exaustivo de todos os design patterns, pelo que resumiremos o que entendemos ser o mais relevante nesta matéria.

4.2

DESIGN PATTERNS: O QUE SÃO?

As dificuldades e os problemas que podem ocorrer quando se está a “construir” uma aplicação não são poucos e, por vezes, surgem repetidamente. Por exemplo, como fazer a aquisição de dados a partir da base de dados ou como devem os resultados ser apresentados são apenas duas das questões que surgem a quem está a desenvolver aplicações, tendo que se optar por um conjunto de técnicos específicas que permitam responder a tais questões, as quais são muitas vezes reutilizáveis. Assim, e de forma simplista, poderíamos dizer que tais técnicas correspondem a padrões de projeto – a que daríamos então o nome design patterns – que seguem uma sequência: analisar o problema, construir uma solução e analisar as consequências. Talvez a melhor definição seja mesmo a de Christopher Alexander, que na sua obra publicada em 1977 com o título A Pattern Language ilustra bem o conceito de “padrão” a que nos vamos referir ao longo deste capítulo: Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice2.

Alexander, C. (1977). A Pattern Language – Towns, Buildings, Construction, Oxford University Press (p. X).

AUTOLOAD, ERROS E EXCEÇÕES

O capítulo anterior abrangeu um conjunto de conhecimentos necessários para melhor compreender a POO, seja em PHP ou noutra linguagem. Contudo, é altura de aprofundar um pouco mais os conhecimentos sobre este tipo de programação, orientando especificamente o nosso interesse para um conjunto de conceitos relacionados com os objetos e as classes em PHP, bem como o seu tratamento e manipulação.

5.1

FUNÇÕES PARA CLASSES E OBJETOS

No Capítulo 2 vimos as funções específicas para strings e arrays. No entanto, o PHP também possui funções específicas para classes e objetos, que permitem a sua manipulação, sendo apenas apresentadas neste capítulo, uma vez que eram necessários conceitos que só ao longo capítulo anterior foram introduzidos. A lista completa das funções dedicadas às classes e aos objetos pode ser encontrada no endereço http://php.net/manual/pt_BR/ref.classobj.php, destacando-se aqui algumas dessas funções: class_exists – permite verificar se a classe existe antes de esta ser chamada; get_class – permite saber o nome da classe da qual o objeto faz parte; get_class_methods – permite saber nomes dos métodos existentes na classe; get_class_vars – permite saber o nome das variáveis (e os seus valores) presentes na classe que foi criada; get_parent_class – permite saber o nome da classe principal da qual o

objeto faz parte; method_exists – permite verificar se existe um método num determinado

objeto antes de este ser chamado; property_exists – permite verificar se um objeto possui uma determinada

propriedade.

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

Por exemplo, para saber os métodos existentes na classe que desenvolvemos na secção 3.6, basta inserir a instrução print_r(get_class_methods('Professor')); para que fossem apresentados sob a forma do array mostrado na Figura 5.1.

FIGURA 5.1 – Apresentação dos métodos da classe Professor.class.php

5.2

INTERFACES

Na POO é possível o uso de interfaces, ou seja, a criação de um código que especifica diretamente os métodos que a classe deve implementar, sem ter que definir como é que esses métodos serão usados. No fundo, acaba por ser uma garantia de que será usado um determinado método na classe e que, sem este, a mesma será inválida. Para se utilizar uma interface é necessário usar a palavra interface em vez de class, mas sem definir os conteúdos do método, em que todos os métodos indicados devem ser públicos, podendo as interfaces serem estendidas da mesma forma que se usou para as classes, ou seja, através do comando extends. Imaginemos que se pretende calcular a área de um retângulo, sendo necessário indicar sempre a largura e a altura do mesmo. Para tal, declaramos uma interface com três métodos (altura, largura e area), os quais vamos depois solicitar na classe que vai receber os valores e calcular a área. Contudo, e de forma propositada, não incluimos os métodos largura e area, ficando o código apenas como se apresenta a seguir: <?php // criar a interface Retangulo

interface InterfRetangulo { function setAltura($altura); function setLargura($largura); function getArea(); } © FCA – Editora de Informática

XML E MYSQLI

Após termos percorrido as bases necessárias para a compreensão, criação e manipulação de classes e objetos, voltamo-nos agora para a manipulação de dados. Assim, veremos como se pode utilizar o PHP para manipular ficheiros XML e bases de dados, usando o paradigma de POO através do mysqli.

6.1

INTRODUÇÃO AO XML

A linguagem XML (eXtended Markup Language) foi sendo progressivamente introduzida sobretudo a partir da década de 90 do século passado e é, atualmente, uma das linguagens que permite a criação de documentos com bastante flexibilidade ao nível da manipulação de dados, uma vez que não é dependente do software ou hardware utilizados. O XML tem como vantagens a simplicidade de criação e escrita, a criação de tags que não limitam o formato ou o texto, a organização de dados de forma hierárquica ou como suporte Unicode, podendo ser criado ou editado em qualquer editor de texto comum. Em Portugal, podemos encontrar ficheiros em formato XML para diversos fins, sendo um deles o que é usado pelos sistemas que possuem a implementação da norma Standard Audit File for Tax Purposes (SAF-T) para exportação de dados contabilísticos que, posteriormente, são fornecidos à Autoridade Tributária e Aduaneira (AT). O PHP possui várias bibliotecas que permitem a utilização e manipulação de documentos em formato XML, das quais se salientam as bibliotecas Document Object Model (DOM), libXML ou SimpleXML, entre outras1, sendo possível deste modo utilizar documentos originados com XML e integrá-los usando a POO em PHP. Se o objetivo for trabalhar com dados em XML devolvidos sob a forma de array, deveremos utilizar a biblioteca SimpleXML. Esta é uma das bibliotecas disponibilizadas nativamente pelo PHP e que permite a utilização de XML com PHP orientado a objetos, estando automaticamente ativa a partir

1 A lista completa está disponível no endereço https://secure.php.net/manual/pt_BR/refs.xml.php. Também pode encontrar referências em http://www.w3schools.com/php/php_xml_simplexml_read.asp.

110

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

da versão PHP 5.1.2. Mas se o objetivo fosse trabalhar com tabelas, poderíamos utilizar a biblioteca XSL; e se fosse para transformar o conteúdo de uma base de dados MySQL em conteúdo XML, poderíamos fazer uso da biblioteca XMLWriter. Deste modo, e para não tornar exaustiva a descrição dos vários procedimentos, neste capítulo faremos uma breve abordagem deste processo para o caso dos dados obtidos sob a forma de arrays com o SimpleXML e também com o XMLWriter, percorrendo algumas das funções existentes para cada uma destas bibliotecas.

6.2

DOCUMENTO XML

Para melhor se compreender o funcionamento do PHP aplicado ao XML, é conveniente ter uma noção básica sobre a estrutura e formatação de um documento XML, na medida em que depois se perceberá melhor a interligação entre os dois formatos. Assim, o documento XML tem como grande vantagem o facto de estar organizado por tags personalizadas que permitem estruturar o conteúdo, de forma similiar às tags utilizadas em linguagem HTML. Para se elaborar um documento XML, deve atender-se aos seguintes requisitos essenciais: Atributos – devem ser colocados dentro das tags para fornecer informações, mas não são fundamentais para o documento, uma vez que não fazem parte dos dados. Por exemplo, os que se colocam a seguir à tag para indicar algo, como no caso assinalado a negrito na seguinte linha de código: <tarefa nome="passar_a_ferro" tempo_previsto = "10 minutos">;

Entidades – são unidades de informação e devem ser identificadas pelo seu nome. Quanto aos atributos, devem ser evitados acentos ou aspas simples, facultativos pois apenas servem para tornar mais claro o que se vai descrever no documento XML. Caso seja necessário escrever bastante texto numa entidade, pode recorrer-se ao comando CDATA, ou seja, Character Data, através da instrução <![CDATA[texto a inserir]]>. Outros requisitos a ter em conta são: Utilização de tags – para identificar o conteúdo, sendo as tags case sensitive e feitas de forma idêntica à do HTML; Estrutura em árvore – os elementos relacionam-se de acordo com o seu parentesco; Codificação – na primeira linha deve sempre ser identificada a versão do XML em uso e a codificação utilizada.

PHP DATA OBJECTS

Neste capítulo dá-se continuação ao tema que foi apresentado no capítulo anterior relativamente à interligação entre o PHP e as bases de dados. Desta forma, serão descritas as vantagens da utilização de PHP Data Objects (PDO) para bases de dados, uma vez que deixamos de estar dependentes do MySQL, e analisados diferentes processos de integração das bases de dados com PDO.

7.1

INTRODUÇÃO

O PHP Data Object (PDO) veio colmatar as limitações sentidas pelos programadores com o mysqli quando necessitavam de interagir com outros SGBD que não apenas o MySQL. Para fazer uso da biblioteca PDO, esta deve estar ativa, o que é possível saber acedendo às definições do ficheiro php.ini ou via browser, como mostra a Figura 7.1.

FIGURA 7.1 – SGBD disponíves com PDO (informação via browser)

Ao contrário do mysqli, a utilização de PDO tem como vantagens permitir usar um dos 12 tipos de SGBD, além de possuir prepared statements do lado do cliente, o que significa que as consultas à base de dados são tratadas do lado do cliente. © FCA – Editora de Informática

138

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

Contudo, essas caraterísticas fazem com que a utilização de PDO torne a performance pior do que aquela que é obtida com o mysqli, pelo que deverá ser visto caso a caso qual o melhor paradigma a utilizar. Note-se que o PDO é uma camada de abstração que permite fazer a ligação à base de dados, oferecendo não só uma forma unificada de ligação às bases de dados com que o PHP pode trabalhar, mas também benefícios como a segurança, a usabilidade ou a reutilização, uma vez que a mesma rotina pode ser utilizada várias vezes e que a sua API é unificada.

7.2

LIGAÇÃO À BASE DE DADOS

Para realizar a ligação à base de dados é necessário sabermos qual o SGBD que será utilizado. Visto que a biblioteca PDO não vai interferir com as instruções SQL, dado que o seu objetivo é unificar métodos e instruções para uso com diferentes bases de dados, temos de indicar a instrução correta de modo a que se possa criar o objeto para a conexão à base de dados em uso, pese embora a criação do objeto de ligação seja igual. Esta possibilidade de abstração é bastante importante e vai poupar tempo e recursos na execução das instruções, pois teremos uma forma de não depender inteiramente do código escrito para efetuar a ligação, estando antes direcionado ao driver que será utilizado na mesma. Caso se pretendesse, poderia obter-se a lista dos SGBD disponíveis, sob a forma de array, através da execução do código abaixo, podendo consultar-se a lista completa das bases de dados suportadas no endereço http://php.net/manual/en/pdo.drivers.php. É de realçar também que, ao executar o código seguinte, é possível obter-se uma lista dos drivers à disposição: <?php var_dump(PDO::getAvailableDrivers()); ?>

Outra opção seria utilizar o seguinte script: <?php foreach(PDO::getAvailableDrivers() as $drivers) { print $drivers.'</br>'; } ?>

Este código retornará um array com a lista dos drivers disponíveis e que podem ser usados, conforme mostra a Figura 7.2.

TRANSAÇÕES E STORED PROCEDURES 6

Neste capítulo completaremos o estudo sobre a utilização dos objetos com a base de dados, analisando como se podem controlar as transações, e sobre a utilização dos stored procedures criados e armazenados no servidor da base de dados.

8.1

TRANSAÇÕES

No Capítulo 7 vimos a interação entre os objetos e a base de dados, mas tal não esgota os conceitos que podem ser referidos a propósito desta matéria. Deste modo, é fundamental considerar outros aspetos, entre os quais a forma como é feita e se mantém a ligação à base de dados, de que modo se podem criar consultas que são usadas de forma recorrente transferindo a carga para o lado do servidor, etc. Considerando o último exemplo visto no capítulo anterior, em que fazíamos a atualização dos dados existentes na base de dados, surgia a questão de que tais dados só deveriam ser alvo de atualização se existissem, pois caso contrário a base de dados nem deveria aceitar o pedido de atualização. Para contornar a situação, criámos um ciclo IF que verificava a existência de tal registo, mas outras questões poderiam ter-se levantado. Por exemplo, se em vez de uma atualização dos dados do médico estivéssemos a tratar da atualização do saldo de uma conta bancária, na sequência de um levantamento da conta, seria fundamental controlar a operação realizada, sob pena de termos várias pessoas a realizar levantamentos simultâneos da mesma conta, sem que esta possuísse saldo suficiente, apenas porque o sistema não conseguiria controlar o número de operações nem o seu encadeamento. O mesmo se aplica relativamente à compra online de uma viagem de avião: se estivéssemos a efetuar a compra e logo depois o check-in de um dado passageiro, seria necessário assegurar que a reserva de um determinado lugar no avião ficaria “bloqueada” para evitar que, entretanto, alguém que também estivesse a fazer a compra online para o mesmo voo marcasse esse lugar de forma definitiva, e viéssemos a ter dois passageiros com reserva para o mesmo lugar, havendo depois um lugar vazio algures no avião.

170

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

Para evitar situações como a que acabámos de descrever recorre-se ao controlo de transações. Numa aplicação “pura” de SQL, poderíamos recorrer aos controlos dos tipos START TRANSACTION, COMMIT, ROLLBACK, etc., mas no PHP teremos de o fazer através da criação de uma classe que verifique todas estas situações e atue em conformidade. Deste modo, será possível manter a ligação à base de dados aberta enquanto a operação estiver em curso, a qual só terminará quando se tiver a certeza de que todos os procedimentos foram realizados. Refira-se ainda que nem todas as bases de dados suportam transações e que nem todas as tabelas o admitem, pelo que o utilizador deverá ter atenção a este aspeto sempre que pretender utilizar transações em bases de dados com PDO.

8.1.1

CONCEITO

Vejamos novamente o exemplo quanto à conta bancária, imaginando que esta tem saldo igual a zero e que pretendemos realizar um depósito e um levantamento de dinheiro, de forma sequencial. Se começarmos pelo depósito e, em seguida, fizermos o levantamento, não haverá problemas desde que o valor do depósito seja suficiente para dar cobertura ao levantamento. Contudo, pensemos numa transferência bancária: se ao transferirmos dinheiro da conta A para a conta B houvesse uma falha de comunicação, a conta A poderia ficar sem essa quantia (porque, entretanto, já tinha sido debitada), mas a conta B não a receberia, porque o processo teria falhado algures. Ora, para evitar situações como esta, na programação recorre-se a transações que, à semelhança das financeiras, só se dão por terminadas depois de ter sido realizado um conjunto de operações predeterminadas. Em caso de falha de uma ou mais operações, todas as restantes já realizadas são anuladas, como se nunca tivessem ocorrido, dado que princípio, meio e fim estão perfeitamente estabelecidos. Como caraterísticas das transações, podemos evidenciar as seguintes: Atomicidade – consiste no facto de as transações funcionarem como um “bloco” unitário, em que ou são todas executadas ou são todas revertidas até ao ponto de origem; Consistência – assegura que há integridade referencial na base de dados, antes e depois da transação; Isolamento – permite que a transação realizada na base de dados seja “isolada” das restantes operações, isto é, só é mostrada após ter sido integralmente concretizada, não estando disponível para outras operações durante o seu tempo de realização;

CREATE, READ, UPDATE AND DELETE 6

Após termos visto a utilização de bases de dados e as transações, analisaremos neste capítulo o conceito traduzido pela sigla de Create, Read, Update and Delete (CRUD), que é um conceito bastante presente para quem desenvolve aplicações web based, relativo às quatro operações mais realizadas sobre a base de dados: criação, leitura, atualização e eliminação.

9.1

INTRODUÇÃO

O conceito de Create, Read, Update and Delete (CRUD) é aplicado a muitos projetos desenvolvidos hoje em dia para a Web, tendo como objetivo tornar possível a reutilização de código na realização de tarefas repetidas de “criação” (inserção), leitura (visualização), atualização (alteração) e eliminação de dados. Deste modo, torna-se possível construir classes e funções que separam estas quatro tarefas básicas daquilo que é o código em HTML, criando-se dois níveis diferentes de organização, já que o HTML será utilizado para a apresentação dos resultados geridos com o CRUD. Na prática, o CRUD é a aplicação da POO às diferentes operações que analisámos no Capítulo 8, mas desta vez organizaremos o código em classes, objetos e métodos, e incluiremos HTML, o que permitirá uma apresentação mais estruturada dos dados. Note-se que apenas estamos a organizar os conhecimentos já discutidos anteriormente, mas de uma forma reutilizável e não isolada, como vimos. Assim, dedicaremos este capítulo a apresentar o modo como o CRUD pode realizar operações na nossa base de dados clinica, sendo utilizado com HTML através do Bootstrap – esta é uma framework que permite ultrapassar as questões relacionadas com o layout da aplicação. Uma vez que se pretende mostrar o grau de abstração que pode ser aplicado a este tipo de situações, usaremos o Bootstrap para criação do layout da nossa apresentação, deixando ao código PHP desenvolvido de forma orientada a objetos as quatro tarefas enunciadas anteriormente e aproveitando parte dos scripts e do conhecimento já abordados noutros capítulos.

190

9.2

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

LAYOUT

Ao longo dos capítulos anteriores apresentámos a base de dados clinica, bem como o código da sua criação e o modo como se efetua a ligação à base de dados com objetos – através da utilização do ficheiro ligacao_PDO.php. No entanto, tais conceitos foram analisados de forma isolada e sem a indicação de classes, objetos e métodos que permitem a reutilização de código. Assim sendo, vamos dedicar-nos apenas a explicar como é possível integrar todos estes conteúdos através da utilização de código para interação com um layout já existente.

9.2.1

BOOTSTRAP: INSTALAÇÃO

O Bootstrap é uma framework do tipo front end para o desenvolvimento de sites e outras aplicações de uma forma mais rápida e estruturada e que permite ao programador dedicar-se mais ao código e às tarefas da programação do que à apresentação e ao layout, estando também já preparado para dispositivos móveis e sendo bastante responsivo. Para poder utilizar o Bootstrap, é necessário aceder a http://getbootstrap.com (versão inglesa) ou a http://getbootstrap.com.br (versão em português do Brasil) e clicar no separador “Getting started”, escolhendo depois a opção “Download Bootstrap”, como mostra a Figura 9.1.

FIGURA 9.1 – Página para download do Bootstrap

Após descarregar os ficheiros, deverá colocá-los nas pastas do projeto que está a elaborar, sendo depois necessário chamar dois ficheiros específicos através da tag <head> e indicando o local em que se encontram. Esses ficheiros são o bootstrap.min.css e o bootstrap.min.js, que se encontram nas pastas CSS e JS, respetivamente. © FCA – Editora de Informática

PHP 7

Neste capítulo pretende-se dar a conhecer o PHP 7, bem como algumas das novidades trazidas por esta versão, além de informações sobre como instalá-la. Será também abordada a situação das funções descontinuadas e as alterações introduzidas no que diz respeito ao tratamento de erros, em contraponto ao que vimos no Capítulo 5.

10.1 INTRODUÇÃO O PHP 7 foi definitivamente lançado em outubro de 2015, estando ainda numa fase de entrada em muitos dos sistemas atuais, na medida em que existe sempre um hiato de tempo entre a saída de uma versão e o seu uso consolidado nos servidores. Não obstante esta realidade, o PHP 7 virá para ficar, mas poderá obrigar à atualização do código escrito que não tenha seguido o paradigma de POO, uma vez que deixará de haver suporte definitivo para muitas opções de código existentes nas versões 5.x, como é o caso do acesso ao MySQL sem a utilização de objetos. Quanto às versões PHP 5.5 e PHP 5.6 em concreto, a primeira já perdeu o suporte, ao passo que está previsto que a segunda deixe de ter suporte ativo até finais de 2016 e de ter suporte de segurança até finais de 2018. Ora, isto significa que mesmo as atualizações possíveis para a versão 5.6 serão reduzidas, embora não queira dizer que ambas as versões não possam estar instaladas e continuar a desempenhar o seu trabalho de modo normal. Contudo, é recomendável fazer o upgrade para a nova versão do PHP, ainda que o caminho de migração possa ser relativamente suave se a programação inerente às aplicações já tiver aplicado o paradigma de orientação a objetos. Assim, este capítulo vai abordar a instalação do PHP 7 e algumas das suas novidades (e diferenças), ainda que de uma forma resumida, pois algumas mudanças foram bastante subtis. No entanto, tal não deverá representar obstáculo à migração para a nova versão, visto que o código elaborado segundo o paradigma de orientação a objetos pode (e deve!) ser perfeitamente utilizado nesta nova versão e sem qualquer transtorno, como é o caso dos exemplos que fomos apresentando ao longo deste livro. Deste modo, dedicaremos as próximas páginas ao PHP 7, na medida em que esta será a linguagem PHP do futuro!

220

PHP – COM PROGRAMAÇÃO ORIENTADA A OBJETOS

10.2 INSTALAÇÃO DO PHP 7 Relativamente ao PHP 7, começam a ser disponibilizados pacotes de instalação compostos, como é o caso do XAMPP, em que já está disponível uma versão que o inclui (no endereço https://www.apachefriends.org/pt_br/index.html). Por conseguinte, aplicam-se os processos de instalação indicados no Capítulo 1, desde que se tenha descarregado o pacote de ficheiros correspondente a cada sistema operativo e se pretenda fazer uma instalação “limpa”, ou seja, sem ter uma versão prévia instalada. No entanto, caso tenha uma versão do XAMPP instalada, é possível fazer a atualização para a nova versão, devendo realizar uma cópia de segurança de tudo o que possua (para evitar perda dos trabalhos já desenvolvidos), bem como das bases de dados instaladas, recomendando-se que depois faça a desinstalação da versão anterior (no caso de ser uma instalação “limpa”). Contudo, se pretender correr o PHP 7 em paralelo com o PHP 5.x que estiver instalado, poderá fazê-lo de dois modos distintos: ou instalando o XAMPP com PHP 7 numa pasta diferente daquela onde tem instalado o XAMPP com PHP 5.x, ou fazendo a instalação manual e a respetiva configuração. Assim, caso queira efetuar todo o processo manualmente, deverá aceder ao endereço http://php.net/downloads.php e descarregar a última versão do PHP 7. Em seguida, e se tencionar manter a versão que tem instalada, deverá criar uma nova pasta (por exemplo, “PHP7”), que poderá colocar na localização atual do XAMPP paralelamente à pasta que contém a versão em uso do PHP. Após este passo, resta indicar a localização da nova pasta para que o XAMPP assuma o PHP 7, o que é feito alterando o ficheiro httpd-xampp.conf que se encontra na pasta dos ficheiros do XAMPP, usando os endereços /XAMPP/xamppfiles/etc/extra/ (para Mac OS X e Linux) ou /XAMPP/apache/conf/extra/ (na versão Windows). Em seguida, deverá modificar a linha de código que contém a indicação do diretório em uso para o diretório que pretende usar com o PHP 7, ou seja, mudar as seguintes linhas de código: LoadFile localização_do_XAMPP/php7/php7ts.dll LoadFile localização_do_XAMPP/php7/libpq.dll LoadModule php7_module localização_do_XAMPP/php7/php7apache2_4.dll

Por último, não se esqueça de mudar a localização do ficheiro php.ini, adicionando as seguintes instruções: <IfModule php7_module>PHPINIDir "localização_do_XAMPP/php7" </IfModule> © FCA – Editora de Informática