Arquivo

Arquivo de agosto, 2010

Anotações sobre o livro “JavaScript: The Good Parts”

15 de agosto de 2010

Em geral quando eu leio um livro, costumo fazer anotações de trechos interessantes que encontro.

No livro JavaScript: The Good Parts, de Douglas Crockford, encontrei um punhado deles. Eu listo esses trechos aqui, até sendo um forma de eu organizar meu estudo.

Só lembrando que minha intenção não é publicar partes do livro. Na verdade, espero que você, que usa/gosta de JavaScript, se sinta incentivado a ler o livro, o qual gostei muito e recomendo.

Ah, para quem quiser, também há a versão traduzida para português, O Melhor do JavaScript, publicada pela editora Alta Books.

Analisando o JavaScript

O JavaScript se baseia em algumas idéias muito boas, que incluem funções, tipificação fraca e objetos dinâmicos, e umas poucas idéias ruins, como um modelo de programação baseado em variáveis globais.

Se você deseja aprender sobre as partes ruins e como mal utilizá-las, consulte qualquer outro livro sobre JavaScript.

Números

Há um único tipo de número, onde não há um tipo inteiro distinto, diferente de outras linguagens de programação. Então 1 e 1.0 têm o mesmo valor.

Strings

Strings são imutáveis, nunca podem ser alteradas. Concatenando com o operador “+”, uma nova string é criada.

Duas strings que contém os mesmos caracteres na mesma ordem são considerados a mesma string. Por exemplo, o resultado da expressão abaixo é true.

"P" + "r" + "o" + "d" + "i" + "s" === "Prodis" // true
Escopo

Diferente de outras linguagens, os blocos (grupo de comandos entre chaves) não criam um novo escopo. Uma variável declarada dentro de um bloco é visível em qualquer lugar da função que contém esse bloco. Sendo assim, as variáveis não deveriam ser definidas nos blocos, e sim no começo da função.

Valores booleanos

false, null, undefined, string vazia “”, o número 0 e o número NaN são valores falsos. Todos os outros valores são considerados verdadeiro, inclusive true, a string “false” e os demais objetos.

Operador typeof

“number”, “string”, “boolean”, “undefined”, “function” e “object” são valores retornados por typeof. Para o uso de typeof com null ou uma matriz, o retorno é “object”, o que não é certo. Um teste melhor para detectar nulos é simplesmente:

myValue === null
Objetos

Números, strings e booleanos não são objetos, pois são imutáveis. Objetos são grupos mutáveis com índices. Matrizes, funções, expressões regulares e objetos são objetos.

Para criar novos valores de objetos, uma forma conveniente é criar um objeto literal, um par de chaves contendo zero ou mais pares nome/valor. Por exemplo:

var contact = {
  "email" = "pedro@bo.com.br",
  "phone" = "(11) 9999-9999"
}

Todo objeto é ligado a um protótipo de onde ele pode herdar propriedades. Todos os objetos criados de literais são associados a Object.prototype, um objeto que vem como padrão no JavaScript.

Funções

A melhor coisa que JavaScript possui é sua implementação de funções.

Funções são ligadas à Function.prototype, que está ligada à Object.prototype.

Funções podem ser armazenadas em váriaveis, objetos e matrizes. Elas podem ser passadas como parâmetros para funções e serem retornadas por funções. E como são objetos, funções também podem ter métodos.

Quando uma função é chamada e os parâmetros não coincidem, não há erro em tempo de execução. Se os valores informados excederem a quantidade de parâmetros, os valores excedentes são ignorados. Se o inverso acontecer, undefined será atribuído aos valores faltantes.

Uma função sempre retorna um valor. Se um valor não for fornecido no comando return, então undefined é retornado.

Ao invés de escopo de bloco, JavaScript possui escopo de função. Todos os parâmetros e variáveis definidos em uma função não são visíveis fora dela. É recomendável declarar todas as variáveis utilizadas em uma função no início do corpo da função, diferente de outras linguagens onde as variáveis geralmente são declaradas logo antes de sua utilização.

Partes péssimas e ruins

A dependência de variáveis globais é a pior parte do JavaScript, pois uma dessas variáveis pode ser alterada em qualquer parte do código e em qualquer momento, algo que pode complicar muito o comportamento de um programa.

O operador “+” é utilizado tanto para concatenar strings, quanto para somar números. Se você quer usá-lo para somar, precisa se certificar que os dois operandos são números. Caso contrário, esses operandos serão convertidos em strings. Veja o exemplo abaixo:

10 + 15 // 25
10 + "15" // "1015"

O valor NaN (not a number) é um tanto incoerente. O typeof não distingue entre números e NaN:

