Há poucos dias foi lançado na App Store o aplicativo (jogo) que desenvolvi recentemente: o Chicken Invaders.

Esse jogo é semelhante ao bom e velho Space Invaders, onde o objetivo é matar o maior número de invasores, ou galinhas, nesse caso. :)

Vejam o vídeo abaixo:

Baixem o jogo no link a seguir: http://itunes.apple.com/br/app/chicken-invaders/id516056571?mt=8

Abraços e boa diversão! :)

Programação multi-thread é considerada difícil em muitas linguagens, mas a SDK do iOS (do MacOS também) oferece uma forma extremamente simple de executar tarefas em thread distintas. Para isso, usem-se as classes NSOperation e NSOperationQueue.

Irei mostrar um exemplo simples, onde há duas abas com uma UITableView em cada uma. A primeira, chamada Single Thread, carregará dados para a TableView em apenas uma thread. A segunda, chamada Multi Thread, usará uma thread separada para carregar os mesmos dados. A fonte de dados é este arquivo texto, que possui 234975 linhas e 3,3 MB de tamanho em disco. Esse arquivo é o resultado de alguns comandos ls no sistema de arquivos.

Os dados são carregados assim que se pressiona o botão “Load” no topo da view. Optei por fazer assim para enfatizar o problema de usar só uma thread. Logo entenderão melhor.

A classe NSOperation é uma classe base para outras classes que podem ser inseridas na fila de execução (NSOperationQueue. Ou seja, se quiser executar tarefas em paralelo, você deverá criar uma subclasse de NSOperation. Como faremos um exemplo simples, podemos usar uma subclasse oferecida nativamente pela SDK, a classe NSInvocationOperation.

Vamos à prática!

Crie um novo projeto e adicione duas subclasses de UITableViewController. Nomeie-as como SingleThreadViewController e MultiThreadViewController (ou qualquer outro nome, se preferir).

Na storyboard (ou em XIB’s, se preferir), crie uma sequência de ViewController’s conforme mostra a imagem a seguir:

A estrutura é basicamente uma view raiz (TabViewController), ligada a duas TableViewController’s, cada um “embutido” em uma NavigationBarController. Em cada NavigationBar, insira o botão “Load”, que usaremos para carregar os dados. Não se esqueça de definir as classes das TableViewController’s e de fazer as conexões do DataSource e do Delegate das TableViews com SingleThreadViewController e MultiThreadViewController.

No arquivo SingleThreadViewController.h, insira um NSArray para armazenar os dados da table view e defina o cabeçalho da IBAction que será chamada ao pressionar o botão Load. O array não precisa ser uma propriedade pois não será acessado de fora da classe.

SingleThreadViewController.h

#import <UIKit/UIKit.h>
 
@interface SingleThreadViewController : UITableViewController
<UITableViewDelegate, UITableViewDataSource>
{
    // array que será usado como fonte de dados para a UITableView
    NSArray *arrayData;
}
 
// ação a ser executada ao clicar em "Load"
- (IBAction) loadData;
 
@end

Tendo criado a IBAction, lembre-se de conectá-la ao botão “Load”.

No arquivo SingleThreadViewController.m, implemente os métodos do DataSource da tableview e a ação loadData. Vou mostrar o código e explicar logo abaixo o funcionamento do método loadData, que é a única novidade para nós.

SingleThreadViewController.m

#import "SingleThreadViewController.h"
 
 
@implementation SingleThreadViewController
 
 
- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view.
 
    // aloca espaço para o array que receberá os dados
    arrayData = [[NSArray alloc] init];
}
 
- (void)viewDidUnload
{
    [super viewDidUnload];
    // Release any retained subviews of the main view.
}
 
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
    return (interfaceOrientation == UIInterfaceOrientationPortrait);
}
 
 
 
#pragma mark - UITableView Data Source Methods
 
- (NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return [arrayData count];
}
 
 
- (UITableViewCell *) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellId = @"bandCell";
 
    UITableViewCell *cell = [self.tableView dequeueReusableCellWithIdentifier:cellId];
 
    if ( cell == nil )
    {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellId];
    }
 
    cell.textLabel.text = [arrayData objectAtIndex:[indexPath row]];
 
    return cell;
}
 
 
#pragma mark - IBActions
 
- (IBAction) loadData
{
    NSString *url = @"http://rberaldo.com.br/tutoriais/concurrency-test/files.txt";
    NSURL *nsUrl = [NSURL URLWithString:url];
 
    NSString *strData = [NSString stringWithContentsOfURL:nsUrl
                                  encoding:NSUTF8StringEncoding
                                  error:nil];
 
    // remove o útlimo caracter, que é um \n
    strData = [strData substringToIndex:([strData length] - 1)];
 
    // divide a string pelo caracter \n
    arrayData = [strData componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]];
 
    // atualiza a tableview
    [self.tableView reloadData];
}
 
@end

No método viewDidLoad, devemos alocar memória para o array. Os métodos do DataSource da UITableView já foram citados em post antigo. Então vamos ao método loadData.

Primeiro, criamos uma string com a URL do arquivo fonte de dados. Em seguida, criamos um objeto NSURL com a URL definida acima. Em seguida, criamos uma string que armazenará o conteúdo total do arquivo. A fim de remover a última quebra de linha, pegamos uma substring da string original. Após isso, basta atribuir a arrayData o conteúdo desse arquivo, dividido pelo caractere “new line” (retiramos a última quebra de linha para que não seja criado um elemento vazio na última posição do array). Após isso, basta recarregar a table view, que agora já tem de onde obter os dados.

Neste ponto, já é possível executar o projeto no iOS Simulator e ver o (péssimo) resultado. Note que, ao pressionar “Load”, a interface fica travada, não sendo possível mover a table view ou selecionar a segunda aba da TabBar. Isso ocorre pois a requisição HTTP está sendo feita na mesma thread principal do aplicativo.

Vamos resolver esse problema programando a MultiThreadViewController adequadamente.

No arquivo MultiThreadViewController.h, crie o mesmo array da classe anterior e o mesmo cabeçalho da IBAction. Além disso, precisaremos de uma NSOperationQueue, que será usada para gerenciar a fila de operações multi thread.

MultiThreadViewController.h

#import <UIKit/UIKit.h>
 
@interface MultiThreadViewController : UITableViewController
<UITableViewDelegate, UITableViewDataSource>
{
    // array que será usado como fonte de dados para a UITableView
    NSArray *arrayData;
 
    // fila de operações executadas em background
    NSOperationQueue *queue;
}
 
 
// ação a ser executada ao clicar em "Load"
- (IBAction) loadData;
 
@end

Lembre-se de, novamente, conectar o botão Load com a IBAction.

O arquivo MultiThreadViewController.m ficará quase igual ao SingleTHreadViewController.m, apenas com algumas diferenças:

1. No método viewDidLoad, devemos alocar memória para nossa NSOperationQueue;
2. O método loadData apenas cria uma NSInvocationOperation, que chama o método que, de fato, carrega os dados no array;
3. O método loadDataInOperation é o método que, de fato, faz a requisição e preenche o array.

MultiThreadViewController.m

#import "MultiThreadViewController.h"
 
 
@implementation MultiThreadViewController
 
 
- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view.
 
    // aloca espaço para o array que receberá os dados
    arrayData = [[NSArray alloc] init];
 
    // aloca espaço para a fila de operações
    queue = [[NSOperationQueue alloc] init];
}
 
- (void)viewDidUnload
{
    [super viewDidUnload];
    // Release any retained subviews of the main view.
}
 
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
    return (interfaceOrientation == UIInterfaceOrientationPortrait);
}
 
 
 
 
#pragma mark - UITableView Data Source Methods
 
- (NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return [arrayData count];
}
 
 
- (UITableViewCell *) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellId = @"bandCell";
 
    UITableViewCell *cell = [self.tableView dequeueReusableCellWithIdentifier:cellId];
 
    if ( cell == nil )
    {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellId];
    }
 
    cell.textLabel.text = [arrayData objectAtIndex:[indexPath row]];
 
    return cell;
}
 
 
#pragma mark - Aux Methods
 
// método usado no NSOperation
- (void) loadDataInOperation
{
    NSString *url = @"http://rberaldo.com.br/tutoriais/concurrency-test/files.txt";
    NSURL *nsUrl = [NSURL URLWithString:url];
 
    NSString *strData = [NSString stringWithContentsOfURL:nsUrl
                                                 encoding:NSUTF8StringEncoding
                                                    error:nil];
 
    // remove o útlimo caracter, que é um \n
    strData = [strData substringToIndex:([strData length] - 1)];
 
    // divide a string pelo caracter \n
    arrayData = [strData componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]];
 
    // atualiza a tableview
    [self.tableView performSelectorOnMainThread:@selector(reloadData)
                                     withObject:nil waitUntilDone:YES];
 
}
 
 
#pragma mark - IBActions
 
- (IBAction) loadData
{
    NSInvocationOperation *operation = [[NSInvocationOperation alloc]
                                        initWithTarget:self
                                        selector:@selector(loadDataInOperation)
                                        object:nil];
    [queue addOperation:operation];
}
 
@end

No método loadData, criamos um objeto da classe NSInvocationOperation, iniciando-o com uma chamada ao método loadDataInOperation, que está na mesma classe (self), sem lhe passar nenhum objeto como parâmetro (nil). Após criado o objeto, devemos inseri-lo na fila de operações.

O método loadDataInOperation é muito semelhante ao loadData da classe SingleThreadViewController, com apenas uma diferença: ao chamar o método reloadData da table view, devemos especificar que isso deve ser feito na thread principal.

Agora o aplicativo está completo. Pode executá-lo e fazer o carregamento dos dados na segunda aba (Multi Thread). Note que, mesmo após pressionar o botão Load, é possível mexer na view, movendo a table view ou mudando de aba. Isso mostra que a requisição está sendo feita fora da thread principal.

