Procurando algo?

quinta-feira, 19 de maio de 2011

Expressões regulares

Expressões regulares são bem úteis e muitos programadores .NET acabam ignorando-as por serem herança do mundo Unix.

Porém, quando se dá a elas a devida atenção, vantagens são descobertas e códigos que levariam n+1 linhas para fazer validação de entrada, acabam por se apresentarem em apenas uma linha. Veja o exemplo de um método que valida telefones:

static bool IsPhone(string s)
{
    return Regex.IsMatch(s, @"^\(?\d{3}\)?[\s\-]?\d{3}\-?\d{4}$");
}

Mas o que raios é esse monte de treco entre as aspas?

Eu explico:

^ Representa o início da string. Quando você usa este símbolo, significa que você está trabalhando a string desde seu início.
\(? Um parênteses opcional. Para validar parênteses, é necessário usar com escape \ e para tornar o símbolo opcional, usa-se ?
\d{3} Três dígitos numéricos. \d significa dígito  e o número entre chaves identifica a quantidade que se está buscando.
\)? Fechamento de parênteses opcional. Novamente um parênteses, dessa vez fechando mas também é opcional graças ao ?
[\s\-]? Ou um ou outro. Nesse caso, estamos buscando OU um espaço vazio por \s OU um hifem por \- . Devido a estarem entre colchetes, nunca serão encontrados ao mesmo tempo. E seja lá qual for que encontremos, é opcional de qualquer maneira.
\d{3} Três dígitos. Isso eu já expliquei :D
\-? Um hífem. Apenas um hífem. Mas é opcional, se não tiver, tudo bem.
\d{4} Adivinha?
$ Final da string. Este símbolo indica o final da string. Como usamos ^ no começo e $ no final, estamos testando a string inteira.

Zenit Polar e texto ao contrário

Dois métodos simples. Apenas por diversão.
/// 
/// Criptografa usando o algorítmo Zenit Polar
/// 
/// O texto de entrada/// Texto criptografado
private string ZenitPolar(string p)
{
    String s;
    s = p;

    s = s.Replace("z", "wx");
    s = s.Replace("p", "z");
    s = s.Replace("wx", "p");

    s = s.Replace("e", "wx");
    s = s.Replace("o", "e");
    s = s.Replace("wx", "o");

    s = s.Replace("n", "wx");
    s = s.Replace("l", "n");
    s = s.Replace("wx", "l");

    s = s.Replace("i", "wx");
    s = s.Replace("a", "i");
    s = s.Replace("wx", "a");

    s = s.Replace("t", "wx");
    s = s.Replace("r", "t");
    s = s.Replace("wx", "r");

    return s;
}

/// 
/// Inverte o texto
/// 
/// O texto de entrada/// O texto invertido
private string Reverse(string txt)
{
    StringBuilder sb = new StringBuilder();

    for (int i = txt.Length; i > 0; i--)
        sb.Append(txt[i-1]);

    return sb.ToString();
}

sexta-feira, 6 de maio de 2011

Código Fonte do Windows Vista

segunda-feira, 28 de fevereiro de 2011

Camel Case em tempo real

Camel Case é quando as palavras iniciam com maiúscula e tem as outras letras minúsculas.

Muitas vezes tratamos isso ao entrar ou sair do campo, mas pode-se também tratar enquanto se digita no campo, em tempo real.

Veja como se faz:

private void txt_KeyPress(object sender, KeyPressEventArgs e)
{
    TextBox t = (TextBox)sender;

    if (t.Text.Length > 1 && t.Text.Substring(t.Text.Length - 1, 1) == " ")
    {
        // Primeiras letras em maiúscula
        e.KeyChar = Convert.ToChar(e.KeyChar.ToString().ToUpper());
    }
    else if (t.Text.Length == 0 || t.SelectionLength == t.Text.Length)      
    {
        // Primeira de todas em maiúscula
        e.KeyChar = Convert.ToChar(e.KeyChar.ToString().ToUpper());
    }
    else                                                                    
        // O resto minúsculo
        e.KeyChar = Convert.ToChar(e.KeyChar.ToString().ToLower());
}

sexta-feira, 7 de janeiro de 2011

As empresas sabem realmente o que estão fazendo?

No início de 2011 voltei a procurar por um novo emprego depois da calmaria em meu emprego atual.

Me candidatei a diversas vagas de análise, desenvolvimento e até suporte. Achei vagas boas até, com bons salários, mas por algum motivo nada se concretizou ainda. Recebí ligações, conversei por um bom tempo ao telefone, enviei CVs em português e em inglês.

Algumas vagas eram extremamente boas, mas o fato de ser suporte, me chateia. Quero desenvolver!

A primeira era perfeita, multinacional, salário alto, suporte em inglês e Unix. Tudo OK. Mesmo sendo suporte, me candidatei, afinal o salário era muito bom.

Em uma delas era suporte em inglês em São Bernardo do Campo. Salário razoável, mas continua sendo suporte. Perguntei ao headhunter se haveria a possibilidade de migrar a carreira pra dev depois de um tempo, ele disse que sim. Vamos ver... meu nome está lá.

Uma outra era análise, indicação de amigo, contratação certa, teoricamente perfeita. Mas era uma tecnologia ultrapassada e ainda em Barueri, 90km de distância.

Uma coisa já decidí, largo meu emprego mas não largo a faculdade! Isso vai mudar minha vida, tenho certeza disso! Estou até indo bem, passando em todas as disciplinas com notas boas, tudo OK para ter um bom Índice de Aproveitamento Acadêmico no final e quem sabe trabalhar na Google :D

Então, se um emprego ameaça meu rendimento na faculdade, fico com um pé atrás. Talvez não devesse, mas fico.

Não tenho experiência profissional comprovada em desenvolvimento. Então até vaga para Júnior fica difícil na área. O que tem abaixo de Jr. então? :D

Fui chutado de todos os estágios e programas de trainee aos quais me candidatei, mas esse ano me candidato novamente. Não vão se livrar tão fácil assim de mim :D

E pra finalizar esta postagem, de vez em quando me pergunto se as empresas sabem realmente o que estão fazendo. Talvez elas estejam deixando um talento passar batido por falta de informação e ou por processo seletivo falho.

Tenho consciência de minha capacidade, um dia chego lá :D