Noções Básicas em

Sobre Noções Básicas

O JavaScript é uma linguagem dinâmica e baseada em protótipos. Tem alguns primitivos, e tudo o resto é considerado um objeto.

Embora seja mais conhecido como a linguagem de script para páginas Web, muitos ambientes fora do navegador também o usam, como o Node.js. A linguagem está em desenvolvimento ativo e, devido à sua natureza multiparadigma, permite muitos estilos de programação. O JavaScript é uma linguagem dinâmica, que suporta estilos orientados a objetos, imperativos e declarativos (por exemplo, a programação funcional).

(Re)Atribuição

Há algumas formas principais de atribuir valores a nomes em JavaScript: usar variáveis ou constantes. No Exercism, as variáveis escrevem-se sempre em camelCase e as constantes em SCREAMING_SNAKE_CASE. Não existe um guia oficial a seguir, e várias empresas e organizações têm guias de estilo diferentes. Escreve as variáveis como quiseres. A vantagem de as escrever como os exercícios estão preparados é que ficarão realçadas de forma diferente na interface web e na maioria das IDEs.

Em JavaScript, as variáveis podem ser definidas com a palavra-chave const, let ou var.

Uma variável pode referenciar valores diferentes ao longo da sua vida quando se usa let ou var. Por exemplo, myFirstVariable pode ser definida e redefinida muitas vezes com o operador de atribuição =:

let myFirstVariable = 1;
myFirstVariable = 'Some string';
myFirstVariable = new SomeComplexClass();

Ao contrário de let e var, as variáveis definidas com const só podem ser atribuídas uma vez. É isto que se usa para definir constantes em JavaScript.

const MY_FIRST_CONSTANT = 10;

// Can not be re-assigned.
MY_FIRST_CONSTANT = 20;
// => TypeError: Assignment to constant variable.

Atribuição de constantes

A palavra-chave const é mencionada tanto para variáveis como para constantes. Outro conceito frequentemente mencionado a propósito das constantes é a (im)mutabilidade.

A palavra-chave const só torna a ligação imutável, ou seja, só podes atribuir um valor a uma variável const uma vez. Em JavaScript, apenas os valores primitivos são imutáveis. No entanto, os valores não primitivos ainda podem ser modificados.

const MY_MUTABLE_VALUE_CONSTANT = { food: 'apple' };

// This is possible
MY_MUTABLE_VALUE_CONSTANT.food = 'pear';

MY_MUTABLE_VALUE_CONSTANT;
// => { food: "pear" }

Valor de uma constante (imutabilidade)

Por regra, no Exercism e em muitos outros guias de estilo de organizações e projetos, não se modificam valores com o aspeto const SCREAMING_SNAKE_CASE. Tecnicamente, os valores podem ser alterados, mas, por uma questão de clareza e de expectativas no Exercism, isso é desaconselhado. Quando isso tiver de ser imposto, usa Object.freeze(value).

const MY_VALUE_CONSTANT = Object.freeze({ food: 'apple' });

// This silently fails
MY_VALUE_CONSTANT.food = 'pear';

MY_VALUE_CONSTANT;
// => { food: "apple" }

No mundo real, é pouco provável ver Object.freeze por todo o código, mas a regra de nunca modificar um valor SCREAMING_SNAKE_CASE é uma boa regra, muitas vezes imposta com análise automática, como um linter.

Declarações de funções

Em JavaScript, as unidades de funcionalidade são encapsuladas em funções, geralmente agrupando no mesmo ficheiro as funções que pertencem umas às outras. Estas funções podem receber parâmetros (argumentos) e podem devolver um valor com a palavra-chave return. As funções são invocadas com a sintaxe ().

function add(num1, num2) {
  return num1 + num2;
}

add(1, 3);
// => 4

💡 Em JavaScript há muitas formas diferentes de declarar uma função. Essas outras formas são diferentes de usar a palavra-chave function. O track tenta apresentá-las gradualmente, mas, se já as conheces, usa à vontade a que preferires. Na maioria dos casos, usar uma ou outra não é melhor nem pior.

Exportar e importar

As palavras-chave export e import são ferramentas poderosas que transformam um ficheiro JavaScript comum num módulo JavaScript. Além de permitirem que o código exponha seletivamente componentes, como funções, classes, variáveis e constantes, também ativam toda uma série de outras funcionalidades, como:

• Renomear exportações e importações, o que te permite evitar conflitos de nomes,
• Importações dinâmicas, que carregam código quando é preciso,
• Tree shaking, que reduz o tamanho do código final ao eliminar módulos sem efeitos secundários e até conteúdos de módulos que não são usados,
• Exportar live bindings, o que te permite exportar um valor que se modifica em todo o lado onde é importado se o valor original se modificar.

Um exemplo concreto é o funcionamento dos testes no track de JavaScript do Exercism. Cada exercício tem pelo menos um ficheiro de implementação, por exemplo lasagna.js, e pelo menos um ficheiro de teste, por exemplo lasagna.spec.js. O ficheiro de implementação usa export para expor a API pública, e o ficheiro de teste usa import para lhe aceder, e é assim que consegue testar os resultados da implementação.

// file.js
export const MY_VALUE = 10;

export function add(num1, num2) {
  return num1 + num2;
}

// file.spec.js
import { MY_VALUE, add } from './file';

add(MY_VALUE, 5);
// => 15