O código-fonte pode ser clonado a partir do GitHub aqui.

Abraços

Neste tutorial, mostrarei como carregar dados em uma TableView. Simplesmente isso, sem transição de telas, apenas exibição de dados e detecção da linha selecionada. O resultado final será o exibido pelas duas imagens abaixo:

Ao clicar em uma linha da TableView, será mostrado um alerta (UIAlertView) informando qual linha você selecionou.

Usarei o XCode 4.3.1, iOS SDK 5.1, Storyboards e ativarei o ARC (Automatic Referencing Count), que são as ferramentas mais recentes no momento da escrita deste tutorial, mas a lógica serve para qualquer versão anterior e, provavelmente, posterior.

Vamos colocar a mão na massa!

Crie um novo projeto, com um ViewController (subclasse de UIViewController) e uma storyboard (ou um XIB, caso não esteja usando storyboards). Chamarei a ViewController de ThingsViewController, pois exibirei dados da classe Thing, que criaremos a seguir. Na storyboard, adicione um ViewController e defina a sua classe como sendo a “ThingsViewController”, na aba “Identy Inspector”. Adicione uma TableView à ViewController adicionada anteriormente.

Crie uma nova classe Objective-C, subclasse de NSObject, chamando-a de Thing. Veja abaixo o cabeçalho e a implementação dessa classe:

Thing.h

@interface Thing : NSObject
 
@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) NSString *description;
 
- (Thing *) initWithName:(NSString *)n description:(NSString *)d;
 
@end

Thing.m

#import "Thing.h"
 
@implementation Thing
 
@synthesize name, description;
 
- (Thing *) initWithName:(NSString *)n description:(NSString *)d
{
    if ( ! [self init] )
    {
        return nil;
    }
 
    self.name = n;
    self.description = d;
 
    return self;
}
 
@end

Criamos duas propriedades: name e description, que armazenarão informações da nossa “coisa”. Também criamos um novo inicializador do objeto, que aceita como parâmetro as propriedades da classe.

No arquivo ThingsViewController.h, é necessário importar o arquivo Thing.h, além de criar uma propriedade para a nossa TableView e um array para armazenar as coisas que queremos mostrar na TableView. O array não precisa ser uma propriedades, pois não um IBOutlet e não precisa ser manipulado por outras classes. Lembre-se também de “adotar” (adopt) os protocolos UITableViewDelegate e UITableViewDataSource. O resultado será este:

ThingsViewController.h

#import
#import "Thing.h"
 
@interface ThingsViewController : UIViewController
{
    NSMutableArray *thingsArray;
}
 
@property (nonatomic, strong) IBOutlet UITableView *thingsTableView;
 
@end

O maior trabalho agora será no ThingsViewController.m. Lembre-se de fazer um “@synthsize” da propriedade thingsTableView:

@implementation ThingsViewController
 
@synthesize thingsTableView;
 
- (void)viewDidLoad
// ...

Antes de continuar a mexer na implementação da classe, abra novamente o arquivo de interface (o XIB ou a storyboard) e faça as conexões dos objetos:

1. Com a ThingViewController selecionada, no Connections Inspector, conecte o Outlet thingTableView à TableView.
2. Com a TableView selecionada, conecte seu Delegate e seu Data Source com a ThingViewController (ou File’s Owner, conforme a versão do XCode utilizada).

Agora vamos voltar ao ThingsViewController.m.

No método viewDidLoad, precisamos alocar memória para o array de coisas, criar coisas (instanciar objetos Thing) e adicioná-las ao array. O resultado será isto:

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view.
 
    // aloca espaço para o array de coisas
    thingsArray = [[NSMutableArray alloc] init];
 
    // cria os objectos da classe Thing e os adicicona ao array
    Thing *abacaxi = [[Thing alloc] initWithName:@"Abacaxi" description:@"Fruta amarela"];
    [thingsArray addObject:abacaxi];
 
    Thing *anta = [[Thing alloc] initWithName:@"Anta" description:@"Um animal inteligente ou uma pessoa burra"];
    [thingsArray addObject:anta];
 
    Thing *babaca = [[Thing alloc] initWithName:@"Babaca" description:@"Usuário Windows"];
    [thingsArray addObject:babaca];
 
    Thing *bolovo = [[Thing alloc] initWithName:@"Bolovo" description:@"Bolinho de carne e ovo"];
    [thingsArray addObject:bolovo];
 
    Thing *cachorra = [[Thing alloc] initWithName:@"Cachorra" description:@"Aquela sua vizinha"];
    [thingsArray addObject:cachorra];
 
    Thing *cobol = [[Thing alloc] initWithName:@"Cobol" description:@"Linguagem em que seu avô programava"];
    [thingsArray addObject:cobol];
 
    Thing *coisa = [[Thing alloc] initWithName:@"Coisa" description:@"Tudo o que você imaginar"];
    [thingsArray addObject:coisa];
 
    Thing *debilMental = [[Thing alloc] initWithName:@"Débil Mental" description:@"Música dos Mamonas Assassinas"];
    [thingsArray addObject:debilMental];
 
    Thing *estanho = [[Thing alloc] initWithName:@"Estanho" description:@"Metal de número atômico 50"];
    [thingsArray addObject:estanho];
 
    Thing *estranho = [[Thing alloc] initWithName:@"Estranho" description:@"Você, que está lendo isto"];
    [thingsArray addObject:estranho];
 
    Thing *feliz = [[Thing alloc] initWithName:@"Feliz" description:@"Você não está se sentindo assi agora"];
    [thingsArray addObject:feliz];
 
    Thing *girafa = [[Thing alloc] initWithName:@"Girafa" description:@"Um bicho da cor do abacaxi, citado acima"];
    [thingsArray addObject:girafa];
 
    Thing *google = [[Thing alloc] initWithName:@"Google" description:@"O Todo Poderoso"];
    [thingsArray addObject:google];
 
    Thing *horror = [[Thing alloc] initWithName:@"Horror" description:@"O último programa que você desenvolveu"];
    [thingsArray addObject:horror];
 
    Thing *idiota = [[Thing alloc] initWithName:@"Idiota" description:@"Seu vizinho"];
    [thingsArray addObject:idiota];
 
    Thing *java = [[Thing alloc] initWithName:@"Java" description:@"A linguagem mais chata da Galáxia"];
    [thingsArray addObject:java];
 
    Thing *jegue = [[Thing alloc] initWithName:@"Jegue" description:@"Também chamado de jumento"];
    [thingsArray addObject:jegue];
 
    Thing *jumento = [[Thing alloc] initWithName:@"Jumento" description:@"Também chamado de jegue"];
    [thingsArray addObject:jumento];
 
    Thing *lontra = [[Thing alloc] initWithName:@"Lontra" description:@"Pteronura brasiliensis"];
    [thingsArray addObject:lontra];
 
    Thing *objectiveC = [[Thing alloc] initWithName:@"Objective-C" description:@"Sou eu!"];
    [thingsArray addObject:objectiveC];
 
    Thing *windows = [[Thing alloc] initWithName:@"Windows" description:@"O vírus mais famoso da Informática"];
    [thingsArray addObject:windows];
}

Agora que já temos o array cheio de dados, precisamos implementar os métodos dos protocolos UITableViewDataSource, para informar a fonte dos dados e os métodos do protocolo UITableViewDelegate, para manipular a seleção das células.

Do protocolo UITableViewDataSource, precisamos implementar pelo menos estes dois métodos:

- (NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section

Esse método informa o número de linhas (células) da TableView.

- (UITableViewCell *) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath

Esse método define os dados para cada célula da TableView.

O método numberOfRowsInSection será simples. Como nossa tableview só tem uma seção, basta retornarmos o número de elementos do array de coisas:

- (NSInteger) tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return [thingsArray count];
}

O método cellForRowAtIndexPath dará um pouco mais de trabalho, mas nada assustador. Precisamos criar a célula (caso ela ainda não exista) e definir os dados exibidos por ela. Vou mostrar o código final desse método e explicar melhor logo abaixo:

- (UITableViewCell *) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellID = @"thingCell";
 
    UITableViewCell *cell = [self.thingsTableView dequeueReusableCellWithIdentifier:cellID];
 
    if ( cell == nil )
    {
        // Com StyleDefault, aparece só o título, sem a descrição
        //cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellID];
 
        // Com StyleSubtitle, são mostrados título e descrição
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:cellID];
    }
 
    Thing *thing = [thingsArray objectAtIndex:[indexPath row]];
    cell.textLabel.text = [thing name];
    cell.detailTextLabel.text = [thing description];
 
    // Adiciona imagem à célula
    //cell.imageView.image = [UIImage imageNamed:@"imagem.png"];
 
    return cell;
}

As células têm um identificador, que deve ser sempre o mesmo. Por isso criaremos uma variável “cellID” para definir esse valor (ela será definida como static pois só precisa ser inicializada uma vez).

Antes de alocar memória para uma nova célula, usamos o método dequeueReusableCellWithIdentifier, da tableview, para tentarmos pegar uma célula já utilizada pela sistema. Fazemos isso pois, ao rolarmos a tela para baixo, o sistema pode usar as células que foram ocultadas para exibir novos dados. Isso economiza memória. Caso esse método retorne nil, precisamos alocar memória para uma nova célula. Iniciamos a célula com o seu estilo. O estilo Default só mostra o título. O estilo Subtitle mostra título e descrição abaixo. Existem também os estilos Value1 e Value2. Teste-os e veja o resultado. :)

Tendo a célula alocada e pronta para uso, precisamos obter os dados para serem exibidos nela. O parâmetro indexPath contém, dentre outros dados, o número da linha que está sendo exibida. Com esse número, obtemos o indice do array de dados, que é um objeto Thing. Após isso, preenchemos os dados da célula com eles.

