DEV Community: Programe com Faiçal e Conrado

JavaScript, HTML e CSS em português! Como assim?!

Faiçal Carvalho — Thu, 07 Nov 2019 15:15:32 +0000

Introdução

JavaScript pt-BR é o nome da tradução da linguagem JavaScript para o português – mais especificamente, para o português falado no Brasil.

Esta surpreendente variação da linguagem JavaScript está disponível como uma das principais características da plataforma Timus, que oferece um ambiente online para criação de aplicações baseadas na web.

A plataforma Timus vai mais além: ela permite não só a programação em JavaScript pt-BR, mas também em HTML pt-BR e CSS pt-BR – estas duas últimas sendo a tradução das linguagens HTML e CSS para o português falado no Brasil.

Por que traduzir? Por que não ensinar programação usando simplesmente JavaScript, HTML e CSS no original, em inglês?

As linguagens de programação usam, atualmente, o texto escrito para representar os programas. Você pode ver cada programa como um texto que deve ser redigido de acordo com regras semelhantes às que você segue ao escrever, por exemplo, uma redação – um pouco mais rígidas, talvez.

Programar é muito parecido com escrever. Os mesmos atributos de um bom texto valem também para caracterizar um bom programa. Clareza, precisão, simplicidade, objetividade, equilíbrio são características que se aplicam como critérios de qualidade tanto na produção de um texto como na de um programa.

Vamos imaginar, então, que você ainda não tem um bom entendimento de inglês. Ou seja, seu inglês deixa a desejar em muitos pontos.

Vamos imaginar também que, nessa situação, alguém lhe pede para elaborar um pequeno texto – um parágrafo – sobre, por exemplo, o campeonato brasileiro de futebol. No entanto, o pedido é feito com um "pequeno" detalhe adicional: o texto tem de ser em inglês!

O que aconteceria? Você conseguiria cumprir com essa tarefa? Seria fácil realizá-la?

É mais ou menos isso que ocorre quando você quer aprender a programar e, mesmo tendo essa dificuldade, se vê obrigado a usar as linguagens de programação em inglês.

Uma coisa é a programação; outra é o inglês. A programação, por si só, já apresenta uma série de conceitos novos que precisam ser assimilados. O processo de assimilação, definitivamente, não é algo simples. Se nesse processo houver a dificuldade adicional causada pelo inglês, o caminho será muito mais difícil.

Tipicamente, a notação usada nas linguagens de programação é mais concisa do que a que pode ser usada, por exemplo, numa redação. Isso é verdade. No entanto, mesmo havendo a notação mais concisa, cada termo que compõe a linguagem de programação está ali carregando o mesmo significado que possui na língua original – tipicamente, o inglês.

Imagine uma pessoa que não sabe programar e lê o texto de um programa. Por entender a língua nativa na qual se baseia a linguagem de programação que está sendo usada, essa pessoa já pode ter pelo menos uma ideia do que está escrito.

Por outro lado, quando não há esse entendimento mínimo, o texto do programa fica parecido com o seguinte:

    cyz (inf < sup) {
        biczro {
            swpo aux = ((sup - inf) % 2) + 1
            itens[aux] = 0
            inf++
        } czaspod (inf < sup)
        rotwpo wdziwypra
    }
    rotwpo kaywylsz

Para programar, você precisa assimilar alguns conceitos que são fundamentais para a sua formação como programador, seja qual for a linguagem ou sistema de desenvolvimento de software que você utilize hoje ou venha a utilizar no futuro.

O que consideramos importante é justamente a firme assimilação desses conceitos fundamentais.

Para qualquer pessoa que não tenha ainda uma sólida base de conhecimentos da língua inglesa, é mais fácil começar a programar usando palavras na sua língua nativa.

Nesse aprendizado, conforme dissemos, o estudante precisa assimilar conceitos básicos, e o uso de palavras que lhe são naturalmente familiares é um fator que simplifica e acelera o processo de assimilação.

E uma vez assimilados os conceitos básicos, será mais fácil, futuramente, usar – se necessário – as linguagens no original, em inglês.

JavaScript, na sua variação pt-BR usa palavras em português. Toda a estrutura sintática de JavaScript pt-BR e todos os seus mecanismos dinâmicos são exatamente os mesmos que os que configuram a linguagem JavaScript original, em inglês. A única diferença é o uso de palavras em português.

O mesmo vale para HTML pt-BR e CSS pt-BR, ficando mantidas as características de cada linguagem.

