Disciplina: Desenvolvimento de Aplicações WEB

Automatic type conversion

Aula 1: Programação do lado Types assigned by context
The Simple Types
do Servidor Integers
Static HTML Doubles
Client-Side Technologies Booleans
Server-Side Scripting NULL
What Is Server-Side Scripting Good for? Strings
Output
Echo and print
Aula 2 – Introdução: Por que Variables and strings
PHP e MySQL?
What Is PHP? Aula 5: Controle e Funções
What Is MySQL? Boolean Expressions
The History of PHP Boolean constants
The History of MySQL Logical operators
Reasons to Love PHP and MySQL Comparison operators
Cost The ternary operator
Ease of Use Branching
HTML-embeddedness If-else
Cross-platform compatibility Switch
Not tag-based Looping
Stability Bounded loops versus unbounded loops
Speed While
Open source licensing Do-while
Many extensions For
Fast feature development Looping examples
Popularity Break and continue
Not proprietary A note on infinite loops
Strong user communities Alternate Control Syntaxes
Terminating Execution
Aula 3: Adicionando PHP ao Using Functions
Return values versus side effects
HTML Function Documentation
Your HTML Is Already PHP-Compliant! Headers in documentation
Escaping from HTML Finding function documentation
Canonical PHP tags Defining Your Own Functions
Short-open (SGML-style) tags What is a function?
Hello World Function definition syntax
Jumping in and out of PHP mode Function definition example
Including files Formal parameters versus actual parameters
Argument number mismatches
Functions and Variable Scope
Aula 4:Sintaxe e Variáveis Global versus local
PHP Is Forgiving Static variables
HTML Is Not PHP Exceptions
PHP’s Syntax Is C-Like Function Scope
PHP is whitespace insensitive Include and require
PHP is case sensitive Recursion
Statements are expressions terminated by
semicolons Aula 6: Passando
Braces make blocks
Comments Informações entre Páginas
C-style multiline comments HTTP Is Stateless
Single-line comments: # and // GET Arguments
Variables A Better Use for GET-Style URLs
PHP variables POST Arguments
Declaring variables (or not) Formatting Form Variables
Assigning variables Consolidating forms and form handlers
Reassigning variables Using array variables with forms
Unassigned variables PHP Superglobal Arrays
Variable scope Extended Example: An Exercise Calculator
You can switch modes if you want
Constants
Types in PHP: Don’t Worry, Be Happy Aula 7: Strings
No variable type declarations Strings in PHP
Interpolation with curly braces INSERT
Characters and string indexes UPDATE
String operators DELETE
Concatenation and assignment
The heredoc syntax
String Functions Aula 11: Funções PHP/MySQL
Inspecting strings Connecting to MySQL
Finding characters and substrings Making MySQL Queries
Comparison and searching Fetching Data Sets
Searching Getting Data about Data
Substring selection Creating MySQL Databases with PHP
String cleanup functions MySQL data types
String replacement MySQL Functions
Case functions
Escaping functions
Printing and output Aula 12: Mostrando
Extended Example: An Exercise Calculator Consultas em Tabelas
HTML Tables and Database Tables
Aula 8: Arrays e Funções de One-to-one mapping
Example: A single-table displayer
Arrays The sample tables
The Uses of Arrays Improving the displayer
What Are PHP Arrays? Complex Mappings
Creating Arrays Multiple queries versus complex printing
Direct assignment A multiple-query example
The array( ) construct A complex printing example
Specifying indices using array( ) Creating the Sample Tables
Functions returning arrays
Retrieving Values
Retrieving by index Aula 13: Construindo
The list( ) construct Formulários
Multidimensional Arrays
HTML Forms
Inspecting Arrays
Basic Form Submission to a Database
Deleting from Arrays
Self-Submission
Iteration
Editing Data with an HTML Form
Support for iteration
TEXT and TEXTAREA
Using iteration functions
CHECKBOX
Our favorite iteration method: foreach
RADIO
Iterating with current( ) and next( )
SELECT
Starting over with reset( )
Reverse order with end( ) and prev( )
Extracting keys with key( ) Aula 14: Sistemas de
Empty values and the each( ) function
Walking with array_walk( ) Arquivos
Understanding PHP File Permissions
File Reading and Writing Functions
Aula 9: Números File open
Numerical Types File read
Mathematical Operators Constructing file downloads by using fpassthru( )
Arithmetic operators File write
Arithmetic operators and types File close
Incrementing operators Filesystem and Directory Functions
Assignment operators feof
Comparison operators file_exists
Precedence and parentheses filesize
Simple Mathematical Functions Network Functions
Randomness Syslog functions
Seeding the generator DNS functions
Example: Making a random selection Socket functions
Extended Example: An Exercise Calculator Date and Time Functions
If you don’t know either date or time
If you’ve already determined the
Aula 10: MySQL date/time/timestamp
Relational Databases and SQL Calendar Conversion Functions
SQL Standards
The Workhorses of SQL
SELECT
Aula 15: Sessões, Cookies, Who pays and how?
Project: A REST Client
and HTTP Project: A SOAP Server and Client
What’s a Session?
So what’s the problem? 2 - Gráficos no PHP – A
Why should you care?
Home-Grown Alternatives Biblioteca GD
IP address Your Options
Hidden variables HTML Graphics
Cookie-based homegrown sessions Creating images using gd
How Sessions Work in PHP What is gd?
Making PHP aware of your session Image formats and browsers
Propagating session variables Choosing versions
Where is the data really stored? Installation
Sample Session Code gd Concepts
Session Functions Functions
Configuration Issues Images and HTTP
Cookies Example: Fractal images
The setcookie( ) function Gotchas and Troubleshooting
Examples Symptom: Completely blank image
Deleting cookies Symptom: Headers already sent
Reading cookies Symptom: Broken image
register_globals and variable overwriting
Cookie pitfalls
Sending HTTP Headers 3 - Programação Orientada a
Example: Redirection Objetos com PHP
Example: HTTP authentication
What Is Object-Oriented Programming?
The simple idea
Aula 16: PHP e XML Elaboration: Objects as datatypes
What Is XML? Elaboration: Inheritance
Working with XML Elaboration: Encapsulation
Documents and DTDs Elaboration: Constructors and destructors
The structure of a DTD Terminology
Validating and nonvalidating parsers Basic PHP Constructs for OOP
SAX versus DOM Defining classes
DOM Accessing member variables
Using DOM XML Creating instances
DOM functions Constructor functions
SAX Inheritance
Using SAX Overriding functions
SAX options Chained subclassing
SAX functions Modifying and assigning objects
SimpleXML API Scoping issues
Using SimpleXML Advanced OOP Features
SimpleXML functions Public, Private, and Protected Members
A Sample XML Application Interfaces
Constants
Abstract Classes
Literatura Complementar Simulating class functions
Calling parent functions
(Trabalhos de pesquisa) Automatic calls to parent constructors
Simulating method overloading
1 - Web Services Serialization
Introspection Functions
The End of Programming as We Know It Function overview
The ugly truth about data munging Example: Class genealogy
Brutal simplicity Example: Matching variables and DB columns
REST, XML-RPC, SOAP, NET Example: Generalized test methods
REST Extended Example: HTML Forms
XML-RPC Gotchas and Troubleshooting
SOAP Symptom: Member variable has no value in
NET services member function
Current Issues with Web Services Symptom: Parse error, expecting T_VARIABLE
Fat and slow OOP Style in PHP
Potentially heavy load Naming conventions
Standards Accessor functions
Hide and seek Designing for inheritance
4 - Funções de Arrays Reading arbitrary files
Running arbitrary programs
Avançadas Viruses and other e-critters
Transformations of Arrays E-mail safety
Retrieving keys and values Register Globals
Flipping, reversing, and shuffling File Uploads
Merging, padding, slicing, and splicing Encryption
Stacks and Queues Public-key encryption
Translating between Variables and Arrays Single-key encryption
Sorting Encrypting cookies
Printing Functions for Visualizing Arrays Hashing
Digitally signing files
Secure Sockets Layer
5 - Expressões Regulares FYI: Security Web Sites
Tokenizing and Parsing Functions
Why Regular Expressions? 10 - Tratamento de Exceções
Regex in PHP
An example of POSIX-style regex Error Handling in PHP
Regular expression functions Errors and exceptions
Perl-Compatible Regular Expressions The Exception class
Example: A Simple Link-Scraper The try/catch block
The regular expression Throwing an exception
Using the expression in a function Defining your own Exception subclasses
Advanced String Functions Limitations of Exceptions in PHP
HTML functions Other Methods of Error Handling
Hashing using MD Native PHP errors
Strings as character collections Defining an error handler
String similarity functions Triggering a user error
Logging and Debugging