Feito isso, você já pode testar o aplicativo. Os dados serão exibidos, mas não acontecerá nada ao selecionar um deles.

Agora vamos implementar a exibição do alerta ao selecionar ma linha. Para isso, devemos implementar um método do protocolo UITableViewDelegate: o método didSelectRowAtIndexPath. Veja sua implementação:

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    Thing *thing = [thingsArray objectAtIndex:[indexPath row]];
    NSString *msg = [NSString stringWithFormat:@"Você selecionou: %@", [thing name]];
 
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Seleção"
                                              message:msg
                                              delegate:nil
                                              cancelButtonTitle:@"Eu sei disso"
                                              otherButtonTitles:nil];
    [alert show];
 
    [self.thingsTableView deselectRowAtIndexPath:indexPath animated:YES];
}

O que fazemos é buscar o objeto da linha selecionada, da mesma forma como fizemos anteriormente, no método cellForRowAtIndexPath. Logo após, criaremos uma string com a mensagem a ser exibida ara o usuário. Em seguida, montamos o alerta (UIAlertView) e o exibimos com seu método show. Por fim, retiramos a seleção da célula, usando o método deselectRowAtIndexPath, da tableview.

Pronto. Basta compilar e testar novamente o aplicativo. Agora é possível selecionar as células e ver o alerta.

Você pode baixar o projeto completo aqui ou cloná-lo a partir do GitHub.

Abraços

O PHP 5.4 é praticamente o PHP 6 (não foi nomeado PHP 6 devido ao abandono de uma atualização, sobre Unicode, que foi deixada para mais tarde), com muitas novidades e mudanças.

O site oficial do PHP disponibiliza o ChangeLog, além de um Guia de Migração do PHP 5.3 para o 5.4, que apresenta as novas funcionalidades, os recursos considerados obsoletos e outros detalhes de migração.

Ainda não testei essa nova versão, por falta de tempo. Mas acredito que tenha sido um ótimo trabalho e que essa nova versão só trará benefícios, por restringir algumas funcionalidades que eram consideradas falhas de segurança, como register_globals e magic_quotes.

Como esse é um mercado promissor para programadores, resolvi entrar nessa dança. Optei por focar em iOS, inicialmente, pois é o sistema que uso diariamente e com o qual tenho mais contato e afinidade. Porém o Android também é uma plataforma que cresce bastante, com muitas ofertas de trabalho, assim como para iOS. Não entrarei no mérito da discussão de qual é melhor; nenhum é melhor. O usuário é quem deve optar por aquele que satisfaz melhor a suas necessidades.

Neste post, colocarei alguns links que me foram úteis quando eu iniciei meus estudos sobre a SDK do iOS. A maioria é em inglês – não há muitos materias em português -, mas para quem tem conhecimento intermediário nesse idioma consegue acompanhar até mesmo as vídeo-aulas que indico aqui.

Para quem ainda não sabe, a linguagem de programação usada no desenvolvimento de aplicativos para iOS (e para Mac OS X também) é Objective-C. No começo você se assusta um pouco com a sintaxe, que herda características do Smalltalk, mas logo se acostuma. Confesso que prefiro programar em Objective-C à programar em Java… :P

Existem ferramentas que lhe permitem usar outras técnicas para desenvolver aplicativos, como HTML 5. Há frameworks que dizem montar aplicativos que rodam tanto em iOS quanto em Android. A maioria deles cria interfaces WEB, semelhantes às interfaces nativas do sistema. Como o aplicativo final roda no navegador, ele não tem acesso a recursos como Câmera, Acelerômetro etc. Como nunca os usei, não falarei muito deles; apenas citarei que eles existem.

Vale ressaltar que, com a chegada do iOS 5, muitas coisas novas surgiram no desenvolvimento para essa plataforma. Novidades como o ARC (Automatic Reference Couting), que diminui – quase a zero – a responsabilidade do programador sobre o gerenciamento de memória, e as Storyboards, que facilitam muito a criação da interface gráfica e a transição entre Views, tornaram a programação para iOS ainda mais robusta e ágil.

Sem muito mais delongas, vamos aos links. Separarei os links em duas seções: links sobre Objective-C e sobre a SDK do iOS, ou Cocoa Touch.

Pretendo atualizar a lista conforme eu for encontrando novas boas referências para estudo. Quem quiser contribuir com outros links, basta adicioná-los nos comentários, que incluo no post.

Alguns links da documentação oficial da Apple talvez só estejam acessíveis para desenvolvedores cadastrados – o cadastro simples, gratuito, já é suficiente.

Objective-C

Documentação oficial da Apple:
https://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/introObjectiveC.html

Vídeo-aulas de Objective-C, do canal “MrAppleBR”, no Youtube (em português)
http://www.youtube.com/playlist?list=PL6B7343642EE37F97&feature=plcp

Vídeo-aulas da TheNewBoston:
http://thenewboston.org/list.php?cat=33

iOS SDK (Cocoa Touch)

Como criar uma conta de desenvolvedor e publicar aplicativos na App Store
Parte 1: http://www.raywenderlich.com/8003/how-to-submit-your-app-to-apple-from-no-account-to-app-store-part-1
Parte 2: http://www.raywenderlich.com/8045/how-to-submit-your-app-to-apple-from-no-account-to-app-store-part-2

Lista de tutoriais oficiais da Apple para iniciantes (Getting Started):
https://developer.apple.com/library/ios/navigation/index.html?section=Resource+Types&topic=Getting+Started

Oficial Apple: Start Developing iOS Apps Today
https://developer.apple.com/library/ios/#referencelibrary/GettingStarted/RoadMapiOS/Introduction/Introduction.html

Vídeos oficiais da Apple para iniciantes:
https://developer.apple.com/videos/ios

Vídeo-aulas da TheNewBoston:
http://thenewboston.org/list.php?cat=28

Mobile Tutorial (em português):
http://www.mobiletutorial.com.br

Vídeo-aulas sobre iOS SDK, do canal “MrAppleBR”, no Youtube (em português)
http://www.youtube.com/playlist?list=PL42EBDD0C4102729F&feature=plcp

HighOnCoding:
http://highoncoding.com/Categories/37_Mobile_Development.aspx

Canal “azamsharp” no Youtube (o mesmo do HighOnCoding):
http://www.youtube.com/azamsharp

Ray Wenderlich (Blog com tutoriais sobre programação iOS):
http://www.raywenderlich.com

Porém, uma coisa muito útil do Zend (e do CodeIgniter também, pelo que li) é a possibilidade de usar módulos, os quais permitem você dividir claramente sua aplicação em Área Administrativa, Área do Usuário e a interface pública. Ou seja, você poderia ter URLs como as apresentadas abaixo, podendo, dentro de cada módulo, usar seus controllers e actions:

http://www.seu_site.com/admin

http://www.seu_site.com/usuario

http://www.seu_site.com/

Após um pequeno tempo de pesquisa no Google, vi que o CakePHP não tem módulos. Alguns usam plugins para isso. Porém, existe uma forma de fazer isso nativamente no CakePHP, sem pugins nem outras complicações: prefixos.

O procedimento é extremamente simples e está descrito na documentação oficial, no link abaixo:

http://book.cakephp.org/1.3/view/950/Prefix-Routing

Em suma, basta editar a configuração “Routing.prefixes” em app/Config/core.php, e criar actions e views específicas para cada “módulo” (prefixo).

Suponde que queremos os prefixos “admin” e “user”, precisamos editar a linha citada no arquivo app/Config/core.php, deixando-a assim:

Configure::write( 'Routing.prefixes', array( 'admin', 'user ) );

Supondo que temos o controller Posts (PostsController.php), se quisermos ter uma ação “edit” para usuário e para admin, deveremos criar as actions admin_edit() e user_edit(). E para termos uma view para cada nível de usuário na edição, deveremos criar os arquivos admin_edit.ctp e user_edit.ctp, ambos em app/View/Posts.

Simples, não? :)

Até a próxima!

Abraços!

Garanto que muitos de vocês vão se identificar com o cidadão do vídeo, assim como eu me identifiquei. :)

Um bom exemplo é a página inicial do Google. Veja um trecho:

<!doctype html><html itemscope itemtype="http://schema.org/WebPage"><head><meta http-equiv="content-type" content="text/html; charset=UTF-8"><meta itemprop="image" content="/images/google_favicon_128.png"><title>Google</title><script>window.google={kEI:"NIQ2T6bFFJS5twfQx53FAg",getEI:function(a){var d;while(a&&!(a.getAttribute&&(d=a.getAttribute("eid"))))a=a.parentNode;return d||google.kEI},https:function(){return window.location

Isso reduz um pouco o tamanho das páginas, tornando seus carregamentos mais eficientes e rápidos. Mas também incomoda quem queira tirar ideias.

Para isso, existem alguns sites que formatam os códigos HTML, CSS e JavaScript, tornando-os legíveis.

Os dois que achei mais úteis e fáceis de usar são:

* JavaScript Beautifier (HTML e JavaScript): http://jsbeautifier.org
* Code Beautifier (CSS): http://www.codebeautifier.com

Há outras opções, mas, em uma busca rápida, esses foram os dois que mais me agradaram, por serem simples e fáceis de usar.

Caso conheçam alternativas melhores, postem-nas nos comentários. :)

Abraços

Recentemente comprei uma TV Full HD. Obviamente, usarei a TV como monitor para meu Desktop e para meu MacBook Pro. Ao ligar a saída de vídeo do MacBook na TV, eu não obtinha 1080p; em vez disso, ficavam duas faixas pretas laterais, como se não houvesse 1920 pixels de largura. Isso ocorria apenas no modo espelho; no modo estendido, a tela da TV era totalmente preenchida.

Uma solução que encontrei, buscando na Internet, foi manter a tampa do MacBook fechada e usar mouse e teclado externos, via USB ou Bluetooh. Dois problemas: 1) há risco de super aquecimento; 2) eu não podia usar o teclado nativo, nem o trackpad nativo (que acho um dos pontos mais fortes do MacBook, por ser multitouch), além de prejudicar o som dos alto-falantes e do microfone.