Usando o Timus, você pode, inclusive, facilmente alternar a língua do módulo que está sendo exibido no editor, variando entre o inglês (en) e o português (pt-BR).

Estamos, no momento, adotando a variação pt-BR porque o nosso atual público alvo reside no Brasil e tem o português como língua nativa.

Insistimos: o processo de assimilação é mais simples e rápido quando na linguagem de programação são usados termos com os quais já existe uma familiarização natural, propiciada pela língua nativa.

Para muitos brasileiros interessados em aprender programação, não haver a necessidade do inglês é uma barreira a menos no caminho rumo à culminação do aprendizado.

Os comandos enquanto (while) e fazer-enquanto (do-while)

Faiçal Carvalho — Fri, 18 Oct 2019 17:45:51 +0000

Diferenças entre esses dois comandos de repetição

Os computadores são muito eficientes na realização de tarefas repetitivas. Por causa disso, as linguagens de programação oferecem vários recursos relacionados com o controle dessas repetições.

Um deles é o comando enquanto (while, em inglês).

Outro é o comando fazer-enquanto (do-while, em inglês).

Esses dois comandos são parecidos, mas funcionam de forma um pouco diferente. Vamos mostrar aqui aspectos da diferença entre esses dois comandos repetitivos, conforme as regras da linguagem JavaScript.

O comando enquanto tem a seguinte sintaxe:

enquanto (condição)
    comando

Em inglês:

while (condição)
    comando

A execução de um comando enquanto é bastante intuitiva, e segue os seguintes passos:

A condição é avaliada
Caso o resultado seja não (falso), o comando que aparece depois da condição não é executado, e a execução do programa prossegue com o comando seguinte ao comando enquanto.
Caso o resultado da avaliação da condição seja sim (verdadeiro), o comando é executado e o ciclo recomeça com o passo 1.

O comando fazer-enquanto tem a seguinte sintaxe:

fazer
    comando
enquanto (condição)

Em inglês:

do
    comando
while (condição)

A execução de um comando fazer-enquanto segue os seguintes passos:

O comando é executado.
A condição é avaliada.
Caso o resultado seja não (falso), o comando fazer-enquanto termina, e a execução do programa prossegue com o comando seguinte ao comando fazer-enquanto.
Caso o resultado da avaliação da condição seja sim (verdadeiro), o ciclo recomeça com o passo 1.

Nestes dois comandos e no outro comando repetitivo – o comando para (em inglês, for) –, cada execução do comando repetido é chamada de uma iteração.

A diferença entre os dois é que, no comando enquanto, a avaliação da condição é feita no início de cada iteração. Dessa forma, pode acontecer de o comando não ser executado nenhuma vez.

Já no comando fazer-enquanto, a condição é avaliada no final de cada iteração. Assim, o comando sempre é executado pelo menos uma vez.

A rigor, a condição que aparece na sintaxe desses dois comandos corresponde a uma expressão. Avaliar a condição significa avaliar a expressão.

A expressão pode ser de vários tipos. O resultado da avaliação é convertido para o tipo lógico (boolean), conforme indicado na tabela abaixo.

Tipo da expressão	Resultado
Indefinido	`não`
Nulo	`não`
Número	`não`, se 0 ou Inválido (NaN); caso contrário, `sim`
Texto	`não`, se texto vazio (tamanho 0); caso contrário, `sim`
Símbolo	`sim`
Objeto	`sim`
Lógico	Resultado é a própria expressão/condição

O resultado dessa conversão para o tipo lógico, indicado na tabela acima, determina então o comportamento do comando repetitivo, conforme descrevemos acima.

Esta mesma regra de conversão vale também para a condição que é verificada no comando se (if).

Por último, uma observação prática: na nossa experiência, o comando enquanto é naturalmente bem mais usado do que o fazer-enquanto. Também na nossa experiência o comando para é naturalmente mais usado do que o enquanto. Em outro post vamos detalhar aspectos relacionados com as variações do comando repetitivo para.

Funções Seta (Arrow Functions)

Faiçal Carvalho — Wed, 16 Oct 2019 13:22:07 +0000

Uma notação especial para definir funções

A partir de 2015, JavaScript passou a ter as funções-seta - em inglês, arrow functions.

Trata-se de uma notação especial para definir funções. Nessa notação não aparece a palavra função, e você não dá um nome à função. As funções-seta são anônimas.

Elas são sempre usadas como expressões, e podem, por exemplo, da mesma forma que as funções tradicionais, ser atribuídas a uma variável:

seja max = (n1, n2) => {
    se (n1 > n2)
        retornar n1
    retornar n2
}

Esse exemplo mostra uma função-seta sendo atribuída a uma variável chamada max.

A definição de uma expressão representando uma função-seta começa com a lista de parâmetros da função. Nesse exemplo, a função tem dois parâmetros - n1 e n2. Eles aparecem entre parênteses.

Em seguida, depois da lista de parâmetros, aparece a seta. Ela é representada pelos caracteres = e >, um seguido do outro: =>.

Depois da seta, vem o bloco da função, entre chaves: { e }. Na definição dos comandos da função, não há restrições nem diferenças entre uma função-seta e uma função tradicional.

Há um detalhe: nos comandos de uma função-seta, a referência ao identificador este - em inglês, this - é tratada de forma especial, diferente da forma como essa referência é tratada numa função regular. Mas isso é outro assunto, sobre o qual trataremos em outra oportunidade.

Caso a função tenha apenas um parâmetro, os parênteses do início podem ser omitidos. Por exemplo:

seja duplicar = n => {
    retornar n * 2
}

Nesse exemplo, a função-seta está sendo atribuída a uma variável duplicar. Observe que o parâmetro n não aparece entre parênteses.

Uma função-seta pode também não ter parâmetros. Nesse caso, é necessário começar a definição com uma lista de parâmetros vazia, (). Por exemplo:

seja jogarDado = () => {
    retornar Mat.piso(Mat.aleatório() * 6) + 1
}

Quando o código da função-seta consiste apenas em retornar o resultado de uma expressão, a notação pode ficar ainda mais concisa, sem a necessidade do abre e fecha chave. Basta colocar diretamente após a seta a expressão retornada. Por exemplo:

seja duplicar = n => n * 2

Nesse exemplo, a função-seta tem um parâmetro, n, e retorna o resultado da expressão n * 2. Funcionalmente, essa implementação da função duplicar é exatamente igual à anterior, que usa o bloco entre chaves e o comando retornar.

O objetivo dessa notação é justamente esse: permitir a definição de funções de forma concisa.

A aplicação das funções-seta é bem expressiva, por exemplo, quando usada nos métodos associados às listas. Vários deles recebem como argumento uma função que é chamada para cada elemento da lista. Usar uma função-seta como argumento desses métodos possibilita notações interessantes.

Vamos ver alguns exemplos. Vamos tomar como base a seguinte lista:

seja carros = [
    { marca: 'Renault', modelo: 'Kwid', câmbio: 'automático' },
    { marca: 'Fiat', modelo: 'Mobi Evo', câmbio: 'manual' },
    { marca: 'Chevrolet', modelo: 'Onix', câmbio: 'manual' }
]

carros é, portanto, uma lista de objetos, cada um contendo as propriedades marca, modelo e câmbio.

Vamos mostrar, então, uma forma de usar, por exemplo, o método encontrar, que pode ser usado em listas. Nesse caso, vamos usá-lo para obter o primeiro carro da lista que tem câmbio manual.

seja câmbioManual = carros.encontrar(carro => carro.câmbio === 'manual')

//  câmbioManual = { marca: "Fiat", modelo: "Mobi Evo", câmbio: "manual" }

A função encontrar recebe como argumento uma função que retorna sim ou não. Essa função é chamada para cada elemento da lista. Nesse exemplo, cada elemento fica representado pelo parâmetro carro. Quem chama essa função repetidas vezes é o mecanismo interno da função encontrar.

Assim que a função-seta retornar sim (ou verdadeiro), a função encontrar termina imediatamente, e retorna o valor do elemento da lista para o qual a função retornou sim. No nosso exemplo, esse valor está sendo atribuído à variável câmbioManual.

Outro exemplo: com base nessa lista carros, vamos criar uma nova lista, na qual cada elemento será o texto correspondente ao modelo do carro. Para isso, a melhor alternativa é usar o método mapear.

seja modelos = carros.mapear(carro => carro.modelo)

//  modelos = ["kwid", "Mobi Evo", "Onix"]

O método mapear retorna uma nova lista. Para cada elemento da lista original, a nova lista terá um elemento cujo valor - de acorodo com o código desse exemplo - corresponde ao texto com a propriedade modelo de cada carro.

Na classe Lista - em inglês Array -, há vários outros métodos semelhantes a esses. Em outra oportunidade vamos tratar desse assunto com mais detalhes. O objetivo hoje foi introduzir essa notação especial para definir funções como funções-seta.