typeof(NaN) // "number"

E NaN não é igual a ele mesmo:

NaN === NaN // false
NaN !== NaN // true

No JavaScript, há dois grupos de operadores de igualdade:

  • Os bons: === e !==
  • E os maus: == e !=

Os bons funcionam como esperado: se dois operando tiverem o mesmo valor e forem do mesmo tipo, === retorna true e !== retorna false. Já os maus funcionam bem quando os operando são do mesmo tipo, mas quando eles são de tipos diferentes, eles tentam fazer coerção de tipo e coisas estranhas podem acontecer:

"" == "0" // false
0 == ""   // true
0 == "0"  // true

false == "false" // false
false == "0"     // true

false == undefined // false
false == null     // false
null == undefined  // true

" \t\r\n " == 0 // true

O melhor é sempre usar o grupo de bons operados de igualdade: === e !==.

JavaScript, Livros , ,

Returning em Ruby on Rails

5 de agosto de 2010

Quantas vezes você já criou algum método em Ruby que inicializa uma variável, atribui valores a ela e depois a retorna?

Veja o exemplo abaixo:

def some_values
  values = []
  values << "first element"
  values << "second element"
  values
end

some_values # => ["first element", "second element"]

A linha 2 é cria um array vazio, depois são atribuidos valores nas linhas 3 e 4, e finalmente na linha 5 o array é retornado pelo método.

Em Ruby on Rails existe o método returning da classe Object que facilita nossa vida nesses casos:

def some_values
  returning values = [] do
    values << "first element"
    values << "second element"
  end
end

some_values # => ["first element", "second element"]

Na linha 2 chamamos o método returning passando a variável que será retornada já atribuindo seu valor inicial. Dentro do bloco, nas linhas 3 e 4, então atribuímos os valores ao array.

Há também esse outro tipo de sintaxe:

def some_values
  returning [] do |values|
    values << "first element"
    values << "second element"
  end
end

some_values # => ["first element", "second element"]

Funciona da mesma forma, mas acaba sendo não tão intuitivo como o código anterior.

Veja um trecho de código utilizando o método returning, de um método auxiliar para testes de RSpec retirado de uma aplicação real:

def variants
  returning variants = [] do
    5.times do |priority| do
      variants << Factory.build(:variant, :priority => priority)
    end
  end
end

E olhe só como é simples a implementação do método returning:

def returning(value)
  yield(value)
  value
end

Ruby , , ,

[Off Topic] Novos tipos de ética

4 de agosto de 2010

Hoje em dia, “surgiram” novos tipos de ética:

Ética do que os olhos não vêem

Se eu estou passeando com meu cachorro e ele faz cocô na calçada em frente ao portão do meu vizinho, tudo bem. Eu vou embora e deixo o cocô lá, ninguém viu mesmo. Mas se isso acontecer quando meu vizinho está no portão, vendo a cena, é claro que eu vou pegar o cocô na hora. E provavelmente vou pedir para ele me emprestar algum papel ou saco plástico, afinal eu não ando com isso no bolso quando passeio com meu cachorro.

Ética do todo mundo também faz

Estou no meu carro, dirigindo em uma estrada cheia, chegando ao ponto de ficar parado em vários momentos. Se eu for pelo acostamento, irei andar mais rápido. Mas andar pelo acostamento é proibibo, então não vou por lá, continuo aqui parado. Mas espere, um carro passou pelo acostamento, e bem rápido. Outros carros estão andando no acostamento agora. Ah, também vou por lá, assim irei chegar mais rápido em casa. É proibido por lei, mas todo mundo está indo mesmo, então não tem problema.

Ética do não é meu mesmo

Eu trabalho todos os dias usando um computador na minha empresa. É um computador muito bom, deve ter custado bem caro. Em casa eu tenho um semelhante, também paguei caro. Por isso, tenho o maior cuidado com ele, sempre o deixo limpo, organizado e não instalo programas que podem prejudicar seu bom funcionamento. Já o computador da minha empresa eu não preciso ter o mesmo cuidado, posso instalar qualquer programa, comer em cima do teclado, deixar os fios todos zoneados. Eu não preciso me preocupar com isso, afinal, não é meu mesmo.


Ética é um conjunto de valores morais e princípios que norteiam a conduta humana na sociedade. A ética serve para que haja um equilíbrio e bom funcionamento social, possibilitando que ninguém saia prejudicado.

Definição retirada de http://www.suapesquisa.com/o_que_e/etica_conceito.htm


.

Falando sério agora, às vezes eu sinto que alguns valores que as pessoas prezam atualmente estão distorcidos, onde honesto é sinônimo de otário e o respeito é deixado em segundo plano.

Geral