A solução que encontrei foi enganar o Mac, fazendo com que ele pense que a tampa está fechada. O truque é simples: imãs.

Antes de detalhar o truque, vale ressaltar que essa gambiarra é para usuários do Lion (Mac Os X 10.7). Quem usa o Snow Leopard (10.6) não precisa disso, pois, ao abrir a tampa do MacBook, estando com um monitor externo ligado, o monitor do MacBook continua desligado.

O Truque

O MacBook é cheio de imãs, alguns para “trancar” a tampa, impedindo que ela se abra sozinha, mas há um especial, responsável por detectar se a tampa está aberta ou fechada. No meu caso (MacBook Pro 13″ de 2011), esse imã está localizado do lado esquerdo e um pouco abaixo da tecla “fn”. Essa localização pode variar conforme o modelo do MacBook.

A gambiarra é colocar o imã sobre a localização citada acima e aguardar a tela do MacBook se desligar. Após isso, basta pressionar a tecla Power e a imagem sairá apenas no monitor externo. Após isso, pode retirar o imã, que tudo continua funcionando, inclusive o teclado e o trackpad do MacBook.

Este vídeo ilustra a ideia:

Essa técnica às vezes falha comigo, mas em poucas vezes. Creio que seja só uma questão de “pegar o jeito”. Ainda estou me especializando nessa técnica… :P

Espero que a dica seja útil a vocês! :)

Abraços 

— Editado

Isso só funcionou para mim no primeiro dia, quando fiz este post. Depois disso, ao retirar o imã, a tela do MacBook volta a ligar, e a TV deixa de exibir em 1080p.

Caso alguém tenha passado por isso e conseguiu resolver, deixe a dica nos comentários. :)

Inicialmente, eu separaria este texto em vários módulos. Porém, optei por faer algo mais sucinto e criar apenas este módulo – que complementa o Módulo #0, sobre os comandos básicos do Linux.

Neste módulo, serão abordados vários temas da programação em Shell (Bash), desde variáveis e funções, até expansões, expressões regulares etc.

Sem mais delongas, vamos ao que interessa! :)

Sumário

0. Scripts Shell
1. Variáveis
1.1 Variáveis de Ambiente
1.2. Variáveis Especiais
2. Controle de Fluxo
2.1. Condicionais
2.1.1. if
2.1.2. case
2.1.3. select
2.2. Estruturas de Repetição (Loops)
2.2.1. for
2.2.2. while
2.2.3. until…do
2.2.4. break
2.2.5. continue
3. Padrão C/C++ em Expressões “(())”
4. Entrada/Saída
4.1. Redirecionamento
4.2. Usando Pipelines
5. Expansões
5.1. Expansão de Variáveis
6. Parâmetros de linha de comando
7. Definindo Funções
7.1. Retorno de Funções
8. Expressões Regulares em Bash
9. Expressões Matemáticas
10. O Arquivo .bashrc
11. Aliases (Apelidos)
12. Referências

0. Scripts Shell

Antes de mostrar os recursos do shell, vamos dar uma olhada na maneira como devemos criar scripts shell. Isso facilitará a compreensão do restante do artigo.

Todo arquivo com códigos shell deve ter, na primeira linha, o identificador do interpretador a ser utilizado. A “linha mágica” que chama o interpretado bash é:

#!/bin/bash

O mesmo vale para outras linguagens interpretadas, como PHP, Python, Ruby, Perl etc.

Tendo essa linha no início do arquivo, o segundo passo é dar permissão de execução ao arquivo:

$ chmod +x script.sh
<pre>
 
Feito isso, basta executar o script:
 
<pre lang="bash">
$ ./script.sh

Também é possível executar o script usando o comando bash:

$ bash script.sh

Assim não é necessário haver a “linha mágica” no início do script. Também não é preciso dar permissão de execução ao arquivo.

1. Variáveis

O Bash, assim como muitas outras linguagens, possui o conceito de variável. Para definir uma variável:

nome_da_variavel="valor da variável"

É importante ressaltar que não deve haver espaços entre o símbolo de atribuição, o nome da variável e seu valor, para que o bash interprete o comando como atribuição, não chamada de comandos.

Para exibir o valor de uma variável, basta usar echo da seguinte forma:

echo $nome_da_variavel

1.1 Variáveis de Ambiente

As variáveis de ambiente são aquelas conhecidas pelos demais processos (programas em execução). Exemplos destas variáveis são: HOME, PATH, EDITOR, etc.

Para entender o seu uso, vejamos um exemplo: editores de texto, como Vi, possuem diferentes interfaces para os modos texto e gráfico e necessitam saber qual o tipo de terminal o usuário está usando. A variável de ambiente TERM é o modo pelo qual isto pode ser determinado. Outro exemplo são os programas de e-mail que permitem ao usuário editar mensagens com o editor de textos de sua preferência. Como estes programas sabem qual editor usar? É através da variável EDITOR ou VISUAL.

Qualquer variável pode se tornar uma variável de ambiente. Para isto, ela deve ser “exportada”, com o comando export:

export <variável>

Também podemos exportar e atribuir valores a uma variável numa única linha de comando:

export <variável>=<valor>

Podemos verificar quais são as variáveis de ambiente já definidas e seus respectivos valores usando o comando abaixo:

export -p

Para visualizar todas as variáveis basta usar set ou env. Uma importante variável de ambiente é PATH que ajuda o shell a encontrar os comandos que o usuário executa. Todo comando executado é, na realidade, um arquivo. Estes arquivos são chamados executáveis e estão armazenados em vários diretórios como /bin ou /usr/bin. O valor da variável PATH é uma lista de diretórios em que o shell procura toda vez que executamos um comando cujo arquivo não é encontrado no diretório corrente. Assim, não precisamos alterar o diretório de trabalho todas vez que necessitamos executar um comando que se encontra em outro diretório. Basta acrescentar o diretório que contém tal comando à variável PATH. Os nomes dos diretórios na variável são separados pelo caractere dois-pontos (:).

Caso o usuário joao queira adicionar um outro diretório, digamos /home/joao/bin à variável PATH, deve proceder como mostrado a seguir:

$ export PATH=$PATH:/home/joao/bin   # adiciona o diretório
$ echo $PATH                         # verifica
/bin:/usr/bin:/usr/local/bin:/home/joao/bin

O primeiro comando faz com que a variável receba o seu valor atual, concatenado com o nome do diretório a ser acrescentado. Observe que existe um “:” antes do nome do diretório. O segundo comando é utilizado apenas para visualizarmos o resultado do primeiro.

1.2. Variáveis Especiais

Existem algumas variáveis especiais, normalmente utilizadas em script shell, para verificação de parâmetros, valores de retorno de comandos e funções etc.

2. Controle de Fluxo

Controle de fluxo permite interromper, continuar e deslocar o fluxo de execução do script. Isso envolve controles de decisão (condicionais) e estruturas de repetição (loops).

2.1. Condicionais

2.1.1. if

Sintaxe:

if <condicao>
then
    comandos
elif <condicao_2>
    comandos 
else
    comandos 
fi

O if, ao contrário do que ocorre em muitas outras linguagens, testa o retorno de um comando, não uma expressão.

Por exemplo:

if test 5 -lt 7
then
    echo '5 é menor que 7'
fi

Porém, é possível posicionar a expressão entre colchetes, de forma a tornar o if mais parecido com o que acontece em outras linguagens:

if [ 5 -lt 7 ]
then
    echo '5 é menor que 7'
fi

O “-lt” significa “less than“, ou seja, “menor que“, equivalendo ao operador “<".

Outros possíveis operadores são:

Comparação Numérica
-lt: É menor que (LessThan)
-gt: É maior que (GreaterThan)
-le: É menor igual (LessEqual)
-ge: É maior igual (GreaterEqual)
-eq: É igual (EQual)
-ne: É diferente (NotEqual)

Comparação de Strings
=: É igual
!=: É diferente
-n: É não nula (não vazia)
-z: É nula (vazia)

Operadores Lógicos
!: NÃO lógico (NOT)
-a: E lógico (AND)
-o: OU lógico (OR)

Testes em arquivos
-b: É um dispositivo de bloco
-c: É um dispositivo de caractere
-d: É um diretório
-e: O arquivo existe
-f: É um arquivo normal
-g: O bit SGID está ativado
-G: O grupo do arquivo é o do usuário atual
-k: O sticky-bit está ativado
-L: O arquivo é um link simbólico
-O: O dono do arquivo é o usuário atual
-p: O arquivo é um named pipe
-r: O arquivo tem permissão de leitura
-s: O tamanho do arquivo é maior que zero
-S: O arquivo é um socket
-t: O descritor de arquivos N é um terminal
-u: O bit SUID está ativado
-w: O arquivo tem permissão de escrita
-x: O arquivo tem permissão de execução
-nt: O arquivo é mais recente (NewerThan)
-ot: O arquivo é mais antigo (OlderThan)
-ef: O arquivo é o mesmo (EqualFile)

2.1.2. case

Sintaxe:

case <string> in
    opcao1)
        comandos 
        ;;
    opcao2)
        comandos 
        ;;
    *)
        operação padrão
esac

Exemplo:

echo "Digite um número"
read x
 
case "$x" in 
    1)
        echo "Você digitou o número 1"
        ;;
    2)
        echo "Você digitou o número 2"
        ;;
    *)
        echo "Você digitou outro número"
esac

2.1.3. select

Sintaxe:

select <variavel> in <opcao1> <opcao2> ...
do 
    comandos 
done

O comando select é pouco utilizado, mas pode ser muito útil para montar menus. Esse comando exibe um menu, associando cada opção a um número. Quando o usuário seleciona o número da opção, o seu valor é associado à .