Qual o preço da pressa?

Faiçal Carvalho — Tue, 15 Oct 2019 20:49:15 +0000

Legibilidade e estilo em JavaScript

Uma das principais características de um programa é a sua legibilidade.

Mas, o que é legibilidade?

No contexto da programação, a legibilidade é o grau de facilidade com que a gente consegue ler o programa. Ou seja, o quanto o programa é legível, de fácil entendimento.

Quem executa o programa é o computador. Para o computador, a forma como o programa está escrito não importa. O computador simplesmente não considera a legibilidade. É algo que ele ignora completamente. “Legibilidade é coisa de humanos”, ele deve pensar…

Então, porque estamos falando de legibilidade? A legibilidade tem importância? Se a legibilidade tem alguma importância, para quem ela é importante? Quem se importa com a legibilidade?

Os programas são escritos por nós, seres humanos, correto? (Na imensa maioria dos casos, sim, isso é verdade. Mas há também programas cuja execução resulta na geração de outros programas. Na área de testes de sistemas, acontece muito isso de um programa gerar um ou vários programas de teste... mas isso é outra história.)

Retomando: os programas são escritos por nós, seres humanos. É uma realidade. Mas é muito importante a gente ter presente uma realidade que vem na sequência dessa: além de escritos por nós, os programas precisam também ser lidos por nós. É aí então que entra a legibilidade.

Por qual motivo eles precisam ser lidos?

Nós temos de pensar o seguinte: Criar um programa é algo que ocorre só uma vez. Porém, na prática, todo programa, depois de criado, precisa ser mantido.

Porque ele precisa ser mantido? As principais causas são:

Para corrigir algum problema que tenha sido detectado (manutenção corretiva).
Para acrescentar uma nova funcionalidade (manutenção evolutiva).
Para adaptar o código a alguma mudança no ambiente externo – por exemplo, mudanças na legislação (manutenção adaptativa).

A necessidade de dar manutenção em um programa é MUITO mais frequente do que a de criar um programa do zero. Por essa razão, a facilidade com que um programa pode ser mantido – isto é, sua manutenibilidade – é superimportante.

Na hora de dar manutenção, a legibilidade é fundamental.

Frequentemente, quem programa costuma sofrer pressões – as empresas costumam ser implacáveis na cobrança por uma solução rápida. A pressa faz com que alguns cuidados – sobretudo os relacionados com a legibilidade – não sejam considerados.

Mais tarde, vêm as consequências.

Para alterar um trecho de código, você precisa saber o que está fazendo. Para isso, você precisa ler e entender – e é aí que a gente conclui que a legibilidade tem uma importância capital. Sem trocadilho.

Legibilidade === $$$

Se, na hora de dar manutenção, você demorar muito para entender o programa por falta de legibilidade, isso certamente vai implicar em custos para a empresa.

Vamos ver agora algumas características que configuram a legibilidade de um programa.

Nos exemplos de código que vamos mostrar, estamos usando uma forma similar à apresentada no livro “The Practice of Programming” (“A Prática da Programação”), de Kernighan e Pike. O código que consideramos inadequado ou questionável é precedido pelo comentário "// ???".

É bom esclarecer que algumas questões que afetam a legibilidade são questões de estilo. Entra nisso, em alguns casos, o gosto pessoal.

Em várias situações, no entanto, sobretudo para quem está começando a programar, o mais prudente é seguir atentamente as recomendações. Depois, com o tempo, aos poucos vão surgindo naturalmente as escolhas pessoais.

Espaços em branco

Vamos começar com o uso de espaços em branco no código. Isso influi muito na legibilidade. Compare esses dois trechos:

//  OK
seja clicouFora = (x < X1) || (y < Y1) || (x > X1 + DX) || (y > Y1 + DY)

//  ???
seja clicouFora=(x<X1)||(y<Y1)||(x>X1+DX)||(y>Y1+DY)

Mesmo sem saber do que trata o código acima, a primeira forma é bem mais clara, bem mais legível que a segunda.

Aqui vai uma primeira regra: Deixe sempre um espaço em branco em ambos os lados de todos os operadores binários (operadores que têm dois operandos, um de cada lado).

Isso vale para os operadores de atribuição:

//  OK
x = X1
x += X2 + ((x - X2) / 2)

//  ???
x=X1
x+=X2+((x-X2)/2)

