Desenvolvendo Web sites dinâmicos com o CodeIgniter

Use a estrutura MVC com CRUD para ganhar eficiência

Aprenda como codificar um Web site dinâmico rapidamente e eficientemente usando o CodeIgniter. Ao tirar proveito da estrutura e dos atalhos integrados do CodeIgniter, você escreverá os arquivos MVC necessários para criar, ler, atualizar e excluir itens (CRUD) de um banco de dados e para um banco de dados.

Kevin Howard Goldberg, CTO, imagistic

Kevin Howard GoldbegCom 20 anos de experiência na indústria de alta tecnologia, Kevin Howard Goldberg é um executivo de tecnologia, autor e consultor que reside em Westlake Village, Califórnia. Ele atualmente trabalha como CTO na imagistic, uma premiada companhia de tecnologia e marketing digital, que ele co-fundou em 1997. Especialista em desenvolvimento e tecnologia na Web, ele atua no Santa Monica College Computer Science Advisory Board e já exerceu altos cargos na Film Roman, Lionsgate e Philips Interactive Media. Ele é autor do livro XML: Visual QuickStart Guide (2ª Edição), (PeachPit Press, 2008). Ele pode ser contatado em http://kehogo.com/contact



04/Mar/2010

O CodeIgniter é uma estrutura livre de aplicativos da Web escrita em PHP. Ela pode ser utilizada com muitos aplicativos de bancos de dados, incluindo MySQL, DB2® Express-C e outros. A estrutura usa o padrão de design MVC, cujo objetivo primário é separar os dados e as camadas de apresentação de um aplicativo de software. No padrão Model-View-Controller (MVC), o modelo gerencia a camada de dados, comunicando-se com o banco de dados; a visualização gerencia a camada de apresentação, exibindo a UI e o conteúdo; e o controlador gerencia a comunicação entre as visualizações e os modelos.

Acrônimos usados frequentemente

  • CRUD: Create, Read, Update, Delete
  • HTML: Hypertext Markup Language
  • MVC: Model-View-Controller
  • SQL: Structured Query Language
  • UI: User interface

Este artigo delineia as etapas necessárias para criar as bases de um Web site ou aplicativo dinâmico usando o CodeIgniter. Ele presume que você tenha instalado o CodeIgniter V1.7.2 ou mais recente e o MySQL V4.1 ou mais recente, e que tenha uma familiaridade básica com ambos. Se não tiver experiência com o CodeIgniter ou precisar de uma rápida recapitulação, consulte Recursos.

Bases do site: Widgets e CRUD

Obviamente, os sites mais dinâmicos serão diferentes dos exemplos usados neste artigo — na maioria dos casos, significativamente diferentes. Porém, todos os Web sites dinâmicos têm duas características cruciais em comum: um banco de dados e algo recuperado (dinamicamente) desse banco de dados. Com o intuito de generalizar esta discussão, chamarei esse "algo" dinamicamente recuperado de widget. Um widget pode ser quase qualquer coisa — um livro à venda, uma receita, um texto de blog ou um release. Não importa o que o widget seja, sua definição requer um conjunto consiste de informações. Por exemplo, o conjunto de informações necessário para uma receita pode incluir um título, ingredientes, instruções e uma análise nutricional.

Para recuperar o widget do banco de dados, primeiro é preciso criá-lo (então ele pode ser atualizado ou até excluído). É aí que entra o CRUD. O CRUD representa as quatro operações primárias necessárias para gerenciar widgets em um banco de dados; junto com o próprio widget, elas formam as bases para qualquer Web site dinâmico.


Configurando o banco de dados

Para este artigo, criaremos um aplicativo da Web para gerenciar as informações de contato para um grupo de estudantes e seus pais, como as crianças de uma equipe de esportes, um grupo da ACM ou uma turma de escola, que é o exemplo que criaremos aqui.

Para começar, crie o modelo de dados para o widget. O conjunto de informações necessário para esse widget é:

  • Nome do estudante
  • Nome dos pais
  • Endereço
  • Cidade
  • Estado
  • CEP
  • Telefone
  • E-mail

Para armazenar esse widget, crie uma tabela chamada student com os campos correspondendo ao conjunto de informações identificadas na lista acima. Um script de banco de dados MySQL e de criação de tabela é mostrado na Listagem 1.