Exemplo:

select i in lista_arquivos lista_arquivos_tree
do
    case "$i" in 
        lista_arquivos)
            ls
            ;;
        lista_arquivos_tree)
            ls -R
            ;;
    esac
done

2.2. Estruturas de Repetição (Loops)

Loops são estruturas que permitem fazer iterações sobre algum dado.

2.2.1. for

Sintaxe:

for <var> in <lista>
do
    <comandos>
done

“var” é o nome da variável a ser usada no bloco de repetição. “lista” pode ser uma lista de dados, fixa ou retornada por outro comando (como o ls), uma sequência de números etc.

Exemplos:

Exibe uma sequência de números:

for i in 1 2 3 4 5
do
    echo $i
done

Lista os diretórios e arquivos da raiz do sistema de arquivos:

for i in $(ls /)
do
    echo $i
done

for i in $(seq 1 10)
do
    echo $i
done

for i in $(cat /etc/passwd)
do
    echo $i
done

2.2.2. while

Sintaxe:

while <condicao>
do
    <comandos>
done

Exemplos:

Exibe a sequência de 1 a 10:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Loop infinito que exibe “bash” na tela:

while true
do
    echo 'bash'
done

Lendo strings da entrada padrão:

while read i
do
    echo 'Voce digitou a string: ' $i
done

Exibe as linhas de um arquivo:

cat 'arquivo.txt' | while read i
do
    echo $i
done

Esse exemplo facilita o trabalho com arquivos de texto, cujas linhas possuem espaços. Se fosse usado um loop for nesse caso, seria necessário alterar a variável de ambiente IFS, definindo o separador para quebra de linha (\n).

Uma variação do exemplo anterior é esta:

while read i
do
    echo $i
done < arquivo.txt

A principal diferença entre estes dois últimos exemplos é que, no primeiro, o loop while é executado num subshell, devido ao uso do pipe (|). No segundo exemplo, o while é executado no shell corrente.

Para ilustrar o problema, crie um arquivo chamado “arq.txt” com algumas linhas de texto. Crie este script e execute-o:

#!/bin/bash
 
FILE='arq.txt'
 
total=0
cat $FILE | while read i
do
	total=$((total+1))
done
echo 'Total de linhas: ' $total
 
total=0
while read i
do
	total=$((total+1))
done < $FILE
echo 'Total de linhas: ' $total

O primeiro loop é executado num subshell, fazendo com que a variável “total”, usada no corpo do loop, existe apenas nesse subshell. No segundo caso, isso não ocorre. Isso pode gerar grandes dores de cabeça… (como já ocorreu comigo)

2.2.3. until…do

Sintaxe:

until <condicao>
do
    <comandos>
done

Nesse loop, a condição é oposta à usada no while. Por exemplo:

Com while:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Com unitl:

i=0
until [ $i -ge 10 ]
do
    echo $i
    i=$((i+1))
done

Para fazer a mesma coisa, tivemos que usar expressões diferentes na condição do loop.

2.2.4. break

O comando break encerra um loop imediatamente.

Exemplos:

i=0
while true
do
    if [ $i -ge 10 ]
    then
        break
    fi
    i=$((i+1))
done

while read i
do
    if [ $i -eq 0 ]
    then
        break
    fi
done

2.2.5. continue

O comando continue para a execução da iteração corrente e vai para a próxima iteração, mesmo que haja mais comandos no bloco de repetição.

3. Padrão C/C++ em Expressões “(())”

É possível usar o padrão C em expressões do shell, como em condicionais de estruturas de controle. Para isso, basta colocar a expressão entre dois parênteses.

Exemplos;

i=0
while (( i < 10 ))
do
    echo $i
    ((i++))
done

É possível, inclusive, usar o padrão do loop for do C:

for ((i = 0; i < 10; i++)
do
    echo $i
done

4. Entrada/Saída

Existem três dispositivos principais, que sempre estão abertos, que merecem destaque:

stdin (standard input): entrada padrão. Corresponde, em geral, ao teclado;
stdout (standard output): saída padrão. Corresponde, em geral, à tela do terminal;
stderr (standard error): saída padrão de erros. Corresponde, em geral, à tela do terminal, também.

Esses três dispositivos estão em /dev e estão sempre disponíveis. Quem programa em C, sabe muito bem disso, pois já deve ter usado stdin, stdout e stderr junto com fprintf, fread, fwrite e semelhantes; esses três dispositivos comportam-se como arquivos comuns, sempre abertos e que não devem ser fechados.
É possível brincar com eles no próprio shell. Experimentem dar um cat em /dev/stdin para ver o que acontece. :)

4.1. Redirecionamento

A entrada de um programa consiste nos dados que lhe são passados inicialmente, os quais são necessários para a execução do programa. A entrada de um programa pode vir do teclado ou de um arquivo, por exemplo. Argumentos passados à comandos constituem a sua entrada.
A saída é constituída pelas informações geradas pelo programa, ou seja, o resultado de sua execução. A saída pode ser mostrada na tela ou gravada em um arquivo de registro.

Muitos comandos do Linux têm sua entrada configurada para a entrada padrão e sua saída para a saída padrão. A entrada padrão é o teclado e a saída padrão é o monitor. Vejamos um exemplo usando o comando cat, que lê dados de todos os arquivos passados como parâmetros e os envia diretamente para a saída padrão. Usando o comando abaixo, veremos o conteúdo do arquivo “arq1″ seguido pelo conteúdo de “arq2″.

$ cat arq1 arq2

Entretanto, se nenhum nome de arquivo for dado como parâmetro, o comando cat lê dados da entrada padrão e os envia para a saída padrão. Para interromper, deve-se pressionar as teclas ctrl e d simultaneamente (ctrl+d).

$ cat 
Ola! Tem alguem ai?  # usuário 
Ola! Tem alguem ai?  # eco do sistema 
Ate mais!            # usuário 
Ate mais!            # eco do sistema
              # usuário pressiona ctrl+d

Como podemos ver, cada linha que o usuário digita é imediatamente ecoada pelo comando cat. Aqui um outro exemplo: o comando sort lê dados da entrada padrão – a menos que algum arquivo seja dado como parâmetro – e ordena os dados, enviando-os para a saída padrão:

$ sort 
bananas     # usuário
peras       # usuário
goiabas     # usuário
            # ctrl+d
bananas     # eco do sistema
goiabas     # eco do sistema
peras       # eco do sistema

Digamos que queremos enviar a saída do comando sort para um arquivo, gravando os dados digitados anteriormente. O shell nos permite redirecionar a saída para um arquivo usando o símbolo “>”.

$ sort > lista
bananas  # usuário
peras    # usuário
goiabas  # usuário
         # ctrl+d

Como se pode ver, o resultado do comando sort não é mostrado imediatamente após o se digitar ctrl+d. Ao invés disso, é salvo em um arquivo chamado “lista”. Vejamos o conteúdo desse arquivo:

$ cat lista
bananas
goiabas
peras

Com o redirecionamento de saída, temos uma maneira simples de criar arquivos de texto. Para isso, utilizamos o comando cat para ler a entrada padrão (teclado) e redirecionamos sua saída para um arquivo.

Ao usar “>” para redirecionar a saída para um arquivo, estamos realizando um redirecionamento destrutivo, ou seja, o comando “ls > lista” sobrescreve o conteúdo do arquivo “lista”. Isto é equivalente a dizer que todo o conteúdo anterior de “lista” é apagado.
Se, ao invés disso, redirecionarmos usando “>>”, a saída será concatenada ao final do arquivo e o conteúdo (se houver) de “lista” será preservado. Para melhor entender isso, experimente executar a seguinte seqüência de comandos:

ls >> listagem
ls >> listagem
less listagem

O redirecionamento neste exemplo, diferentemente do exemplo anterior, é denominado redirecionamento não-destrutivo.

4.2. Usando Pipelines

Nos exemplos para o filtro sort, os dados de entrada eram digitados pelo usuário ou estavam gravados em um arquivo. O que aconteceria se quiséssemos ordenar dados vindos do saída de outro comando ? Para listar os arquivos do diretório corrente em ordem alfabética invertida devemos fazer com que a saída do comando ls seja ordenada pelo comando sort. Usando a opção “-r”, este comando ordena os dados na ordem inversa.

$ ls
historia  notas     tese      testes 
$ ls > lista 
$ sort -r lista 
testes
tese
notas
lista                             # observe esse nome de arquivo
historia

Aqui, salvamos a saída do comando ls em um arquivo (lista) e usamos sort com a opção “-r”. Porém, isso faz com que tenhamos um arquivo temporário para armazenar os dados. Assim, toda vez que fizermos isso, teremos que, em seguida, remover o arquivo lista. A solução é usar o que chamamos de pipeline, outro recurso do shell que nos permite conectar vários comandos usando um pipe, onde a saída do primeiro comando é enviada diretamente à entrada do segundo e assim por diante no caso de haver mais de dois comandos conectados por pipes.

No nosso caso, queremos enviar a saída do comando ls para a entrada do comando sort. O símbolo “|” (barra vertical) é usado para criar um pipe:

$ ls | sort -r 
testes
tese
notas
historia

Note que neste exemplo, nenhum nome de arquivo é usado na linha de comando, diferentemente do exemplo anterior que fazia o uso do arquivo intermediário lista. Outra diferença é que o nome desse arquivo intermediário aparece no resultado do penúltimo exemplo, mas não neste último. O comando é mais curto, mais fácil de digitar e o resultado é mais adequado pois não inclui nomes de arquivos intermediários.

É importante observar que o redirecionamento e o uso de pipes são características do shell e não dos comandos em si. É o shell quem provê a sintaxe dos símbolos “>”, “<" e "|". Logo, se você criar um programa que utilize entrada de dados via stdin, poderá usar redirecionamento para especificar uma entrada para o seu programa.

5. Expansões