6 - Conversões de Tipos
11- Funções de E-mail
Type Round-up
Resources Understanding E-mail
What are resources? TCP/IP server
How to handle resources Mail Transfer Agent, aka SMTP server
Type Testing Mail spool
Assignment and Coercion Mail User Agent, aka local mail client
Integer overflow Mail-retrieval program, aka POP/IMAP server
Finding the largest integer Mailing list manager
Receiving E-mail with PHP
Implementing from scratch
7 - Uso Avançado de Funções Modifying other people’s PHP
Variable Numbers of Arguments Cosmetic changes
Default arguments Sending E-mail with PHP
Arrays as multiple-argument substitutes Windows configuration
Multiple arguments in PHP and above Unix configuration
Call-by-Value The mail function
Call-by-Reference More Fun with PHP E-mail
Variable Function Names Sending mail from a form
An Extended Example Sending mail from a database
Sending attachments with MIME mail
A custom PHP mail application
8 - Matemática Sending mail from a cronjob
Mathematical Constants
Tests on Numbers 12 - Autenticação de Usuário
Base Conversion
Exponents and Logarithms Designing a User-Authentication System
Trigonometry Avoiding Common Security Issues
Arbitrary Precision (BC) Turn off register_globals
An arbitrary-precision example Check for string length and safety
Converting code to arbitrary-precision One-way encrypt passwords
Registration
Login/Logout
9 - Segurança User Tools
Possible Attacks Forgotten password
Site defacement Changing sensitive user data
Accessing source code Edit non-sensitive user data
Administrator Tools
Authorization: Basic auth, cookie, database, and IP Login as user

Bibliografia sugerida
PHP Guia do Desenvolvedor – Sterling Hughes
PHP4 Guia do Programador – Blake Schwendiman
Prog. Em PHP - Conceitos e Aplicações Walace Soares São Paulo Erica Sim
NIEDERAUER, Juliano. DESENVOLVENDO WEBSITES COM PHP. São Paulo: Novatec, 2004.
TIM Converse, JOYCE Park .PHP: A Bíblia.2.ed. Rio de janeiro:Campus,1997.
http://www.php.net

PARTE I - ENTENDENDO A LINGUAGEM.

1. Diferenças entre páginas dinâmicas e estáticas. Comparando linguagens para produção de
páginas estáticas (PHP, JSP, ASP). Breve história do PHP.
2. Referência da linguagem: sintaxe básica, palavras reservadas, tipos e uso de variáveis,
constantes, expressões, operadores, estruturas de controle (condicionais e de repetição),
funções, referências, vetores e matrizes.
3. Características da linguagem: cookies, upload de arquivos, safe mode, conexão persistente
com banco de dados.
4. Bibliotecas de funções e variáveis pré-definidas: arrays, strings, matemática e
trigonometria, mail, data e hora, diretórios, sistema de arquivos, http, manipulação de
imagens, MySQL, sessões, URL, etc.
5. Manipulação de dados obtidos por formulários HTML com PHP.
6. Passando informações entre páginas: cookies e sessões com PHP.
7. Upload de arquivos via FTP com PHP.
8. Enviando e-mails com PHP.

Variáveis
1. Numéricas 3. Arrays
2. Strings 4. Escopo

