Página Inicial > JavaScript, Livros > Anotações sobre o livro “JavaScript: The Good Parts”

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

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 , ,

  1. thiago
    31, agosto, 2010 em 19:19 | #1

    vc sabe como eu forço a atualização do DOM via javascript!? Ex: eu seto uma valor para um textbox via client, no entanto o navegador (IE) não atualiza o objeto. Vi algumas soluções de jogar o valor para o hidden, e depois ler do hidden (no server), mas achei essa solução meio porca.

  1. 5, janeiro, 2011 em 18:40 | #1