Vale também para os operadores de comparação:

//  OK
se (x <= X1)
    x++

//  ???
se (x<=X1)
    x++

Para os operadores aritméticos:

//  OK
seja número = vabM * 4 / Mat.potência(vabM, 4) + Mat.potência(vabM, 4)
número = 1 - Mat.raiz(3 - 6 * número)

//  ???
seja número=vabM*4/Mat.potência(vabM,4)+Mat.potência(vabM,4)
número=1-Mat.raiz(3-6*número)

Para os operadores lógicos:

//  OK
se (x > X1 && x < X2 && y > Y1 && y < Y2)
    x++

//  ???
se (x>X1&&x<X2&&y>Y1&&y<Y2)
    x++

Vale também para o operador ternário:

//  OK
x = (x > X1 && x < X2) ? 1 : 0

//  ???
x=(x>X1&&x<X2)?1:0

No caso dos operadores unários, consideramos mais adequado não deixar um espaço em branco. Por exemplo, depois do operador ! (negação):

//  OK
se (!iniciou)
    iniciar()

//  ???
se (! iniciou)
    iniciar()

Da mesma forma, operadores de incremento ++ ou decremento -- também não devem ter um branco entre eles e o operando:

//  OK
n++

//  ???
n ++

O espaço em branco é importante também no uso dos comandos. Deixe sempre um espaço em branco após a palavra chave dos comandos:

//  OK
se (a > b)
    b++

//  ???
se(a > b)
    b++

//  OK
enquanto (a > b)
    b++

//  ???
enquanto(a > b)
    b++

//  OK
para (i = 0; i < tam; i++)
    lista[i] = nulo

//  ???
para(i = 0; i < tam; i++)
    lista[i] = nulo

Mudanças de linha

A mudança de linha é outro aspecto que influi muito na legibilidade. Muitos comandos possuem um ou mais comandos subordinados. Eles devem ser posicionados na próxima linha:

//  OK
se (a > b)
    b++

//  ???
se (a > b) b++

//  OK
enquanto (a > b)
    b++

//  ???
enquanto (a > b) b++

//  OK
para (i = 0; i < tam; i++)
    lista[i] = nulo

//  ???
para (i = 0; i < tam; i++) lista[i] = nulo

Indentação

A indentação é a forma de posicionar os comandos nas linhas, sobretudo considerando a distância em relação à margem esquerda e a subordinação entre comandos. Sem que tenhamos mencionado, quase todos os exemplos que temos dado incluem aspectos relacionados com a indentação.

Nós adotamos a indentação com 4 caracteres. Isto significa que os níveis de tabulação do código avançam de 4 em 4 caracteres.

É muito comum você encontrar código em JavaScript adotando indentação com 2 caracteres. Nós preferimos 4.

Conforme você já deve ter observado, o comando subordinado deve ser posicionado com um nível a mais de indentação:

//  OK
se (a > b)
    enquanto (b < c)
        b++

//  ???
se (a > b)
enquanto (b < c)
b++

Indentação na declaração de uma função

Na declaração de uma função você deve também estar atento a alguns detalhes importantes:

A palavra função e o nome da função devem ser colocados na mesma linha, separados por um espaço em branco.
Entre o nome da função e o abre parêntese da lista de parâmetros não deve haver um espaço em branco.
Os parâmetros entre parênteses devem estar separados por vírgula, cada uma seguida de um espaço em branco.
Entre o último parâmetro e o fecha parêntese não deve haver um espaço em branco.
Entre o fecha parêntese da lista de parâmetros e o abre chave do bloco de comandos da função deve ser colocado um espaço em branco.
Os comandos da função devem ser posicionados um nível de indentação acima do que está a palavra função.
O caractere fecha chave ao final da função deve ficar numa linha isolada, e deve ser posicionado no mesmo nível de indentação da palavra função.

O exemplo abaixo ilustra todos esses aspectos.

//  OK
função comparar(a, b) {
    retornar a - b
}

//  ???
função comparar ( a, b ) {
    retornar a - b
}

Chamada a uma função

Na chamada a uma função, não deve haver um espaço em branco entre o nome da função e o abre parêntese:

//  OK
seja result = comparar(x, y)

//  ???
seja result = comparar (x, y)

//  ???
seja result = comparar( x, y )

//  ???
seja result = comparar ( x, y )

Na lista de argumentos usados na chamada, que aparece obrigatoriamente entre parênteses, não deve haver um espaço em branco após o abre parêntese nem antes do fecha parêntese.