Listagem 1. Script de banco de dados MySQL e de criação de tabela
CREATE DATABASE classroom;

USE classroom;

CREATE TABLE IF NOT EXISTS `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `s_name` varchar(64) DEFAULT NULL,
  `p_name` varchar(64) DEFAULT NULL,
  `address` varchar(128) DEFAULT NULL,
  `city` varchar(32) DEFAULT NULL,
  `state` char(2) DEFAULT NULL,
  `zip` char(10) DEFAULT NULL,
  `phone` char(20) DEFAULT NULL,
  `email` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Configuração inicial do CodeIgniter

Após ter criado o banco de dados e a tabela, configure as variáveis do banco de dados do CodeIgniter em .\system\application\config\database.php e da URL base em .\system\application\config\config.php. Para os propósitos deste artigo, eu presumo que a URL base seja http://127.0.0.1/codeigniter/.

Um controlador e uma visualização padrão

Em seguida, crie um controlador e visualização padrão. (Quando eles estiverem prontos, será possível ver os efeitos de qualquer código que escrevermos.) Para este projeto, crie um controlador chamado student.php na pasta .\system\application\controllers\, como mostrado na Listagem 2, e o defina como o controlador padrão em .\system\application\config\routes.php.

Listagem 2. O controlador padrão: Student
<?php

class Student extends Controller {

  function Student()
  {
    parent::Controller();  
  }
  
  function index()
  {
    // display information for the view
    $data['title'] = "Classroom: Home Page";
    $data['headline'] = "Welcome to the Classroom Management System";
    $data['include'] = 'student_index';

    $this->load->view('template', $data);
  }
}

/* End of file student.php */
/* Location: ./system/application/controllers/student.php */

Observe que a função index() cria um array chamado data que contém três índices nomeados: title, headline e include. Esse array é transmitido à visualização chamada template, armazenada como template.php (consulte a Listagem 3) na pasta .\system\application\views\.

Listagem 3. A visualização padrão: template.php
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<title><?php echo $title;?></title>
</head>
<body>

<h1><?php echo $headline;?></h1>

<?php $this->load->view($include);?>

</body>
</html>

Essa visualização será o shell do HTML ou o wrapper visual de todas as páginas no Web site. Ela contém uma configuração HTML padrão e espera três valores do controlador —title, headline e include— que correspondem ao título da página, a manchete da página e um arquivo de visualização a ser incluído para exibição de conteúdo, respectivamente.

Esse arquivo de visualização incluído é a última etapa da configuração inicial. Nomeie o arquivo como student_index.php, como declarado no template.php (Listagem 2 acima), e o armazene na pasta .\system\application\views\. A Listagem 4 fornece o código de origem.

Listagem 4. Um texto básico de "Olá Mundo"
<p>Congratulations. Your initial setup is complete!</p>

Observe que não há tags de estrutura HTML padrão. Isso ocorre porque o student_index.php é incluído através da visualização template.php e é, portanto, parte do wrapper e da exibição HTML da visualização.

Agora, se navegarmos para http://127.0.0.1/codeigniter/, o navegador carrega a página com o título dela, a manchete de boas-vindas e uma mensagem de parabéns.


As quatro operações CRUD

Vejamos o aplicativo da Web em termos de operações CRUD.

Criando widgets

Agora que a configuração inicial está completa, é necessário escrever o código que gerencia os widgets. Comece com a primeira das quatro operações CRUD: create. Esse código deve salvar a entrada do usuário como um widget no banco de dados.

Comece criando um formulário HTML com campos que correspondem à estrutura da tabela de estudantes. Crie um arquivo de visualização chamado student_add.php na pasta .\system\application\views\, como mostrado na Listagem 5.

Listagem 5. Gerando campos de formulários HTML para a operação create
<?php 

echo form_open('student/create');

// an array of the fields in the student table
$field_array = array('s_name','p_name','address','city','state','zip','phone','email');
foreach($field_array as $field)
{
  echo '<p>' . $field;
  echo form_input(array('name' => $field)) . '</p>';
}

// not setting the value attribute omits the submit from the $_POST array
echo form_submit('', 'Add'); 

echo form_close();

?>

Há duas observações a serem feitas sobre esse arquivo. A primeira é que ele usa a função form_input(). Essa função é parte do CodeIgniter Form Helper e é uma maneira rápida de gerar o HTML necessário para a maioria dos formulários. Ela recebe três argumentos: nome de campo, valor de campo e qualquer dado adicional (como JavaScript).

Atalhos do CodeIgniter

Quando inicio ou crio o protótipo de um projeto, eu uso o maior número possível de "atalhos" integrados que o CodeIgniter oferece (como a classe HTML Table e os arquivos de Form e URL Helper) para diminuir o tempo gasto com codificação e depuração. É claro, esses benefícios vêm às custas de um controle mais refinado do layout e da aparência, mas nesses estágios iniciais, a funcionalidade deve ser mais importante que a aparência.

A segunda observação é que a função form_submit(), que recebe os mesmos três argumentos, possui uma cadeia de caractere vazia para o nome do campo. Isso impede que o campo de envio seja parte do array de postagem de formulário. O modelo usa esse array quando adiciona o registro ao banco de dados; se o campo submit fosse incluído, o banco de dados falharia.

Depois precisamos adicionar uma função ao controlador Student (Listagem 6) para poder ver o formulário HTML.

Listagem 6. A função add() para o controlador Student
  function add()
  {
    $this->load->helper('form');
    
    // display information for the view
    $data['title'] = "Classroom: Add Student";
    $data['headline'] = "Add a New Student";
    $data['include'] = 'student_add';

    $this->load->view('template', $data);
  }

Observe que essa função carrega o CodeIgniter Form Helper para ser usado pela visualização student_add.php.

Agora, se navegarmos para http://127.0.0.1/codeigniter/index.php/student/add, o navegador carregará o formulário HTML com campos que representam um registro na tabela de estudantes. Se enviarmos o formulário, receberemos um erro porque ainda não criamos uma função para receber a postagem do formulário. Para fazer isso, adicione a função create() ao controlador Student, mostrado na Listagem 7.

Listagem 7. A função create() para o controlador Student
  function create()
  {
    $this->load->helper('url');
    
    $this->load->model('MStudent','',TRUE);
    $this->MStudent->addStudent($_POST);
    redirect('student/add','refresh');
  }

Essa função, que corresponde à URL http://127.0.0.1/codeigniter/index.php/student/create, primeiro carrega um modelo chamado MStudent, que criaremos na próxima etapa. Ela então executa a função addStudent(), transmitindo o array post criado na página student_add.php. Finalmente, ela redireciona o usuário de volta à página student_add.php usando a função redirect(), que é parte do arquivo de URL Helper.

O modelo MStudent é responsável pela interação com a tabela de estudantes no banco de dados. Na pasta .\system\application\models, crie um arquivo chamado mstudent.php (é uma boa prática adicionar um prefixo ou sufixo ao nome do arquivo, indicando que o arquivo é um modelo; essa é a razão da presença do m). Seu código é mostrado na Listagem 8.

Listagem 8. O modelo MStudent responsável pela camada de dados
<?php 

class MStudent extends Model{

  // Create student record in database
  function addStudent($data)
  {
    $this->db->insert('student', $data);
  }

}

/* End of file mstudent.php */
/* Location: ./system/application/models/mstudent.php */

Esse modelo usa a função db->insert() para inserir os dados do array de postagem na tabela de estudante. A função recebe dois argumentos. o nome da tabela e um array associativo de nomes e valores de campo. Essa função é parte da classe Active Record do CodeIgniter, que é automaticamente carregada, e é um dos atalhos que o CodeIgniter oferece para diminuir o tempo de desenvolvimento.

Além disso, como foi observado, se o array post incluísse o botão Submit como campo, a inserção falharia porque não haveria um campo na tabela chamado submit.

Navegue novamente para http://127.0.0.1/codeigniter/index.php/student/add. Desta vez, insira alguns dados nos campos e clique em Submit. A página será atualizada e os campos serão esvaziados. Mas se verificarmos o banco de dados, veremos que os dados enviados foram adicionados à tabela de estudantes.

Recuperando widgets

A segunda operação CRUD é read: O código simplesmente precisa ler registros de widget do banco de dados. É claro, também é comum exibir esses registros; é por isso que muitas pessoas se referem a essa operação como retrieve.

Comece atualizando o modelo MStudent com uma função para recuperar os registros da tabela de estudantes, como mostrado na Listagem 9.

Listagem 9. Função MStudent para recuperar registros de estudantes
  // Retrieve all student records
  function listStudents()
  {
    return $this->db->get('student');
  }

Esse código usa a função db->get(), também parte da classe Active Record do CodeIgniter, para gerar um SELECT * contra a tabela nomeada no argumento da função (student).

Em seguida, adicione a função ao controlador Student chamado listing() que carrega o modelo MStudent e executa a função listStudents(), como mostrado na Listagem 10.

Listagem 10. Criando uma tabela HTML para exibir os registros de estudantes
  function listing()
  {
    $this->load->library('table');
    
    $this->load->model('MStudent','',TRUE);
    $students_qry = $this->MStudent->listStudents();

    // generate HTML table from query results
    $students_table = $this->table->generate($students_qry);
    
    // display information for the view
    $data['title'] = "Classroom: Student Listing";
    $data['headline'] = "Student Listing";
    $data['include'] = 'student_listing';

    $data['data_table'] = $students_table;

    $this->load->view('template', $data);
  }

Essa função usa a função table->generate(), um atalho do CodeIgniter, na classe HTML Table. Ela gera uma tabela HTML com nomes de campo (do objeto de resultado de consulta) como uma linha de cabeçalho, e então cada registro relacionado subsequentemente. Seu resultado é transmitido à visualização de modelo no array de dados.

Finalmente, uma visualização é necessária para exibir essa tabela HTML. Crie um arquivo chamado student_listing.php na pasta .\system\application\views\, como mostrado na Listagem 11.

Listagem 11. Exibindo a tabela HTML
 <?php echo $data_table; ?>

Para ver os resultados dessa operação, visite http://127.0.0.1/codeigniter/index.php/student/listing. Lá é possível ver a lista de estudantes recuperada do banco de dados. Agora pare por um momento e adicione mais registros de estudantes, usando o formulário de entrada ou executando o script SQL mostrado na Listagem 12 para fazer o mesmo.

Listagem 12. Script SQL para adicionar registros de estudantes
INSERT INTO classroom.student 
	(id, s_name, p_name, address, city, state, zip, phone, email) 
	VALUES
(NULL, 'Peter Green', 'Len & Natalie Green', '480 West Broad Street', 
	'Eastbrook Canyon', 'PA', '19104', '(215) 900-2341', 
	'greenery@timewarner.dsl.com'),
(NULL, 'Jonah Ross', 'Robert & Linda Ross', '1293 Law Street', 
	'Eastbrook Village', 'PA', '19105', '(215) 907-1122', 'ross_boss@gmail.com'),
(NULL, 'Rebecca Dillon', 'Lainie and Howard Dillon', '12 Flamingo Drive', 
	'Westbrook Village', 'PA', '19103', '(215) 887-4313', 'ld_1975@yahoo.com'),
(NULL, 'Noah Singer', 'Carolyn & Peter Singer', '393 Green Lake Road, 8th Floor', 
	'Eastbrook Village', 'PA', '19105', '(215) 907-2344', 'candp@gmail.com'),
(NULL, 'Trevor Lee Logan', 'Steven Logan', '400 Green Lake Road, 9th Floor', 
	'Eastbrook Village', 'PA', '19105-6541', '(828) 299-9885', 
	'misterSAL@sbcglobal.net'),
(NULL, 'Audrey Christiansen', 'Lovey Christiansen', '1993 East Sunnyside Lane', 
	'Eastbrook Canyon', 'PA', '19104', '(215) 887-5545', 
	'lovey@christiansen-clan.com');

Antes de prosseguir para a próxima operação CRUD, para tornar a navegação do site mais fácil, adicione um conjunto de links de navegação global acima da tag <h1> no arquivo template.php na pasta .\system\application\views. Esse código é mostrado na Listagem 13.

Listagem 13. Links de navegação global
<div class="navigation">
<?php 
  // nav bar
  echo anchor('student/index', 'Home');
  echo (' | ');
  echo anchor('student/add', 'Add a New Student');
  echo (' | ');
  echo anchor('student/listing', 'List All Students');
?>
</div>

Esse código usa o atalho de função anchor(), que é parte do arquivo de URL Helper do CodeIgniter. E, devido ao fato de todas as funções no controlador Student tocarem a visualização de modelo, é necessário carregar o URL Helper como parte do construtor Student (consulte a Listagem 14). Também é necessário removê-lo da função create() para que o arquivo de Helper não seja carregado duas vezes.

Listagem 14. Carregando um ajudante em um construtor
  function __construct()
  {
    parent::Controller();

    // load helpers
    $this->load->helper('url');
  }

Atualizando widgets

Agora estamos prontos para a terceira operação CRUD: update. Para isso, o código deve:

  • Ler um registro de widget do banco de dados.
  • Exibir esse registro para edição.
  • Permitir que o usuário envie as informações atualizadas de volta ao banco de dados.

Comece atualizando a lista de estudantes para que ela inclua a opção Edit em cada linha. Ainda é possível usar a classe HTML Table para gerar a maior parte do HTML necessário para a tabela. Porém, agora será necessário fazer o loop sobre o objeto de resultado de consulta do banco de dados explicitamente, para criar as linhas da tabela e adicionar a opção Edit; A atualização da função listing() no controlador Student é detalhado na Listagem 15.

Listagem 15. Usando a classe HTML Table para criar uma tabela
    // generate HTML table from query results
    $tmpl = array (
      'table_open' => '<table border="0" cellpadding="3" cellspacing="0">',
      'heading_row_start' => '<tr bgcolor="#66cc44">',
      'row_start' => '<tr bgcolor="#dddddd">' 
      );
    $this->table->set_template($tmpl); 
    
    $this->table->set_empty("&nbsp;"); 
  
    $this->table->set_heading('', 'Child Name', 'Parent Name', 'Address', 
        'City', 'State', 'Zip', 'Phone', 'Email');
  
    $table_row = array();
    foreach ($students_qry->result() as $student)
    {
      $table_row = NULL;
      $table_row[] = anchor('student/edit/' . $student->id, 'edit');
      $table_row[] = $student->s_name;
      $table_row[] = $student->p_name;
      $table_row[] = $student->address;
      $table_row[] = $student->city;
      $table_row[] = $student->state;
      $table_row[] = $student->zip;
      $table_row[] = $student->phone;
      $table_row[] = mailto($student->email);

      $this->table->add_row($table_row);
    }    

    $students_table = $this->table->generate();

Esse código atualizado tira proveito do maior controle de detalhes do HTML ao:

  • Incluir uma linha de cabeçalho com nomes de campos próprios e uma cor de fundo.
  • Não exibir o campo ID.
  • Adicionar uma cor de fundo em linhas alternadas.

Em seguida, adicione uma função ao controlador Student chamado edit(), que é para onde a opção Edit está apontando. O código é mostrado na Listagem 16.

Listagem 16. A função edit() para o controlador Student
  function edit()
  {
    $this->load->helper('form');

    $id = $this->uri->segment(3);
    $this->load->model('MStudent','',TRUE);
    $data['row'] = $this->MStudent->getStudent($id)->result();

    // display information for the view
    $data['title'] = "Classroom: Edit Student";
    $data['headline'] = "Edit Student Information";
    $data['include'] = 'student_edit';

    $this->load->view('template', $data);
  }

A opção Edit transmite o ID do registro de estudante como o terceiro segmento na URL (após o http://127.0.0.1/codeigniter/index.php/). A função uri->segment(3) (parte do arquivo URL Helper do CodeIgniter) analisa esse ID da URL e o transmite para uma função no modelo MStudent que recupera esse registro de estudante, como mostrado na Listagem 17.

Listagem 17. Recupera um registro de estudante do banco de dados
  // Retrieve one student record
  function getStudent($id)
  {
    return $this->db->get_where('student', array('id'=> $id));
  }

Então crie um formulário HTML chamado student_edit.php para exibir e editar esse registro de estudante, como mostrado na Listagem 18.

Listagem 18. Crie a visualização de formulário HTML para editar um estudante
<?php 

echo form_open('student/update');

echo form_hidden('id', $row[0]->id);

// an array of the fields in the student table
$field_array = array('s_name','p_name','address','city','state','zip','phone','email');
foreach($field_array as $field_name)
{
  echo '<p>' . $field_name;
  echo form_input($field_name, $row[0]->$field_name) . '</p>';
}

// not setting the value attribute omits the submit from the $_POST array
echo form_submit('', 'Update'); 

echo form_close();

?>

Observe que esse arquivo é quase idêntico ao student_add.php. Muitos desenvolvedores gostam de usar apenas uma construção de arquivo de adicionar/editar ao invés de manter dois arquivos distintos. No final das contas, essa é uma questão de estilo, e existem prós e contras em ambas as abordagens.

Em seguida, para receber a postagem de formulário, adicione a função update() ao controlador Student; o código é mostrado na Listagem 19.

Listagem 19. A função update() para o controlador Student
  function update()
  {
    $this->load->model('MStudent','',TRUE);
    $this->MStudent->updateStudent($_POST['id'], $_POST);
    redirect('student/listing','refresh');
  }

Finalmente, atualize o modelo MStudent com uma função para atualizar o registro de estudante no banco de dados. Essa função é mostrada na Listagem 20.

Listagem 20. Atualize um registro de estudante
  // Update one student record
  function updateStudent($id, $data)
  {
    $this->db->where('id', $id);
    $this->db->update('student', $data); 
  }

A operação de atualização foi concluída. É possível navegar até a listagem de estudantes, editar qualquer registro de estudante, enviar o formulário e ver as novas informações na lista de estudantes atualizada.

Excluindo widgets

A operação CRUD final é delete. Nessa operação, o usuário precisa ser capaz de selecionar um registro de uma lista e então excluir o registro. Também é desejável confirmar a intenção do usuário antes de excluir o registro (caso o usuário clique no link errado).

Comece substituindo o código que cria a opção Edit na função listing() do controlador Student pelo código na Listagem 21.

Listagem 21. Adicionando a opção Delete à lista de estudantes
      $table_row[] = '<nobr>' . 
        anchor('student/edit/' . $student->id, 'edit') . ' | ' .
        anchor('student/delete/' . $student->id, 'delete',
          "onClick=\" return confirm('Are you sure you want to '
            + 'delete the record for $student->s_name?')\"") .
        '</nobr>';

Em seguida, adicione uma função delete() ao controlador Student, que é para onde a opção Delete está apontando. O código é mostrado na Listagem 22.

Listagem 22. A função delete() para o controlador Student
  function delete()
  {
    $id = $this->uri->segment(3);
    
    $this->load->model('MStudent','',TRUE);
    $this->MStudent->deleteStudent($id);
    redirect('student/listing','refresh');
  }

Finalmente, atualize o modelo MStudent com uma função para excluir o registro. Essa função é mostrada na Listagem 23.

Listagem 23. Exclua um registro de estudante
  // Delete one student record
  function deleteStudent($id)
  {
    $this->db->where('id', $id);
    $this->db->delete('student'); 
  }

Agora faça um teste. Navegue até a listagem de estudantes e tente excluir um registro de estudante. Se você clicar em OK no prompt do JavaScript, a lista de estudantes será atualizada e mostrará que o registro foi excluído.


Conclusão

Parabéns! Você concluiu a base de um Web site dinâmico usando o CodeIgniter. O Web site possui uma separação muito clara entre a apresentação e as camadas de dados, pois ele usa o padrão MVC. E ao incluir os atalhos de codificação que o CodeIgniter torna disponíveis, o tempo de desenvolvimento foi acelerado e as linhas de código necessárias foram minimizadas. Na verdade, você percebeu que concluiu esse aplicativo usando apenas um controlador, um modelo e cinco visualizações? Essa é uma codificação bem eficiente.


Downloads

DescriçãoNomeTamanho
Full code base, including CodeIgniter filesos-codeigniter-classroom.zip2160KB
MVC files onlyos-codeigniter-MVC-files-only.zip5KB

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=471519
ArticleTitle=Desenvolvendo Web sites dinâmicos com o CodeIgniter
publish-date=03042010