Expansões são caracteres, ou uma sequência deles, que expressa outro significado. O intuito disso é facilitar e padronizar comandos.

~: path à home do usuário corrente
~user: path à home do usuário “user”
{a,b,c}: presença do caractere “a”, “b” ou “c”. Podem ser usadas strings em vez de simplesmente caracteres.

Exemplos:

ls ~

ls ~root

ls /dev/std{in,out,err}

5.1. Expansão de Variáveis

6. Parâmetros de linha de comando

Assim como em outras linguagens, é possível passar parâmetros para scripts shell. Para isso, usam-se as variáveis $1, $2, … A variável $0 contém o comando chamado via linha de comando.

Exemplo:

Crie um arquivo “test.sh” com este conteúdo:

#!/bin/bash
 
echo '$0 = '$0
echo '$1 = '$1
echo '$2 = '$2

Veja as saídas das execuções abaixo:

$ ./test.sh 
$0 = ./test.sh
$1 = 
$2 = 
$ ./test.sh um
$0 = ./test.sh
$1 = um
$2 = 
$ ./test.sh um dois
$0 = ./test.sh
$1 = um
$2 = dois

7. Definindo Funções

Sintaxe:

function nome_da_funcao()
{
     <comandos>
}

Para chamar a função:

nome_da_funcao
 
# caso haja parâmetros
nome_da_funcao param1 param2 ...

Exemplo:

#!/bin/bash
 
function imprime()
{
	echo "Sou a função '${0}'"
	echo "Param 1: ${1}"
	echo "Param 2: ${2}"
	echo "Lista de parâmetros: ${*}"
}
 
imprime um dois tres quatro

Da mesma forma como foram usados $0, $1 etc anteriormente, aqui essas variáveis são usadas para retornar os parâmetros da função. Logo, percebe-se que, dentro de funções, não é possível acessar parâmetros de script, a menos que eles sejam passados por parâmetro para a função.

7.1. Retorno de Funções

Antes de tudo, é preciso diferenciar retorno de função e saída de função. Por exemplo, ao se executar o comando “cat /etc/passwd”, a saída é o conteúdo do arquivo; o retorno é 0 (ou outro valor, caso ocorra erro). O retorno de uma função shell é um valor inteiro, normalmente utilizado para definir o status da função, ou seja, se ocorreu algum erro ou e ela foi executada corretamente.

Para obter o valor de retorno de uma função, usa-se a variável “$?”. Ela exibe o retorno do último comando executado. Por exemplo:

$ cat /etc/passwd
echo $?

Para retornar valor (status) numa função, usa-se o comando return.

Exemplo:

#!/bin/bash
 
function retorna()
{
    echo "sou um valor"
    return 42
}
 
valor=$(retorna)
echo $?
echo $valor

Ao se executar a função, sua saída será “sou um valor”; seu retorno será 42.

Em shell, considera-se o valor 0 como execução bem sucedida. Qualquer outro valor representa erro. É por isso que recomenda-se que toda função main de um programa em C retorne o valor 0, desde que não ocorra algum erro.

8. Expressões Regulares em Bash

Expressões regulares em shell podem ser usadas em comparações (if’s), por exemplo. Em if’s, usa-se o operador “=~” para realizar comparações usando ER’s:

s="bash"
if [[ "$s" =~ ^b ]]
then
    echo 'começa com b'
fi

9. Expressões Matemáticas

O bash não trabalha com expressões matemáticas tão facilmente. Existe o comando “let”, que permite realizar expressões matemáticas, mas é mais comum se usar a sintaxe semelhante ao C, utilizando dois parênteses:

$ a=$((1 + 1))
$ ((i++))
$ x=$((x*2))
...

10. O Arquivo .bashrc

Na home dos usuários (~), é comum haver o arquivo .bashrc (o ponto no início indica que o arquivo é oculto). Esse arquivo é sempre executado quando se abre um shell. Nele, constam diversas configurações, como definição de variáveis de ambientes, definição de aliases etc. Você pode editar esse arquivo (ou criá-lo, caso não exista):

$ vim ~/.bashrc

É possível usar outros editores, não apenas o vim.

11. Aliases (Apelidos)

Algumas vezes usamos comandos que necessitam de várias opções e argumentos. Para amenizar o trabalho de digitarmos repetidamente estes comandos o bash oferece um recurso chamado alias com o qual podemos definir sinônimos ou “apelidos” para um comando. Um alias pode ser definido na linha de comando da seguinte forma:

alias <nome>=<comando>

Observe que não pode haver espaços em branco antes ou depois do “=”.

Esta sintaxe indica que nome é um “alias” (apelido) para comando. Toda vez que digitarmos o comando “nome”, o bash o substituirá por “comando”.

Exemplo:

$ alias lf='ls -F'

Isso fará o shell executar “ls -F” toda vez que usarmos “lf” na linha de comando. Ou seja, o que o alias faz na verdade é substituir a palavra “lf” por “ls -F”. Observe neste exemplo, existe um espaço em branco entre ls e -F. Sempre que houver espaços em branco na definição de um campo, todo o campo deve ser digitado entre aspas simples (‘) ou duplas (“).

É possível definir aliases em seu .bashrc, para que eles estejam sempre disponíveis na sua sessão.

12. Referências

Linux Básico:
http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico/ ou http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico.pdf

Linux Avançado

http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxAvancado.pdf

Canivete Suiço do Shell (Bash)

http://aurelio.net/shell/canivete/

Livro Shell Script Profissional (Livro físico):

http://www.shellscript.com.br/

Pretendo mostrar o básico sobre o Git, como criar repositórios, fazer commits, voltar para versão anterior (reverter). Além disso, citarei alguns links interessantes com mais conteúdo sobre Git.

É muito comum trabalhar com repositórios remotos, hospedados em servidores como o GitHub. Outra forma é trabalhar com um repositório local, quando estamos fazendo um trabalho de faculdade, desenvolvendo um software etc.

Vou mostrar como criar repositórios locais. Tutoriais sobre GitHub já existem aos montes pela Internet. O próprio site do GitHub já mostra como proceder para usar repositórios remotos.

Para iniciar um repositório local:

$ git init

Esse comando inicia um repositório no diretório corrente. Um diretório oculto, chamado .git, será criado com as informações do repositório.

A qualquer momento é possível executar o comando abaixo, que exibe o status do repositório, ou seja, mostra se há arquivos modificados, arquivos prontos para serem “commitados” etc:

$ git status

Para ver o log de commits, usa-se o comando:

$ git log

Para adicionar arquivos ao controle de versão:

$ git add arquivo1.txt arquivo2.txt [...]

Outra possibilidade é adicionar todos os arquivos do diretório atual:

$ git add .

Após adicionar um arquivo ao controle de versão, é necessário fazer o commit dele:

$ git commit -m "mensagem do commit" arquivo1.txt arquivo2.txt [...]

Também é possível usar a opção -a, que faz o commit de todos os arquivos que foram modificados em relação ao último commit:

$ git commit -a -m "mensagem do commit"

O Git é um sistema de controle de versão. Logo, é evidente que é possível desfazer mudanças. Se você percebeu que cometeu um erro em um arquivo commitado (ou um cliente odiou a última modificação que você fez no site dele :P ), é possível reverter o repositório para a versão anterior. Para isso, usa-se o comando:

$ git revert HEAD

Esse comando cria um novo commit, que ignora o último commit realizado, voltando o repositório à versão anterior ao commit problemático.

Para remover um arquivo do controle de versão:

$ git rm arquivo1.txt arquivo2.txt [...]

Lembrando que sempre é necessário fazer commit após adição ou remoção de arquivos do controle de versão:

Caso você tenha modificado um arquivo – sem dar commit nele – e deseja voltar à versão dele para a versão do commit mais recente, execute:

$ git reset --hard

Isso também vale para quando se remove um diretório e se deseja obtê-lo novamente do repositório.

Abaixo estão alguns links muito bons sobre Git, que me auxiliaram bastante quando comecei a mexer com esse sistema de controle de versão.

Git by examples
http://sysmonblog.co.uk/misc/git_by_example

Video-aula sobre git
http://vimeo.com/20299469

Git para quem conhece SVN
https://git.wiki.kernel.org/index.php/GitSvnCrashCourse

Documentação e Tutorial oficial do Git:
http://git-scm.com/documentation

E para aqueles que insistem em usar um “Sistema Operacional” de segunda linha… :P

Git no Windows
http://nathanj.github.com/gitguide/tour.html

Não adianta querer programar usando Shell sem conhecer os comandos básicos do Linux. Por isso o primeiro módulo do “curso” abordará os comandos básicos do Linux, que são fundamentais para a construção dos scripts.

Vamos analisar apenas alguns comandos, os mais conhecidos e usados, juntamente com algumas de suas opções. A maioria dos comandos permitem o uso de inúmeras opções, não sendo possível abordar todos elas neste texto.

Antes de iniciarmos, vale lembrar que os manuais de todos os comandos podem ser lidos usando o comando man nome_do_comando, por exemplo:

$ man echo

A maioria dos comandos também têm a opção -h, ou –help, que lista os parâmetros aceitos pelo programa.

Os comandos estão ordenados alfabeticamente, sem levar em consideração relevância ou complexidade de utilização.

Sumário

awk
cat
cd
chmod
cut
date
diff
echo
find
grep
head
kill
ls
printf
rev
scp
sed
seq
sort
ssh
tac
tail
top

awk

O AWK é uma linguagem de programação para processamento de textos. Ao lado do comando SED, é capaz de realizar muitos truques.

Um post exclusivo sobre AWK pode ser visto aqui:

http://www.rberaldo.com.br/blog/tutorial-awk

cat

Exibe o conteúdo de um arquivo.

Opções:
-n : numera as linhas

Exemplos:

$ cat /etc/hostname 
orion

$ cat -n /etc/hostname 
     1	orion

cd