Posicionamento das chaves

De uma maneira geral, as chaves que delimitam blocos de comandos devem seguir o mesmo modelo que usamos no bloco de comandos de uma função, isto é, o abre chave na mesma linha do início do comando, e o fecha chave numa linha isolada. Assim, por exemplo, para um comando se:

//  OK
se (a > b) {
    a++
    b++
}

//  ???
se (a > b) {
    a++
    b++
    }

//  ???
se (a > b)
{
    a++
    b++
}

Isso vale para todos os comandos.

Use o bloco (abre/fecha chaves) somente se necessário

Quando o comando subordinado é constituído de apenas um comando, não use as chaves que delimitam um bloco. Por exemplo:

//  OK
se (a > b)
    a++
senão
    b++

//  ???
se (a > b) {
    a++
} senão {
    b++
}

Esta é outra recomendação polêmica. Muitos preferem sempre usar as chaves, independentemente do número de comandos. Nós não. Se na parte subordinada há apenas um comando, o bloco entre chaves não deve ser usado.

O exemplo abaixo ilustra isso.

//  OK
se (c === '*' || c === '/')
    op = MULT
senão
    op = SOMA
senão
    opInválido(c)

//  ???
se (c === '*' || c === '/') {
    op = MULT
} senão {
    op = SOMA
} senão {
    opInválido(c)
}

Indentação do comando se com cláusula senão

A indentação do comando se com a cláusula senão também apresenta algumas peculiaridades. Sua forma mais simples é a seguinte:

Para os casos em que há múltiplas cláusulas senão seguidas, a forma mais adequada é a seguinte:

Indentação do comando escolher

O comando escolher possui características especiais em sua indentação. Indicamos a seguinte:

Algumas variações são bem razoáveis. Por exemplo, a de alinhar a indentação dos casos no mesmo nível do comando escolher:

É importante observar que os comandos dentro de cada caso sempre ficam alinhados um nível a mais que as palavras caso. Também como mostram os exemplos acima, indicamos colocar uma linha em branco entre os casos.

Nomes

Conforme já vimos em outro vídeo/post, dar um nome aos itens que compõem um programa é algo que deve ser feito com muito cuidado e atenção.

Veremos a seguir algumas regras que consideramos como critérios que devem ser levados em conta nesse aspecto.

O tamanho do nome depende do contexto

Nomes de coisas exportadas devem ser mais descritivos. Nomes locais devem ser pequenos.

Você pode, por exemplo, exportar funções e variáveis com nomes como:

exibirMapa
inserirElemento
alterarPerfilDeUsuário
numClientes
suprimirConta
maxQtdLivros
ModeloPadrão

Portanto, são nomes mais descritivos. Mas, não é conveniente exagerar. Aqui estão alguns nomes que certamente poderiam ser melhorados:

númeroDeAlunosAbaixoDaMédia
ElementoDaInterfaceGráficaDeUsuário
notaMínimaParaPassarDeAno

Para uma variável de controle de um loop, a melhor escolha é quase sempre i. Se, por algum motivo, não puder ser i, que seja j, k ou ind ou algo similar, com poucos caracteres.

No trecho a seguir, inspirado no livro já citado “The Practice of Programming” (“A Prática da Programação”) de Kernighan e Pike, você vê um exemplo que demonstra claramente a vantagem do uso de variáveis locais com nomes pequenos:

Compare os dois trechos acima e veja qual você considera o mais legível.

Propriedades de um objeto não devem repetir o nome do objeto

Como as propriedades de um objeto são geralmente referenciadas por meio de uma variável que representa o objeto, não é necessário que elas também contenham, em seus nomes, outra referência ao próprio objeto. Exemplo:

Algumas convenções

Nome de funções construtoras devem ter a primeira letra em maiúscula. Quando houver mais de um termo, cada um também deve ter a sua inicial em maiúscula. Exemplos:

Lista
Usuário
ElementoGráfico

Nome de variáveis, de funções (não usadas como construtoras) e de parâmetros de funções devem ter a primeira letra em minúscula. Quando houver mais de um termo, cada um deve ter a sua inicial em maiúscula. Exemplos:

i
temp
pesquisarControles
últimoElemento
conectarPontosOpostos

É também usual a convenção de usar nomes de constantes com todas as letras em maiúsculas:

Esta é uma tradição herdada da linguagem C. Apesar de antiga, é uma convenção que contribui com a legibilidade.