Operadores
1. Atribuição 3. Lógicos
2. Comparação 4. Aritméticos

Condicionais
1. IF, ELSE
2. ELSEIF
3. SWITCH, CASE

Controle de fluxo
1. WHILE
2. DO... WHILE
3. FOR
Funções

Uso de require e include

PARTE II - INTEGRANDO PHP e HTML

1. Criando páginas dinamicamente
2. PHP e formulários da WEB
3. Cookies
4. Enviando emails pelo PHP

PARTE III - MYSQL E A LINGUAGEM SQL.

1. Tipos de dados aceitos pelo MYSQL
2. Criando tabelas
3. Manipulando dados das tabelas
4. Limitando o número de linhas retornado
5. Conectando-se ao MySQL através do PHP

Introdução
Esta seção fornece uma pequena visão geral da linguagem de programação PHP.
Como mencionei na introdução deste livro, não pretendo passar muito tempo analisando os
conceitos gerais da programação. Aqui, você encontrará a sintaxe PHP para os elementos
comuns da programação, como variáveis, constantes e funções. Os exemplos neste capítulo
não são destinados a mostrar as melhores práticas de programação, mas simplesmente a
sintaxe e o uso. Para obter uma referência completa da linguagem, verifique a seção de
documentação no site da Web do PHP, http://www.php.net. Informações gerais da sintaxe.

Linguagem de Script do Lado do servidor

A Figura 2-4 mostra uma representação esquemática de um fluxo de dados do

lado do servidor. Script do lado do cliente é a parte glamorosa, atraente do desenvolvimento
web. Em contraste, o script do lado do servidor é invisível ao usuário. O desenvolvimento web
do lado do servidor que, na maior parte, envolve conexão de sites web aos seus respectivos
servidores, tais como os bancos de dados. Isto permite comunicação em dois sentidos:
• Servidor ao cliente: As páginas Web podem ser montadas na saída do servidor e
enviada ao navegador do cliente.
• Cliente ao servidor: a informação é enviada pelo Cliente ao servidor. Os exemplos
comuns da interação do cliente ao servidor são os formulários.
Os scripts do lado do servidor consistem em duas partes principais: a linguagem de
script e o motor do script (que podem ou não ser montados no servidor web). O motor analisa
gramaticalmente e interpreta as páginas escritas na linguagem. Freqüentemente, a mesma
companhia ou equipe desenvolve as peças para o uso somente em uma linguagem específica.
PHP e ColdFusion são ambos exemplos desta prática. Entretanto, existem exceções a esta
regra. O servidor de páginas em Java (JSP), por exemplo, é escrito em uma linguagem de
programação melhor do que em uma linguagem especialmente desenvolvida para scripts.
Empresas como por exemplo, Macromedia (JRun), Apache (Tomcat) desenvolveram diversos
motores de script permutáveis que podem ser usados para executar o código JSP em um Web
site.

Entendendo a Linguagem PHP

Como o PHP é geralmente incorporado no código HTML, existem tags especiais
para delimitar os blocos de código PHP. O uso dessas tags também é conhecido como escape
da HTML.

Listagem 1: Maneiras de delimitar os blocos de código PHP na

HTML

<? echo "short PHP tags method of escaping from HTML<br>"; ?>
<?php echo "escape using full PHP tags<br>"; ?>
<script language="php">
echo "some -HTML editors don't like processing instructions<br>";
</script>
<% echo "you may prefer ASP-style tags<br>"; %>

O primeiro método de delimitação de um bloco PHP estará disponível apenas se as

tags curtas tiverem sido ativadas. Para ativá-las, use a função short_tags(), ative a
definição da configuração short_tag_open no arquivo de configuração PHP ou compile o PHP
com a opção -enable-short-tags. As tags do estilo ASP estarão disponíveis apenas se a
definição da configuração asp_tags estiver ativada. O PHP é sintaticamente muito parecido
com o C. Por exemplo, as instruções são separadas por um ponto-e-vírgula. A tag ?> é um
término implícito da instrução, portanto os seguintes exemplos são sintaticamente equivalentes:

Listagem 2: 0 término dos exemplos da instrução

<?php
echo "Testing, testing...<br>";
?>
<?php
echo "Testing, testing...<br>"
?>

Os comentários do PHP são anotados usando os delimitadores de comentários no

estilo do shell C, C++ ou Unix. Os comentários com uma linha terminam no final da linha ou no
final do bloco de código PHP atual, o que vier primeiro. Não aninhe diversos comentários do
tipo C.

Listagem 3: Comentários
<?php
echo "Hello,World!<br>"; // This is a 1-line C++ style comment
/* This is a multiline comment block. */
echo "Hello, again.<br>"; # This is a shell-style comment ?>
<?php
/* The following line will print, "This will print nothing."
*/
?>
This will print <?php # echo "something"; ?> nothing.<br>
<?php
/*
echo "This is a problem."; /* This comment will cause a problem
?>
*/

Tipos
O PHP suporta os seguintes tipos: números com ponto flutuante, inteiros, strings,
arrays e objetos. O tipo de variável é geralmente determinado pelo contexto da variável em vez
de ser definido explicitamen¬te pelo programador. É importante lembrar disto ao desenvolver
aplicações PHP, pois a conversão de tipos implícita pode causar erros incomuns (e difíceis de
encontrar). Por exemplo, a seguinte instrução é válida e resultará no número 9 sendo exibido:

print( 3 * "3 little pigs" );

Para ajudar a gerenciar os tipos variáveis, o PHP fornece as funções gettype() e

settype(), junto com algumas funções específicas para verificar o tipo como is_integer()
e is_array(). A referência de função no final deste livro fornece uma análise completa
dessas funções. Cada um dos tipos de variáveis (exceto os objetos) é analisado rapidamente
nas próximas seções. Números: Inteiros e com ponto flutuante. Você poderá especificar os
inteiros usando a notação decimal, octal ou hexadecimal. Poderá especificar os números com
ponto flutuante na notação padrão e científica. A sintaxe PHP para cada um é mostrada na
listagem a seguir.