Muda o diretório de trabalho, ou seja, entra em um determinado diretório.

Exemplo:

$ cd /tmp

$ cd ~

chmod

O chmod (change mode) muda as permissões de um arquivo ou diretório. O sistema de permissões em sistemas Unix-Like, como Linux ou Mac OS, é um dos pontos fortes desses sistemas. Porém, infelizmente, poucos usuários realmente sabem usá-lo.

Um post exclusivo ao chmod pode ser lido aqui:

http://www.rberaldo.com.br/blog/chmod-permissoes-em-sistemas-linux-e-unix-like

cut

Separa trechos ou campos de uma linha, por meio de um delimitador. Também trunca textos, exibindo apenas um número específico de caracteres.

Opções
-d : define o delimitador
-f : define o(s) campo(s) a ser(em) exibido(s)
-c : número do caractere a ser exibido ou intervalo de caracteres

Exemplos:

$ echo "um:dois:tres:quatro" | cut -d: -f 2
dois

$ echo "um:dois:tres:quatro" | cut -d: -f 2,3
dois:tres

Também é possível definir intervalo de valores para a opção -f:

$ echo "um:dois:tres:quatro" | cut -d: -f 1-3
um:dois:tres

$ echo "um:dois:tres:quatro" | cut -d: -f 2-
dois:tres:quatro

$ echo "1234567890" | cut -c 7
7

$ echo "1234567890" | cut -c 1,3,5
135

beraldo@orion:~$ echo "1234567890" | cut -c 1-7
1234567

$ echo "1234567890" | cut -c 8-
890

beraldo@orion:~$ echo "1234567890" | cut -c -5
12345

date

Mostra a data atual ou uma data específica, com diversas opções para formatação da data.

Opções:
-d : especifica a data (Ex: tomorrow, 5 days ago)
+%? : define o padrão de formatação da data. A lista de opções pode ser lida no manual do comando (man date).

Exemplos:

$ date
Dom Mai  1 20:05:47 BRT 2011

$ date -d "yesterday"
Sáb Abr 30 20:05:59 BRT 2011

$ date -d "2 days ago"
Sex Abr 29 20:06:10 BRT 2011

beraldo@orion:~$ date -d "2 days"
Ter Mai  3 20:06:13 BRT 2011

$ date +"%d/%m/%Y"
01/05/2011

$ date -d "30 days" +"Daqui 30 dias será %d/%m/%Y"
Daqui 30 dias será 31/05/2011

diff

Exibe as diferenças entre dois arquivos.

Opções:
-i : case-insensitive (indiferente a maiúsculas e minúsculas)
-y : exibe as diferenças lado a lado
-E : ignora diferenças no tamanho do TAB
-B : ignora linhas vazias
-b : ignora quantidade de espaços

Outros comandos semelhantes muito úteis: vimdiff e diff3

O comando diff é muito útil para encontrar cópias de trabalhos de faculdade, por exemplo. :P

echo

Exibe um texto na saída padrão.

Opções:
-n : não pula linha no final do texto
-e : interpreta caracteres de escape

Exemplos:

$ echo "sou \n um \n texto"
sou \n um \n texto

$ echo -e "sou \n um \n texto"
sou 
 um 
 texto

find

Localiza arquivos no sistema de arquivos.

Esse comando possui diversas opções e truques. Por isso, merece um post específico para ele. Um post muito bom sobre o find pode ser encontrado aqui:

http://gerencievocemesmo.com.br/site/?p=56

grep

Localiza padrões dentro de um ou mais arquivos. A busca é feita usando Expressões Regulares.

Opções:
-i : case-insensitive
-v : inverte o critério de busca
-r : recursivo, busca em subdiretórios também
-n : mostra, também, o número da linha
-c : conta o número de linhas que casaram com o padrão
-l : exibe só o nome do arquivo onde o padrão foi encontrado
-A N : mostra N linhas após a linha onde o padrão foi encontrado
-B N : mostra N linhas antes da linha onde o padrão foi encontrado
-C N : mostra N linhas antes e depois da linha onde o padrão foi encontrado

$ seq 10 | grep -A2 -B3 "5"
2
3
4
5
6
7

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep "^[a-z]"
olá
sou
teste
para
grep

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep -v "^[a-z]"
1

Para usar todos os recursos das Expressões Regulares, use egrep em vez de grep, o que permite usar grupos, quantificadores “+” e “{quantificador}”.

head

Mostra o início de um arquivo. O limite pode ser estabelecido em número de linhas ou caracteres. É o inverso do comando tail.

Opções:
-n N : exibe as N primeiras linhas
-c N : exibe os N primeiros caracteres

Exemplos:

$ echo -e "olá, sou\num teste\npara o\ncomando head" | head -n 2
olá, sou
um teste

$ echo -e "ola, sou\num teste\npara o\ncomando head" | head -c 7
ola, so

kill

O comando kill “mata” processos, ou seja, encerra, ou força o encerramento, de um programa.

Opções:
-9 : força o encerramento da execução de um processo
-1 : mata todos os processos que o usuário pode matar

Exemplos:

Força o encerramento do processo 1234:

$ kill -9 1234

Encerra a sessão do usuário, ou seja, força o encerramento de todos os seus processos:

$ kill -1 -9

Os IDs dos processos (PID – Process ID) podem ser encontrados usando o comando ps, que é o gerenciador de processos. Com as opções “ux”, listam-se os processos do usuário. Com grep podemos filtrar a saída pelo processo desejado:

$ ps ux | grep skype
beraldo   2267  1.0  2.0 281508 82968 ?        Sl   09:58   0:41 skype
beraldo   5672  0.0  0.0  10128   848 pts/0    S+   11:04   0:00 grep --color=auto skype

O skype é o processo 2267. Para forçar seu encerramento, fazemos:

$ kill -9 2267

Como lição de casa, vale ler os manuais dos comandos killall e pkill. :)

ls

Lista o conteúdo de um diretório.

Opções:
-a : lista arquivos e diretórios ocultos
-l : mostra diversos atributos dos arquivos e diretórios, como data de criação, dono, permissões etc
-R : lista o conteúdo recursivamente

Exemplos:

$ ls

$ ls -a

$ ls -l

$ ls -la

$ ls -laR

printf

Exibe um texto na tela, com várias opções de formatação, semelhante à função printf(), da linguagem C.

As opções de formatação são praticamente as mesmas da linguagem C. A lista completa pode ser vista no manual (man printf).

Exemplos:

$ printf "%x\n" 15
f

$ printf "%o\n" 7
7

$ printf "%o\n" 8
10

$ printf "%05d\n" 70
00070

$ printf "%.2f\n" 70
70,00

rev

Esse comando inverte uma string.

Exemplos:

$ echo "texto" | rev
otxet

$ echo "duh" | rev
hud

scp

Copia arquivos e diretórios via ssh, ou seja, cópia segura entre máquinas remotas.

Opções:
-r : cópia recursiva

Sintaxe:

$ scp [opções] maquina:origem destino
$ scp [opções] origem maquina:destino

Exemplos:

$ scp 192.168.0.100:~/arquivo.txt .

$ scp arquivo.txt 192.168.0.102:~

sed

Linguagem para edição de arquivos e textos. Veja um post exclusivo a ela aqui:

http://www.rberaldo.com.br/blog/o-comando-sed-do-linux/

seq

Exibe uma sequência de números.

Opções:
-s : separador (padrão “\n”)
-f : formato (padrão “%g”)

Exemplos:

$ seq 3
1
2
3

$ seq 3 5
3
4
5

$ seq 3 2 10
3
5
7
9

$ seq 10 -2 0
10
8
6
4
2
0

$ seq -s, 10 -2 0
10,8,6,4,2,0

$ seq -s, -f"%04g" 10 -2 0
0010,0008,0006,0004,0002,0000

sort

Ordena linhas de um texto, alfabética ou numericamente.

Opções:
-n : ordena numericamente
-r : ordena inversamente (de Z para A e de 9 para 1)
-f : case-insensitive
-k N : ordena pela coluna N do texto
-t : separador de coluna para a opção -k (padrão TAB)
-o : define um arquivo para a saída do comando

Exemplos:

$ echo -e "um\ndois\ntres\nquatro" | sort
dois
quatro
tres
um

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2
um	dois
tres	quatro

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2 -r
tres	quatro
um	dois

$ echo -e "1\n10\n100\n2\n20\n200" | sort 
1
10
100
2
20
200

$ echo -e "1\n10\n100\n2\n20\n200" | sort -n
1
2
10
20
100
200

ssh

O SSH (Secure Shell) realiza acesso remoto a outras máquinas Linux. Um post exclusivo a SSH pode ser lido aqui:

http://www.rberaldo.com.br/blog/usando-o-ssh

tac

Inverso do comando cat. Exibe o conteúdo de um arquivo do fim para o início.

tail

Exibe o fim de um texto, exatamente o oposto do comando head

Opções:
-n N : número de linhas a exibir
-c N : número de caracteres a exibir

Exemplos semelhantes ao do comando head.

top

O comando top exibe os processos atualmente em execução. É semelhante ao ps, citado na seção do comando kill, mas atualiza-se automaticamente, além de possuir várias opções de ordenação.

Exemplo:

$ top

O comando “htop” é mais completo e user-friendly, mas normalmente não vem instalado nas distros Linux. É possível instalá-lo via gerenciador de pacotes. Por exemplo, em sistemas baseados em Debian:

# apt-get install htop

O Python possui bibliotecas para implementação de servidores WEB simples. Há versão de apenas uma thread (atende uma requisição por vez) ou multi-thread (atende diversas requisições simultaneamente).

Os exemplos abaixo apenas enviam al cliente uma mensagem “INICIO”, esperam 2 segundos, e enviam outra mensagem, “FIM”. A espera por 2 segundos será útil apenas para enfatizar a diferença entre as versões monothread e multi-thread.

Os códigos funcionam em qualquer Sistema Operacional com Python instalado, mas os exemplos de execução que mostrarei são voltados para Linux ou Mac OS, onde há um terminal com suporte a bash e curl. Porém, nada impede que os testes sejam feitos em navegadores.

Versão simples, com apenas uma thread, ou seja, atende apenas uma requisição por vez:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/usr/bin/env python
# coding: utf-8
 
from BaseHTTPServer import BaseHTTPRequestHandler
import urlparse
import time
 
# Porta onde o servidor rodará
PORT = 8888
 
class GetHandler(BaseHTTPRequestHandler):
 
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write( "INICIO\n" )
        time.sleep( 2 )
        self.wfile.write( "FIM\n" )
 
if __name__ == '__main__':
    from BaseHTTPServer import HTTPServer
    server = HTTPServer(('localhost', PORT), GetHandler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()

Para executar:

$ python monothread.py

Ou, caso você dê permissão de execução ao script:

$ ./monothread.py

Para enviar solicitações ao servidor, sugiro este comando:

$ for (( i = 0; i < 5; i++ )) ; do curl http://localhost:8888 & done;

Você verá que cada requisição será atendida de cada vez. Ou seja, ao terminar a requisição 1, inicia-se o atendimento à requisição 2, mesmo que todas as 5 requisições tenham sido feitas “ao mesmo tempo” (note o & indicando que o cURL rodará em background).
Você verá que cada par “INICIO” e “FIM” aparecerão sequencialmente, mostrando que cada requisição é atendida individualmente.

Versão multi-thread, ou seja, atende várias requisições simultaneamente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/usr/bin/env python
# coding: utf-8
 
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
import threading
import time
 
# Porta onde o servidor rodará
PORT = 8888
 
class Handler(BaseHTTPRequestHandler):
 
    def do_GET(self):
 
        self.send_response(200)
        self.end_headers()
        self.wfile.write('INICIO\n')
        time.sleep( 2 )
        self.wfile.write('FIM!\n')
        return
 
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    """Handle requests in a separate thread."""
 
if __name__ == '__main__':
    server = ThreadedHTTPServer(('localhost', PORT), Handler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()

O procedimento para execução é o mesmo do anterior. Para testar, vamos usar o mesmo loop de requisições:

$ for (( i = 0; i < 5; i++ )) ; do curl http://localhost:8888 & done;

Dessa vez, todas as requisições serão atendidas ao mesmo tempo. A palavra “INICIO” aparecerá 5 vezes de uma só vez, e os logs de requisição do servidor aparecerão os 5 de uma só vez.

Os códigos acima foram adaptados deste link:
http://blog.doughellmann.com/2007/12/pymotw-basehttpserver.html

Em Linux, há programas gráficos para isso, mas a linha de comando é interessante pois permite converter vários arquivos de uma só vez, automaticamente. Por isso mostrarei como executar essa ação via Terminal. Além disso postarei um Shell Script completo para isso.

É necessário ter instalados os pacotes mplayer e mencoder para executar os comandos.

Supondo que queremos converter o arquivo video.avi em video.mp4, executaremos:

mencoder video.avi -o video.mp4 -oac copy -ovc lavc -lavcopts vcodec=mpeg1video -of mpeg

E este é um Shell Script para facilitar a tarefa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#!/bin/bash
#
# Converte arquivos AVI em MP4
#
# Sintaxe: avi2mp4.sh arquivo.avi
#
# Ao fim da execução, será gerado o arquivo arquivo.mp4
 
if [ $# -ne 1 ]
then
	echo "Erro de sintaxe."
	echo "Uso: avi2mp4.sh <video.avi>"
fi
 
FILE=$1
BASENAME=${FILE%.*}
 
mencoder "${FILE}" -o "${BASENAME}".mp4 -oac copy -ovc lavc -lavcopts vcodec=mpeg1video -of mpeg

A extensão MySQLi necessita do servidor MySQL 4.1 ou superior.

Vale lembrar que há boatos de que a extensão MySQL deixe de existir no PHP 6. Logo, seja isso verdade ou não, é preferível usar MySQLi.

Vou mostrar aqui a forma de se trabalhar com a extensão MySQLi.

Para realizar a conexão com a base de dados, basta isto:

$MySQLi = new mysqli( 'servidor', 'usuario', 'senha', 'nome_da_db' );

Por exemplo:

$MySQLi = new mysqli( 'localhost', 'root', 'passwd', 'test' );

Se a conexão for bem sucedida, $MySQLi será um objeto, que será usado para consultas posteriores e outras ações com a base de dados.

Para realizar uma consulta, por exemplo, basta usar o método query() e percorrer com fetch_assoc(), muito semelhante ao que se faz usando a extensão mysql:

$exec = $MySQLi->query( 'select dados from tabela' );
 
while ( $f = $exec->fetch_assoc() )
{
    print_r( $f );
}

A lista completa de propriedades e métodos da classe MySQLi pode ser encontrada no link abaixo:

http://php.net/manual/pt_BR/book.mysqli.php

Por exemplo: em vez de executar:

INSERT INTO tabela(numero) VALUES (1);
INSERT INTO tabela(numero) VALUES (2);
...

Poderíamos executar:

INSERT INTO tabela(numero) VALUES (1), (2);

Vou mostrar uma maneira simples de se fazer isso dinamicamente, com quantidade indeterminada informações, que podem vir de qualquer tipo de fonte de dados.

Vamos considerar um array com números inteiros, de 1 a 10:

$valores = range( 1 , 10 );

Para inserir isso num banco de dados, muitos fariam isto:

$valores = range( 1 , 10 );
for ( $i = 0; $i < count( $valores ); $i++ )
{
    $DB->query( 'INSERT INTO tabela(numero) VALUES(' . $valores[ $i ] . ')' );
}

Isso funciona. Mas é lento e sobrecarrega o servidor. Imaginem um array com 100 mil valores.

O correto é gerar a string SQL com todos os valores a serem inseridos, separados por vírgula, de forma a executar a consulta apenas uma vez. Logo, podemos fazer isto:

$valores = range( 1 , 10 );
$sql = sprintf( 'INSERT INTO tabela(numero) VALUES (%s)', implode( '), (' , $valores ) );
$DB->query( $sql );

Se dermos um echo em $sql, teremos como saída:

INSERT INTO tabela(numero) VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)

Dessa forma só se executa a SQL uma vez, tornando a execução bem mais rápida.

Normalmente são usados em sistemas desktop, mas é possível usá-lo para qualqquer tipo de aplicação. O PHP possui uma função nativa destinada ao processamento desse tipo de arquivo.

Antes de tudo, é bom entender a formatação de um arquivo INI. O artigo sobre arquivos INI da Wikipedia explica muito bem essa formatação. Além disso, se você está lendo este post é porque tem familiaridade com o PHP e, consequentemente, com o arquivo php.ini, o arquivo de configuração do PHP, que é um arquivo INI.

Vamos considerar o arquivo INI abaixo, nomeado como config.ini.

; comentário da seção 1
[section 1]
config1 = "valor 1"

; comentário da seção 2
[section 2]
config2 = "valor 2"

Usaremos a função parse_ini_file, do PHP, para processarmos esse arquivo.

O protótipo da função é:

array parse_ini_file ( string $filename [, bool $process_sections = false]);

O primeiro parâmetro é o nome do arquivo a ser processado. O segundo, opcional, define se devem ser processadas as seções dos arquivos. O padrão é false. Caso passe-se o valor true, o array de retorno será multidimensional, sendo cada dimensão correspondente a cada seção do arquivo .ini.

Isso ficará mais claro ao rodarmos este script:

1
2
3
4
5

$config = parse_ini_file( 'config.ini' );
print_r( $config );
 
$configWithSections = parse_ini_file( 'config.ini', true );
print_r( $configWithSections );

A saída é:

Array
(
    [config1] => valor 1
    [config2] => valor 2
)
Array
(
    [section 1] => Array
        (
            [config1] => valor 1
        )

    [section 2] => Array
        (
            [config2] => valor 2
        )

)

O primeiro print_r exibe o array unidimensional, com todas as seções numa única dimensão do array. O segundo print_r exibe o array multidimensional, resultante do processamento que leva em conta as seções do arquivo .ini.

Com isso fica simples criar arquivos de inicialização que buscam configurações básicas em arquivos .ini.

Porém, tome cuidado ao usar arquivos .ini com informações sensíveis, como configurações de acesso a bancos de dados. Arquivos .ini podem ser acessados via URL, sendo possível visualizar seu conteúdo pelo navegador. Logo, opte por manter um arquivo ini fora do diretório público de sua aplicação (geralmente o public_html).

O setlist foi muito bom, mas sempre pensamos “Bem que poderia ter tocado aquela…“. História longa, discografia extensa. Difícil agradar a todos.

Sem mais delongas, eis o setlist:

1. Satellite 15… The Final Frontier
2. El Dorado
3. 2 Minutes to Midnight
4. Coming Home
5. Dance of Death
6. The Trooper
7. The Wicker Man
8. Blood Brothers
9. When the Wild Wind Blows
10. The Evil That Men Do
11. The Talisman
12. Fear of the Dark
13. Iron Maiden

Encore:
14. The Number of the Beast
15. Hallowed Be Thy Name
16. Running Free

Dia 05 de abril será dia de nós, curitibanos, natos ou não, conferirmos o show do grande Iron Maiden, no Expotrade!

Vejo vocês lá! =)

Se ainda não comprou ingresso, corra!
http://www.ingressorapido.com.br/Evento.aspx?ID=13239

Fonte: Setlist.fm

É uma coisa extremamente simples, mas tem gente que não sabia (eu, por exemplo :P)

Basta pressionar simultaneamente as teclas de Repouso e Início. O som da câmera será emitido e a foto estará dispoinível no álbum de fotos.

Fonte
http://blogdoiphone.com/2010/10/print-screen