Listagem 4: Representações de números

<?php
$int1 = 523; // decimal
$int2 = -523; // negative decimal
$int3 = 01013; // octal representation of 523
$int4 = 0x20B; // hex representation of 523
$floatl = 523.197; // standard float notation
$float2 = 5.23197e2; // scientific float notation. /* Print all the
numbers. Displays "523, -523, 523, 523, 523.197, 523.197". */
print( "$intl, $int2, $int3, $int4, $floatl, $float2<br>" ); ?>
print( "$aStr4<br>" );
$aStr5 = 'Don\'t evaluate $aStr2';
// $aStr5 = "Don't evaluate $aStr2" print( "$aStrS<br>" );
// prints "My name is Thatcher and My name is $aStr2";
print( "$aStr3" . " and " . "$aStr4" );
?>

Strings
As strings no PHP são delimitadas por aspas duplas (") ou aspas simples ('). A
diferença é como a string é interpretada. Se uma string for delimitada por aspas duplas, as
variáveis na string serão expandidas. Você poderá usar o caractere de barra invertida (\) nas
strings com aspas duplas para especificar caracteres especiais (seqüências de escape), como
mostrado na Tabela 2.1.
Tabela 2.1 As seqüências de escape nas strings com aspas duplas
Seqüência de caracteres Significado
\n nova linha
\r retorno automático
\t tabulação horizontal
\\ barra invertida
\” aspa dupla
\$ cifrão
As strings com aspas simples não expandem as variáveis internas. E mais, as
únicas seqüências de escape válidas nas strings com aspas simples são as seqüências de
escape de barra invertida (\\) e aspa simples (\'). Essas seqüências de escape permitem que
aspas simples e barras invertidas estejam presentes nas strings com aspas simples. Você
poderá concatenar as strings usando o operador ponto (.). A seção sobre os operadores, neste
capítulo, tem mais informações sobre esse procedimento. Parecidos com a linguagem de
programação C, os caracteres individuais em uma string podem ser acessados tratando a string
como um array de caracteres.
Listagem 5: Exemplos de string
<?php
$aStrl = "This is a simple string.";
print ("$aStrl<br>" );
$aStr2 = "Thatcher";
print( "$aStr2<br>" );
$aStr3 = "My name is $aStr2";
// $aStr3 = "My name is Thatcher"
print( "$aStr3<br>" );
$aStr4 = "My name is \$aStr2";
// $aStr4 = "My name is $aStr2"
print ( "$aStr4<br>" );
$aStr5 = ‘Don\’t evaluate $sStr2’;
// $aStr5 = "Don\’t evaluate $sStr2";
print ( "$aStr5<br>" );
// prints "My Name is Tatcher and my name is $sStr2"
print ("$aStr3"." And "."$aStr4" );

Em virtude da natureza vagamente digitada do PHP, as variáveis podem transitar

de um tipo para outro com base em seu contexto. Um número pode ser convertido
implicitamente em uma string quando usado com um operador de strings, ou uma string pode
ser convertida em um número para avaliar uma instrução numérica. Quando o PHP avalia uma
string para convertê-la em um número, usa as seguinte regras:
• Se a string começar com dados numéricos válidos, esses dados serão o valor usado.
• Se a string não começar com dados numéricos válidos, o valor será zero (0).
• Se os dados numéricos válidos contiverem qualquer caractere ., e ou E, o valor será um
tipo com ponto flutuante; do contrário, será um tipo inteiro.
Os dados numéricos válidos são um sinal opcional seguido de um ou mais dígitos,
um ponto decimal opcional e um expoente opcional. O expoente é “e” ou “E” seguido de um ou
mais dígitos.

Listagem 6: Exemplos de conversão de strings/números implícita

<?php
$aVar = 123;
print( "\$aVar = $aVar, type = " . gettype ( $aVar ) . "<br>" );

$aVar2 = $aVar . " implicitly converted to string";

print( "\$aVar2 = $aVar2, type = " . gettype( $aVar2 ) . "<br>" );

$aVar3 = $aVar2 + 1; // implicit cast to integer

print( "\$aVar3 = $aVar3, type = " . gettype( $aVar3 ) . "<br>" );

$aVar3 = $aVar2 * 1.1; // implicit cast to floating-point

print( "\$aVar3 = $aVar3, type = " . gettype( $aVar3 ) . "<br>" );

$aNotNumber = "abc";
$aVar4 = $aNotNumber * 1; // attempt to cast to number, returns 0
print( "\$aVar4 = $aVar4, type = " . gettype( $aVar4 ) . "<br>" );

$aIsNumber = "3 little pigs";

$aVar5 = $aIsNumber + 1; // casts $aIsNumber to integer 3
print( "\$aVar5 = $aVar5, type = " . gettype( $aVar5 ) . "<hr>"
?>
Arrays
Os arrays no PHP se comporiam como arrays indexados (vetores) e como tabelas
de hash (arrays associativos). O PHP também suporta arrays multidimensionais. Em virtude da
implementação exclusiva dos arrays no PHP, você poderá indexar os arrays
multidimensionais numericamente em uma dimensão e de modo associativo em outra.
Ainda, poderá criar arrays usando as funções list() ou array() ou
especificando explicitamente cada valor. A seção de referência no final deste livro documenta o
conjunto completo de funções de manipulação de arrays disponíveis.
As variáveis dos arrays com uma dimensão podem ser expandidas nas strings
exatamente como qualquer outra variável. Para os arrays multidimensionais, as chaves tem
que englobar a referência completa da variável. A seguinte listagem mostra exemplos dos
diferentes tipos de arrays.

Listagem 7: Como inicializar e usar os arrays

<?php
// Create a simple array explicitly
$a[0] = "Ryan";
$a[l] = "Scott";
$a[ ] = "Randal"; // implicitly assigned to index (key) 2,
$a[ ] = "Cherie" // implicitly assigned to index (key) 3
print ("$a[3], $a[2], $a[1], $a[0]<br>" );

// Create an associative array

$color["blue"] = "#0000FF";
$color["green"] = "#00FF00";
$color["red"] = "#FF0000";
print ( "The hex value for red is { $color[‘red’] } <br>" );

//Create the same associative array above, just

// do it more simply.
$color = array( "blue" => "#0000FF", "green" => "#00FF00", "red" =>
"#FF0000" );
print ( "The hex value for green is {$color[‘green’]} <br>" );

// Manually create a multi-dimensional array

$m[0][0] = "Zero Zero";
$m[0][1] = "Zero One";
print( "The value of \$m[0][1] is {$m[0][1]}<br>" );
//Manually create a multidimensional associative array
$counties["Idaho"][0] = "Ada";
$counties["Idaho"][1] = "Adams";
$counties["Idaho"][2] = "Bannoc";
$counties["Arizona"][0] = "Apache";
$counties["Arizona "][1] = "Cochise";
$counties["Arizona "][2] = "Coconino";
print ("\$counties[‘idaho’][0] = {$counties[‘idaho’][0]}<br>" );
?>

Variáveis e constantes
As variáveis do PHP são atribuídas pelo cifrão (S), seguido de seu nome.Todos os
nomes das variáveis levam em conta as letras maiúsculas e minúsculas. Os nomes de variáveis
válidos têm que começar com uma letra ou sublinhado seguido de um número de letras,
números ou sublinhados. Para os nomes das variáveis, uma letra é considerada como sendo a-
z, A-Z ou qualquer caractere ASCII na faixa 127255 (0x7f - 0xff).

Listagem 8: Exemplos de nomes de variáveis

<?php
$variable1 = "Ryan";
$variable2 = "Scott";
print ("$variable1, $variable2<br>");
$1variable; // nome de variável inválido
$_test // válido, começa com sublinhado
$testç // inválido, ç é ASCII 128

As variáveis podem ser atribuídas pelo valor ou pela referência. Quando uma
variável é atribuída pelo valor, o valor inteiro da expressão original é atribuído á variável de
destino. Depois da atribuição, a variável original é independente, portanto uma alteração em
uma variável não afetará a outra.
Quando uma variável é atribuída pela referência, a nova variável simplesmente
refere-se à variável original. As alterações feitas em qualquer variável serão refletidas na
outra. Para fazer uma atribuição pela referência, simplesmente anexe o símbolo ampersand (&)
ao nome da variável.

Listagem 9: As atribuições das variáveis

<?php
$variable1 = "Ryan";
$variable2 = $variable1; // assign by value
print( "$variable1, $variable2<br>" ) ; // prints "Ryan, Ryan"
$variable2 = "Scott";
print( "$variable1, $variable2<br>" ) ; // prints "Ryan, Scott"
$variable1 = &$variable1; // assign by reference
print( "$variable1, $variable3<br>" ) ; // prints "Ryan, Ryan"
$variable3 = "Katie";
print( "$variable1, $variable3<br>" ) ; // prints "Katie, Katie"
?>

Variáveis predefinidas
Além das variáveis definidas pelo usuário, o PHP fornece diversas variáveis
predefinidas para qualquer script no qual são executadas. A lista de variáveis disponível
depende do contexto do script (por exemplo, se estiver sendo executado de maneira
independente ou através de um servidor Web), da versão do PHP e do tipo do servidor Web (se
presente). Como a lista de variáveis predefinidas depende desses fatores, algumas variáveis
poderão não estar disponíveis em todos os casos. O PHP também gera variáveis para cookies e
formulários enviados através de POST ou GET.
As seguintes seções exibem um subconjunto de variáveis disponíveis ao se
executar o PHP4 no Apache 1.3.11. Use a função phpinfo() para listar as variáveis
disponíveis em seu ambiente de desenvolvimento. Você poderá encontrar um conjunto mais
completo de variáveis predefinidas na seção de referência no final deste livro. ATabela 2.2
mostra um subconjunto de variáveis de ambientes Apache; a Tabela 2.3 mostra um
subconjunto das variáveis-ambientes do sistema e a Tabela 2.4 mostra um subconjunto das
variáveis geradas pelo PHP. Os operadores aritméticos são mostrados na Tabela 2.5, os
operadores de bitwise na Tabela 2.6 e os operadores de comparação na Tabela 2.7. A Tabela
2.8 mostra os operadores de aumento/diminuição e a Tabela 2.9 exibe os operadores lógicos.
Finalmente, a Tabela 2.10 mostra os operadores de atribuição.
Tabela 2.2 Um subconjunto das variáveis-ambientes Apache
Variável Definição

HTTP_HOST O conteúdo do cabeçalho Host: enviado do browser, se

houver.
HTTP_USER_AGENT O conteúdo do cabeçalho User Agent: enviado do browser.
Esse cabeçalho indica o browser que solicitou a página
atual, como, por exemplo "Mozilla/4.0 (compatible; MSIE
5.01; Windows NT)".
REMOTE_ADDR O endereço IP do usuário que exibe a página atual.
SERVER_PROTOCOL O nome e a revisão do protocolo pelo qual a página foi
solicitada, como, por exemplo, HTTP/1.1.
GATEWAY_INTERFACE A revisão da especificação CGI usada pelo servidor,como,
por exemplo, CGI/1.1.

Tabela 2.4 Um subconjunto das variáveis geradas pelo PHP (continuação)

Variável Definição
HTTP_GET_VARS Um array associativo das variáveis
transmitidas para o script atual através do
método HTTP GET
HTTP_POST VARS Um array associativo das variáveis
transmitidas para o script atual através do
método HTTP POST

Tabela 2.5 Operadores aritméticos

Nom
+ adiç
- subt
* multi
/ divis
% mód
E Resultado
$A soma de $a e $b
$A diferença de $a e $b
$O produto de $a e $b
$O quociente de $a e $b
$O resto de $a dividido por $b

Tabela 2.3 Um subconjunto das variáveis-ambientes do sistema

 Definição Variável
HOSTNAME O nome do host do servidor.
HOSTTYPE O tipo do computador do servidor, como, por
exemplo, I386.
PATH A variável do caminho do servidor
OSTYPE O sistema operacional sendo executado no
servidor, como, por exemplo, Linux

Tabela 2.4 Um subconjunto das variáveis geradas pelo PHP

Variável Definição
PHP_SELF O nome de arquivo do script sendo executado
atualmente
HTTP_COOKIE VARS Um array associativo das variáveis
transmitidas para o script atual através dos
cookies HTTP

Tabela 2.6 Operadores de bitwise

Operador Nome Exemplo Resultado

& And $a & Sb Os bits definidos em $a e Sb são definidos

| Or $a | $b Os bits definidos em $a ou $b são definidos
^ Xor $a ^ $b Os bits definidos em Sa ou $b, mas não
ambos, são definidos
Not ~$a Os bits definidos anteriormente em $a não
~
são definidos e vice-versa
<< Deslocamento $a << $b Desloca os bits de $a para a esquerda pelas
para a
esquerda etapas $b
>> Deslocamento Sa >> $b Desloca os bits de $a para a direita pelas
para a
direita etapas $b

Tabela 2.7 Operadores de comparação

Operador Nome Exemplo Resultado
== Igual $a == Sb Verdadeiro se $a for igual a $b
=== Idêntico $a === $b Verdadeiro se $a for igual a $b e ambos forem
do mesmo tipo
!= Diferente Sa != $b Verdadeiro se $a for diferente de $b
< Menor quo $a < $b Verdadeiro se $a for menor que $b
> Maior que $a > $b Verdadeiro se $a for maior que $b
<= Menor que $a <= $b Verdadeiro se $a for menor que ou
ou igual a igual a $b
>= Maior ou $a >= $b Verdadeiro se $a for maior que ou
igual a igual a $b
 2.8 Operadores de aumento/diminuição
Operador/Exemplo Nome Resultado
$a++ Aumento posterior Retorna $a e então aumenta $a em um
++$a Aumento anterior Aumenta $a em um e então retorna $a
$a-- Diminuição posterior Retorna $a e então diminui $a em um
--$a Diminuição anterior Diminui $a em um e então retorna $a

Tabela 2.9 Operadores lógicos

Operador Nome Exemplo Resultado
and And $a and $b Verdadeiro se $a e $b forem verdadeiros
or Or $a or $b Verdadeiro se $a ou $b for verdadeiro
xor Xor $a xor $b Verdadeiro se $a ou $b for verdadeiro, mas não ambos
! Not !$a Verdadeiro se $a não for verdadeiro
&& And $a and $b Verdadeiro se $a e $b forem verdadeiros
|| Or $a or $b Verdadeiro se $a ou $b for verdadeiro

Tabela 2.10 Operadores de atribuição

Operador Exemplo Resultado
= $a = $b Atribui o valor de $b a $a
+= $a += $b Atribui o valor de ($a + $b) a $a. É idêntico a $a = $a + $b
-= $a -= $b Atribui o valor de ($a - $b) a $a. É idêntico a $a = $a - $b
*= $a *= $b Atribui o valor de ($a * $b) a $a. É idêntico a $a = $a * $b
/= $a /= $b Atribui o valor de ($a / $b) a $a. É idêntico a $a = $a / $b
.= $a.= $b Atribui o valor de ($a . $b) a $a. É idêntico a $a = $a . $b
%= $a %= $b Atribui o valor de ($a % $b) a $a. É idêntico a $a = $a%$b
|= $a |= Sb Atribui o valor de ($a|$b) a $a. É idêntico a $a = $a | $b
&= $a &= $b Atribui o valor de ($a & $b) a $a. É idêntico a $a = $a & $b
^= $a ^= $b Atribui o valor de ($a ^ $b) a $a. É idêntico a $a = $a ^ $b
<<= $a << $b Atribui o valor de ($a << $b) a $a. É idêntico a $a = $a<< $b
>>= $a >>= $b Atribui o valor de ($a >> $b) a $a. É idêntico a $a = $a » $b

Escopo da variável
Em geral, todas as variáveis PHP têm um único escopo. Esse escopo se estende
sobre os arquivos incluídos e requeridos. Nas funções definidas pelo usuário, o escopo da
função local é introduzido. As variáveis globais terão que ser declaradas como globais dentro de
uma função se forem usadas na mesma. Finalmente, o PHP suporta as variáveis estáticas nas
funções para permitir que as variáveis locais da função mantenham seus valores entre as
chamadas.
Escopo de uma variável é o termo técnico para as regras quando um nome
(digamos, uma variável ou uma função) têm o mesmo valor em dois lugares diferentes. Toda a
variável em PHP que esteja fora de uma função possui o escopo global e estende-o durante
toda uma "linha dada" da execução. Ou seja, se você atribuir a uma variável um determinado
valor no início de um script em PHP, seu valor se manterá durante o resto do script; e se não
for atribuído novamente outro valor, permanecerá o mesmo em toda a execução (exceto dentro
do corpo das funções). A atribuição de uma variável não afetará o valor das variáveis com o
mesmo nome em outros arquivos PHP nem não o nivelará em usos repetidos do mesmo
arquivo. Por exemplo, digamos que você tem dois arquivos, startup.php e
next_thing.php, que são visitados tipicamente nessa ordem por um usuário. Digamos
também que perto do topo do código do arquivo startup.php, você tem a linha: $username
= "Jane Q. User"; a qual é executada somente em determinadas situações. Agora, você
pode esperar que, após o ajuste da variável em startup.php, ela estaria pré-ajustada
também automaticamente quando o usuário tiver visitado next_thing.php, mas isto não
acontece. Cada vez que uma página PHP é executada, ele associa e reassocia variáveis
enquanto está sendo executado, e aquelas variáveis desaparecem no fim da execução da
página. As atribuições das variáveis em um arquivo não afetam variáveis do mesmo nome em
um arquivo diferente. Obviamente, há muitas situações em que você gostaria de segurar a
informação por mais tempo. Para casos deste tipo, existem outras soluções que veremos mais
tarde.

Listagem 10: Escopo da variável

<HTML>
<HEAD>
<?php
$username = “Jane Q. User”;
?>
</HEAD>
<BODY>
<?php
print(“$username<BR>”);
?>
</BODY>
</HTML>

Constantes
O PHP fornece várias constantes predefinidas e permite a definição de constantes
adicionais. Você poderá encontrar a lista completa de constantes predefinidas na seção de
referência no final deste livro. Para definir novas constantes, use a função define(). Note que as
constantes PHP não são macros do tipo C e, portanto. têm que ser valores escalares.

Listagem 11: Constantes

<?php
define("aString", "This is a string constant" );
define( "aNumber",1);
print( "There is ".aNumber." constant defined.<br>");
print("Its value is '" . aString."'<br>");
?>

Operadores e precedência dos operadores

O PHP fornece um conjunto de operadores que será muito familiar para os
programadores C/C++. As Tabelas 2.5 até 2.10 fornecem uma breve descrição dos operadores
disponíveis.
Há mais operadores além dos listados nas tabelas anteriores, mas eles são mais
difíceis de se colocar em categorias. O operador ternário, que é designado com ?:, está
disponível no PHP, assim como no C. A expressão $aValue = (expressão1) ? (expressão2) :
(expressão3); atribuirá o valor da expressão2 à variável $aValue se a expressão1 for avaliada
como verdadeira. Do contrário, a variável $aValue receberá o valor da expressão3.
O operador de execução é designado por crases ('), parecido com muitas
linguagens de programação do shell. As instruções nas crases são executadas no servidor e o
resultado pode ser transmitido para uma variável.
O PHP também suporta um operador de controle de erros. @. Quando esse
operador é prefixado a uma expressão no PHP, qualquer mensagem de erro que possa ser
gerada é omitida. O uso desse operador permitirá um tratamento de erros mais estruturado se
o recurso track_errors estiver ativado. Quando o recurso track_errors está ativado,
qualquer mensagem de erro omitida pelo operador @ é armazenada na variável global $php-
errormsg. Essa variável é sobrescrita em cada erro, portanto a variável deve ser verificada
assim que possível para assegurar que o erro seja devidamente tratado.

Listagem 12: Alguns exemplos de operador

<?php
$aNum1 = 1;
$aNum2 = 2;
$aVal = ( $aNum1 == $aNum2 ) ? "The values are equal" : "The values
are different";

print( "$aVal<br>" ); // prints "The values are different"

$aAval = (1 == "1")?"The values are equal" : "The values are
different";

print ( $aVal<br>" ) // prints "The values are equal"

$aVal = ( 1 === "1" )?"The values are identical" : "The values are not
identical";

print( "$aVal<br>" ); // prints "The values are not identical"

$aListing = 'ls -l'; // `ls' is on 'nix systems

$aFmtList = nl2br ($aListing);
print(<br>Directory Listing:<br><b>$aFmtList.</b><br>" );
?>
Controle do fluxo do programa
O PHP suporta instruções padrão de controle do fluxo, como as instruções de loop
if, while e for. Os programadores C reconhecerão a sintaxe de cada uma dessas
instruções. E mais, o PHP suporta duas funções para incluir os arquivos-fonte: include() e
require().

if, else, elseif

Um elemento de linguagem obviamente crítico, a instrução if controla o fluxo do
programa desviando as expressões condicionais.

Listagem 13: Exemplos de como usar if, else e elseif

<?php
if ( 1 < 2 )
print( "This will be printed.<br>" );
else
print("This will not he printed.<br>");
$aValue = 2;
if ($aValue==1)
// Use curly braces to delimit a statement block
// Only NEEDED for multiple statement blocks
print( "\$aValue == 1<br>" );
elseif ( $aValue == 2 ) {
print ("\$aValue==2<br>");
}
elseif ( $aValue == 3 ) {
print ("\$aValue==3<br>");
}
else {
print ("\$aValue is neither 1, 2 nor 3<br>");
}

while
O tipo mais simples de loop no PHP, o loop while comporta-se como no C e em
outras linguagens de alto nível.

do..while
Embora parecido com o loop while, o loop do..while verifica a condição do
loop depois da primeira execução das instruções de loop. Isto assegura que as instruções de
loop serão executadas pelo menos uma vez.

Listagem 14: Exemplos de como usar while e do..while

<?php
print("Contando usando o <b>while</b>.<br>");
$nIndex = 0;
while ($nIndex<10) {
print ("$nIndex<br>");
}
print("Contando regressivamente usando o <b>do..while</b>.<br>");
do {
print ("$nIndex<br>");
$nIndex--;
}while ($nIndex>0);
?>

for
O loop for é a instrução de loop mais complexa no PHP, mas é sintaticamente
equivalente à Instrução for da linguagem C. A sintaxe é a seguinte:

for(expr1; expr2; expr3) statement

A primeira expressão (exprl) é avaliada uma vez no início do loop. A segunda

(expr2) é avaliada no inicio de cada iteração no loop. Se for avaliada como verdadeira, o loop
continuará e a(s) instrução(ções) será(ão) executada(s). Se a segunda expressão for vazia, será
avaliada implicitamente como verdadeira. No final de cada iteração, a expressão três (expr3)
será avaliada. Qualquer uma das três expressões poderá estar vazia.

Listagem 15: Exemplos de como usar for

<?
for ($x = 1, $y = 1, $z = 1; //initial expressions
$y < 10, $z < 10; // termination checks
$x = $x + 1, $y = $y + 2, // loop-end expressions
$z = $z + 3)
print("$x, $y, $z<br>");
?>

Exibirá no navegador:
1, 1, 1
2, 3, 4
3, 5, 7

foreach
A instrução foreach é um mecanismo conveniente para fazer uma iteração nos
arrays. O Perl, o VBScript e outras linguagens suportam uma construção parecida. O PHP
suporta duas sintaxes:

foreach ($array_variable as $value_variable) {

// .. do something with the value in $value_variable
} // Note that this is an example template, not real PHP code

foreach ($array_variable as $key_var => $value_var) {

// .. do something with $key_var and/or $value_var
}

A primeira forma faz um loop no array dado (array_expr). Para cada iteração do
loop, o valor do elemento do array atual é atribuído à variável (value_varname) e o ponteiro
do array é avançado. A segunda forma faz o mesmo, mas atribui adicionalmente a chave do
elemento do array atual à variável key_varname.
switch
A instrução switch simplifica a avaliação de diversas condições. É geralmente
usada para substituir uma instrução if..elseif..else complexa quando o código contém
diversas ocorrências de elseif. A sintaxe e implementação da instrução switch no PHP é
igual no C. Uma ótima vantagem da implementação PHP é que você pode usar urna string
como a expressão switch. Para os programadores Delphi/Pascal, uma das coisas mais difíceis a
lembrar em uma instrução switch do tipo C é a instrução break. Às vezes, omitir a instrução
break em um switch é conveniente. Os seguintes exemplos mostram muitos usos comuns da
instrução switch.

switch(expression)
{
case value-1:
statement-1
statement-2
...
[break;]
case value-2:
statement-3
statement-4
...
[break;]
...
[default:
default-statement]
}

Listagem 17: Exemplos de como usar switch

switch($day)
{
case 5:print("Five golden rings<BR>");break;
case 4:print("Four calling birds<BR>");break;
case 3:print("Three French hens<BR>");break;
case 2:print("Two turtledoves<BR>");break;
default:print("A partridge in a pear tree<br>");
}

break
O comando break cancela a execução do comando for, foreach, while, do-while ou
switch atual.
O comando break aceita um argumento numérico opcional que diz a ele quantas
estruturas aninhadas englobadas devem ser quebradas.

Listagem 18: Exemplos de break

<?php
do {
// some code
if ($condition)
 break;
// some more code
} while (FALSE);
?>

ou

<?php
switch ($dummy) {
default:
// some code
if ($condition)
break;
// some more code
}
?>

continue
O comando continue é usado dentro de estruturas de loops para saltar o resto
da iteração do loop atual e continuar a execução na avaliação e no início da próxima iteração.
Nota: Note que no PHP a instrução switch é considerada uma estrutura de loop
quando relacionada ao comando continue.
O comando continue aceita um argumento numérico opcional que diz a ele de
quantos níveis de loops aninhados ele deve saltar até o fim.

Listagem 19: Uso do comando continue

<?php
while (list ($key, $value) = each ($arr)) {
if (!($key % 2)) { // pula itens pares
continue;
}
do_something_odd ($value);
}

$i = 0;
while ($i++ < 5) {
echo "Fora<br />\n";
while (1) {
echo "&nbsp;&nbsp;Meio<br />\n";
while (1) {
echo "&nbsp;&nbsp;Dentro<br />\n";
continue 3;
}
echo "Isto nunca será exibido.<br />\n";
}
echo "Nem isso.<br />\n";
}
?>

include e require
O PHP fornece dois mecanismos para incluir arquivos externos: include() e
require(). A instrução include() é uma função PHP comum; require() é uma
construção da linguagem especial e tem algumas restrições em seu uso. Em ambos os casos,
sempre que um arquivo é incluído usando qualquer uma das instruções, a análise sai do modo
PHP e vai para o modo HTML no início do arquivo de destino. O analista retoma o modo PHP no
final do arquivo. Isto significa que qualquer código no arquivo de destino que deve ser
executado como um script PHP terá que ser incluído nas tags inicial e final PHP válidas.
A função include() é avaliada sempre que encontrada e pode estar contida em
loops ou instruções condicionais. Isto significa que os arquivos podem ser incluídos
condicionalmente ou os grupos de arquivos podem ser incluídos usando um loop. A função
include() também permite que o arquivo de destino especifique um valor de retorno e possa
atribuir esse valor a uma variável. O processamento de um arquivo em uma instrução
include() terminará se uma instrução de retorno for encontrada.
A instrução require() é diferente da instrução include(), no sentido de que não
está sujeita a nenhuma estrutura de controle. Isto significa que os arquivos não podem ser
incluídos condicionalmente usando require(). A instrução será executada uma vez se
aparecer em um loop ou mesmo se aparecer em uma instrução condicional que seja avaliada
como falsa. Outra diferença é que um arquivo em uma instrução require() não retornará um
valor.Tentar retornar um valor em uma instrução require() causará um erro de análise.

Funções
O PHP suporta a criação de funções definidas pelo usuário. As funções não têm
que ser declaradas antes de serem referidas no PHP4. O PHP suporta os seguintes recursos em
relação às funções: nomes dafunção variáveis, número de argumentos variável, argumentos
defaults, argumentos transmitidos pe o valor e argumentos transmitidos pela referência. Em um
bloco da função, o PHP permite que qualquer código PHP seja executado, inclusive o código
que chama outras funções. Essa capacidade permite que o PHP forneça funções recursivas. O
PHP não suporia a sobrecarga de funções ou a capacidace de indefinir ou redefinir previamente
as funções definidas.
Por default, os argumentos são transmitidos para as funções pelo valor. Para
transmitir um valor pela referência, prefixe o nome da variável com um símbolo &. Ao se usar
argumentos defaults, qualquer argumento default terá que estar à direita de todos os
argumentos não defaults. Para obter listas de argumentos com comprimento variável, as
funções func_num_args(), func_get_arg() e func_get_args() estão disponíveis
para recuperar informações sobre os argumentos transmitidos. Os seguintes exemplos mostram
o uso geral das funções no PHP.

Listagem 20: Exemplos de fúnções definidas pelo usuário

<?php
// a basic function
function ReturnSum( $a, $b ) {
return $a + $b;
}

// passed by reference

function StringAppend( &$BaseString, $AddString ) {

// because it's passed by reference, the value
// of $BaseString will be changed outside the
// scope of this function
$BaseString.=$AddString;
}
?>