recursal/MDN huggingface dataset:
accent
======

Um **accent** é uma cor tipicamente brilhante que contrasta com as cores de fundo e de primeiro plano mais utilitárias dentro de um esquema de cores. Estes estão presentes no estilo visual de muitas plataformas (embora não todas).

Na web, um acento às vezes é usado em elementos `<input>` para a parte ativa do controle, por exemplo, o plano de fundo de uma caixa de seleção marcada.

Veja tmbém
----------

### CSS relacionado ao **accent**

Você pode definir a cor do `accent` para um determinado elemento definindo a propriedade CSS `accent-color` (en-US) do elemento para o valor `<color>` apropriado.
Operador
========

**Sintaxe** reservada que consiste em pontuação ou caracteres alfanuméricos que executam a funcionalidade incorporada. Por exemplo, em JavaScript, o operador de adição ("+") soma números juntos e concatena strings, enquanto o operador "não" ("!") nega uma expressão — por exemplo, fazendo uma declaração `verdadeira` retornar `falso`.

Aprenda mais
------------

### Conhecimento geral

* Operadores (programação de computadores) na Wikipedia (em inglês)
### Referência técnica

* Operadores JavaScript
ECMA
====

**Ecma International** (oficialmente *Associação Européia dos Fabricantes de Computadores*) é uma organização sem fins lucrativos que desenvolve os padrões para hardware de computadores, comunicações e linguagens de programação.

Na web ela é famosa por ser a organização que mantém a especificação ECMA-262 (também conhecida por ECMAScript (en-US)), que é a especificação núcleo para a linguagem JavaScript.

Aprenda mais
------------

* Ecma International na Wikipedia
* Site do Ecma International
Servidor
========

Um servidor hardware é um computador compartilhado em uma rede que provê serviços a clientes. Um servidor software é um programa que provê serviços a programas clientes.

Os serviços são providos normalmente pela rede local ou por redes remotas. Programas cliente e servidor tradicionalmente se conectam enviando mensagens por meio de um protocolo.

Os servidores mais comuns numa rede local são os de arquivos, nomes, emails, impressoras e fax. Outro exemplo comum de servidor é o de páginas da web conectado à Internet. Os minicomputadores, mainframes e super computadores nas centrais de dados também são servidores.

Aprenda mais
------------

### Conhecimentos Gerais

* Introdução aos servidores
* Servidor na Wikipedia
ARIA
====

**ARIA** (*Accessible Rich Internet Applications*) é uma especificação do W3C para adicionar semântica e outros metadados ao HTML para atender aos usuários de tecnologia assistiva.

Por exemplo, você pode adicionar o atributo `role="alert"` para um `<p>` tag para notificar um usuário com deficiência visual que a informação é importante e sensível ao tempo (que você poderia transmitir através da cor do texto).

Veja também
-----------

* ARIA
Teste de Fuzzing
================

O **Fuzzing** é uma técnica para testar o software usando ferramentas automáticas para fornecer entradas inválidas ou inesperadas para um programa ou função em um programa, logo verificando os resultados para ver se o programa falha ou age de forma inapropriada. Essa é uma forma importante para garantir que o software está estável, confiável e seguro, e nós usamos muito o fuzzing no Mozilla.

* Postagens do blog do Jesse sobre fuzzing
* Wikipedia: Fuzz testing
* fuzzdb
Pré-processador CSS
===================

Um **pré-processador CSS** é um programa que permite você gerar CSS a partir de uma sintaxe (en-US) única desse pré-processador. Existem muitos pré-processadores CSS para escolha, no entanto, a maioria deles irá adicionar algumas funcionalidades extras que não existem no CSS puro, como um mixin, seletores aninhados, herança de seletores, e assim por diante. Essas funcionalidades fazem a estrutura do CSS mais legível e fácil de manter.

Para usar um pré-processador, você deve instalar um compilador CSS no seu servidor web; Ou usar o pré-processador CSS para compilar no ambiente de desenvolvimento, e então fazer upload do arquivo CSS compilado para o servidor web.

1. Alguns dos pré-processadores CSS mais populares:
    1. Sass
    2. LESS
    3. Stylus
    4. PostCSS
2. MDN Web Docs Glossário
    1. CSS
Algoritmo
=========

Um algoritmo é uma série de instruções independentes que executam uma função.
TLS
===

Transport Layer Security (TLS), previamente conhecido como Secure Sockets Layer (SSL), é um protocolo usado por aplicativos para se comunicar de forma segura em toda a rede, evitando adulteração e espionagem no email, navegador, mensagens e outros protocolos.

Todos os navegadores atuais suportam o protocolo TLS, exigindo que o servidor forneça um certificado digital (en-US) válido que confirme sua identidade para estabelecer uma conexão segura. É possível para ambos, o cliente e o servidor, se autentiquem mutuamente, se ambas partes providenciar seus próprios certificados digitais individuais.

### Conhecimento geral

* Transport Layer Security (en-US)
* OWASP: Transport Layer Protection Cheat Sheet
* Transport Layer Security na Wikipedia
### Especificações

* RFC 5246 (The Transport Layer Security Protocol, Version 1.2)
Prototype
=========

A prototype é um modelo que exibe a aparência e o comportamento de um aplicativo ou produto no início do ciclo de vida do desenvolvimento.

See Inheritance and the prototype chain

Saiba mais
----------

### Conhecimento geral

* Software Prototyping on Wikipedia
Função
======

Uma **função** **(function)** é um fragmento de código que pode ser invocado por outro código, por si mesmo ou uma variável que se refere à função. Quando uma função é invocada, o argumento é passado para a função como input (entrada) e a função pode opcionalmente retornar um output (saída). Uma função em JavaScript também é um objeto.

O nome da função é um identificador declarado como parte de uma declaração de função ou expressão de função. O nome da função escopo depende se o nome da função é uma declaração ou expressão.

### Diferentes tipos de funções

Uma **função anônima** é uma função sem o nome da função:


```js
function () {};
// or using the ECMAScript 2015 arrow notation
() => {};
```


Uma **função nomeada** é uma função com o nome da função:


```js
function foo() {}
// or using the ECMAScript 2015 arrow notation
const foo = () => {};
```


Uma **função interna** é uma função dentro de outra função (`square` nesse caso). Uma **função externa** é uma função contendo uma função (`addSquares` nesse caso):


```js
function addSquares(a, b) {
  function square(x) {
    return x \* x;
  }
  return square(a) + square(b);
}
//Using ECMAScript 2015 arrow notation
const addSquares = (a, b) => {
  const square = (x) => x \* x;
  return square(a) + square(b);
};
```


Uma **função recursiva** é uma função que invoca a si mesma. Veja recursão.


```js
function loop(x) {
  if (x >= 10) return;
  loop(x + 1);
}
//Using ECMAScript 2015 arrow notation
const loop = (x) => {
  if (x >= 10) return;
  loop(x + 1);
};
```


Uma **Expressão de Função Invocada Imediatamente** (IIFE em Inglês) é uma função que é invocada diretamente após a função ser carregada no compilador do navegador. A maneira de identificar um IIFE é localizar os parênteses extra esquerdo e direito no final da declaração da função.


```js
// Error (https://en.wikipedia.org/wiki/Immediately-invoked\_function\_expression)
/\*
function foo() {
 console.log('Hello Foo');
}();
\*/

(function foo() {
  console.log("Hello Foo");
})();

(function food() {
  console.log("Hello Food");
})();
```


Se gostaria de saber mais sobre o IIFE, confira a seguinte página no Wikipédia : Immediately Invoked Function Expression

Leia mais
---------

### Referência técnica

* Funções
* Funções Arrow
IndexedDB
=========

IndexedDB é uma API de web para armazenar volumosas estruturas de dados dentro dos navegadores e indexá-los para buscas de alta performance. Sendo um RDBMS baseado em SQL (en-US), IndexedDB é um sistema de banco de dados transacionais. Porém ele usa objetos JavaScript ao invés de tabelas em colunas fixas para armazenar os dados.

Aprenda mais
------------

* The IndexedDB API no MDN
* A especificação W3C para o IndexedDB
Propriedade
===========

O termo **propriedade** **(property)** pode ter diversos siginificados depenedendo do contexto. Ele pode se referir a:

Propriedade (CSS)
Uma **propriedade CSS** é uma característica (como a cor) cujo valor define o aspecto de como o navegador deve exibir o elemento.
Propriedade (JavaScript)
Uma **propriedade Javascript** é uma característica de um objeto, frequentemente descrita como atributos associados à uma estrutura de dados.
Cabeçalho Genérico
==================

Um **cabeçalho genérico** é um  cabeçalho HTTP (en-US) que pode ser de mensagens de solicitação e resposta, mas isso não é aplicado ao seu conteúdo. De acordo com o contexto em que são usados, podem ser cabeçalho de resposta (en-US) ou de Requisição. Entranto, não são cabeçalhos de entidade.

O uso mais comum para cabeçalho genérico é `Date`, `Cache-Control` or `Connection`.
Proxy server
============

Um **servidor proxy** é um computador ou programa intermediário usado ao navegar em conexões de internet diferentes. Eles facilitam o acesso ao conteúdo na rede mundial de computadores. Um proxy intercepta pedidos e exibe respostas; pode encaminhar os pedidos, ou não (por exemplo no caso de uma cache), e pode modificá-los (por exemplo alterando cabeçalhos, no limite entre duas redes)

Um proxy pode estar no computador local do usuário, ou em qualquer lugar entre o computador do usuário e um servidor de destino na internet. Em geral, existem dois tipos principais de servidores proxy:

* Um **proxy de encaminhamento** que lida com pedidos de e para qualquer lugar na internet.
* Um **proxy reverso** que recebe pedidos da Internet e os encaminha para servidores numa rede interna.
Aprenda Mais
------------

* Servidores proxy e túneis (en-US)
* Proxy em Wikipedia
Mutável
=======

*Mutável* é o tipo da variável que pode ser alterada. Em JavaScript, somente objetos e arrays são mutáveis, valores primitivos não.

(Você *pode* fazer o nome da variável apontar para um novo valor, mas o valor anterior continua na memória. Logo, a necessidade da coleta de lixo, "garbage collection")

Um **objeto mutável** é um objeto cujo estado pode ser modificado após sua criação.

**Imutáveis** são os objetos cujo o estado **não** podem ser mudados uma vez criados.

**Strings e Numbers são imutáveis**. Vamos entender isso com um exemplo:
```

var stringImutavel = 'Hello';

// No código acima, um novo objeto com o valor string é criado.

stringImutavel = stringImutavel + 'World';

// Agora nós estamos anexando 'World' ao valor existente.
```


Ao anexar a 'stringImutavel' com um valor de string, os seguintes eventos ocorrem:

1. O valor existente de 'stringImutavel' é recuperado.
2. 'World' é anexado ao valor existente de 'stringImutavel'.
3. O valor resultante é então alocado para um novo bloco na memória.
4. O objeto 'stringImutavel' agora aponta para um novo espaço de memória criado.
5. O espaço de memória criado anteriormente está habilitado para a coleta de lixo.
Aprenda mais
------------

### Conhecimentos gerais

* Objeto Mutavel
OOP
===

**OOP** (Object-Oriented Programming) é uma abordagem na programação em qual os dados são encapsulados em **objects** e o proprio objeto é operado, em vez de suas partes componentes.

JavaScript é altamente orientado à objeto. Isto segue um modelo baseado em **prototypes** (as opposed to class-based).

Aprenda mais
------------

### Conhecimento geral

* Object-oriented programming no Wikipedia
* Introduction to object-oriented JavaScript (en-US)
WebSockets
==========

WebSocket é um protocolo que permite persistir conexões TCP entre o servidor e o cliente de modo que se possa trocar dados a qualquer momento.

Qualquer aplicação de servidor ou cliente pode usar WebSocket, mas principalmente navegadores web e web servers. Através do WebSocket, servidores podem passar dados a um cliente sem um pedido prévio desse cliente, permitindo atualizações dinâmicas de conteúdo.

Learn more
----------

### General knowledge

* Websocket on Wikipedia
### Technical reference

* WebSocket reference on MDN
### Learn about it

* Writing WebSocket client applications (en-US)
* Writing WebSocket servers
Navegador Opera
===============

**Opera** é o quinto navegador web mais usado, publicamente lançado em 1996 e inicialmente executando somente em Windows. Opera usa Blink (en-US) como seu mecanismo de layout desde 2013 (antes disso, Presto (en-US)). Opera também existe nas versões móveis e tablets.

Saiba mais
----------

### Conhecimento geral

* Opera na Wikipedia
* Opera browser web site
Polyfill
========

Um polyfill é um pedaço de código (geralmente JavaScript na Web) usado para fornecer funcionalidades modernas em navegadores mais antigos que não o suportam nativamente.

Por exemplo, um polyfill pode ser usado para imitar a funcionalidade de um elemento HTML Canvas no Microsoft Internet Explorer 7, usando um plugin Silverlight, ou imitar o suporte para unidades rem CSS, ou `text-shadow`, ou o que você quiser.

Aprenda mais
------------

### Conhecimento geral

* O que é polyfill? (artigo em inglês de Remy Sharp, criador do termo)
API
===

Uma API (*Application Programming Interface*) é um conjunto de características e regras existentes em uma aplicação que possibilitam interações com essa através de um software - ao contrário de uma interface de usuário humana. A API pode ser entendida como um simples contrato entre a aplicação que a fornece e outros itens, como outros componentes do software, ou software de terceiros.

No desenvolvimento Web, uma API é geralmente um conjunto de methods (en-US) padronizados, properties, eventos, e URLs que um desenvolvedor pode usar em seus aplicativos para interagir com componentes do navegador da Web de um usuário ou outro software / hardware no computador do usuário ou sites e serviços de terceiros.

Exemplos
--------

* A API getUserMedia (en-US) pode ser usada para capturar áudio e vídeo da webcam de um usuário, que pode ser usada de qualquer maneira que o desenvolvedor goste, por exemplo, gravar vídeo e áudio, transmiti-lo para outro usuário em uma chamada em conferência ou capturar imagens do vídeo.
* A API de geolocalização pode ser usada para recuperar informações de localização de qualquer serviço que o usuário tenha disponível em seu dispositivo (por exemplo, GPS), que pode ser usado em conjunto com as APIs do Google Maps para, por exemplo, traçar a localização do usuário em um mapa personalizado e mostrar a ele que atrações turísticas estão em sua área.
* As APIs do Twitter podem ser usadas para recuperar dados de contas de twitter de um usuário, para por exemplo, exibir seus últimos tweets em uma página da web.
* A API de animações da Web (en-US) pode ser usada para animar partes de uma página da web - por exemplo, para fazer imagens se movimentarem ou girarem.
Aprenda mais
------------

Conhecimento geral
------------------

* API no Wikipedia
### Referência técnica

* Web API reference
Call stack (Pilha de chamadas)
==============================

A pilha de chamadas **(call stack)** é um mecanismo do interpretador de uma linguagem que organiza o funcionamento do script quando são chamadas muitas funções, qual função está sendo executada no momento, e quais serão chamadas dentro de alguma função, etc.

* Quando o script chama a função, ela é adicionada à pilha de chamadas, e então é iniciado o carregamento da função.
* Qualquer função chamada por essa função será adicionada à pilha de chamadas uma acima da outra.
* Quando a função termina a execução, o interpretador retira a função da pilha e continua a execução do programa de onde parou.
* Caso a pilha ocupar mais espaço do que foi separado a ela, será exibido um erro "stack overflow" (estouro de pilha).
Exemplo
-------


```js
function saudacao() {
  // [1] Algum código aqui
  digaOi();
  // [2] Algum código aqui
}
function digaOi() {
  return "Olá!";
}

// Chamando a função `saudacao`
saudacao();

// [3] Algum código aqui
```


O código acima será executado desta forma pelo interpretador:

1. Todas as funções serão ignoradas, até chegar na chamada da função `saudacao()`.
2. Adiciona a função `saudacao()` para a pilha de chamadas.


**Nota:** Pilha de chamadas:
 - saudacao
3. Executa todas as linhas de código da função `saudacao()`.
4. Chama a função `digaOi()`.
5. Adiciona a função `digaOi()` na pilha de chamadas.


**Nota:** Pilha de chamadas:
 - `saudacao` > - digaOi
6. Executa todas as linhas de código da função `digaOi()` até o final.
7. Retorna a execução na linha onde foi chamada a função `digaOi()` e continua a execução do resto da função `saudacao()`.
8. Deleta a função `digaOi()` da pilha de chamadas.


**Nota:** Pilha de chamadas:
 - `saudacao`
9. Quando todas as linhas da função `saudacao()` forem executadas, retorna para a linha onde a função foi invocada, e continua a execução do resto do código.
10. Deleta a função `saudacao()` da Pilha de chamadas.


**Nota:** Pilha de chamadas:
 EMPTY

Começamos com uma pilha de chamadas vazia, e sempre que chamamos uma função, ela é automaticamente adicionada à pilha de chamadas, e depois de todas as linhas serem executadas, é automaticamente removida da pilha de chamadas. No final, a pilha está vazia novamente.

Veja mais
---------

### General knowledge

* Call stack on Wikipedia
* MDN Web Docs Glossary
    + Call stack
    + Function
Primitivo
=========

Resumo
------

Um **primitivo** (valor primitivo, tipo de dados primitivo) é um dado que não é representado através de um Objeto e, por consequência, não possui métodos.

Em detalhes
-----------

Na maior parte do tempo, um valor primitivo é representado diretamente através do mais baixo nível da implementação de uma linguagem.

No JavaScript, existem 6 tipos primitivos:

* String
* Number
* Boolean
* Null
* undefined
* Symbol (novo no ECMAScript (en-US) 6)

Todos os primitivos são **imutáveis** (não podem ter o seu valor modificado).

### Wrappers em JavaScript

> 
> NT: O termo "wrapper" em português significa "que envolve". No entanto, em tecnologia, é comum se usar a versão em inglês que possui o mesmo significado.
> 
> 
> 

À exceção do `null` e do `undefined`, todos os primitivos tem um objeto wrapper equivalente:

* `String` para o primitivo string.
* `Number` para o primitivo .
* `Boolean` para o primitivo Boolean.
* `Symbol` para o primitivo Symbol.

O método valueOf() do objeto wrapper retorna o valor primitivo.

> 
> NT: É possível verificar o tipo da variável digitando typeof+nomedavariavel. Para saber mais, verifique typeof.
> 
> 
> 

Referências externas
--------------------

* Primitive data types on Wikipedia (em inglês)
* Tipo de dado
Alpha (canal alfa)
==================

Cores são representadas no formato digital como uma coleção de números, cada qual sinalizando o nível de força ou intensidade de dado componente da cor. Cada um desses componententes é chamado de **canal**. Num típico arquivo de imagem, o canais de cores descritos devem ser vermelho, verde e azul, que serão usados para definir a cor final. Para representar uma cor que através dela um plano de fundo possa ser visto, um quarto canal é adicionado a ela: o canal alfa. O canal alfa define o nível de opacidade da cor.

Por exemplo, a cor `#8921F2` (também descrita como `rgb(137, 33, 242)` ou `hsl(270, 89%, 54)`) é um belo tom de roxo. Abaixo você pode ver um pequeno retângulo no canto superior esquerdo e outro com a mesma cor, mas tendo um canal alfa defino em 0.5 (50% de opacidade). Os dois retângulos estão desenhados sobre o paragrafo de texto.

![Image showing the effect of an alpha channel on a color.](/pt-BR/docs/Glossary/Alpha/alpha-channel-example.png)

Como você pode notar, a cor sem o canal alfa bloqueia completamente o texto ao fundo, enquanto o retângulo com canal alfa definido permite visibilidade através do plano de fundo com cor roxa.

Saiba mais
----------

### Conhecimento geral

* Alpha compositing na Wikipedia
* RGBA color model na Wikipedia
* Channel (digital image) na Wikipedia
### Referência técnica

* CSS color (en-US)
Elementos inline
================

### Sumário

"Inline" é uma categorização dos elementos do HTML, em contraste com os "elementos de bloco" (en-US). Os elementos inline podem ser exibidos em nível de bloco ou outros elementos inline. Eles ocupam somente a largura de seu conteúdo. A diferença entre elementos inline e bloco incluem:

Modelo de conteúdo

Geralmente, elementos inline devem ter somente dados em outros elementos inline.

Formato

Por padrão, os elementos inline não começam em uma nova linha.

### Elementos

Listagem dos elementos que são "inline":

* b, big, i, small, tt
* abbr, acronym, cite, code, dfn, em, kbd, strong, samp, var
* a, bdo, br, img, map, object, q, script, span, sub, sup
* button, input, label, select, textarea
### Ver também

* Elementos de nível de bloco
Pseudo-element
==============

Em CSS, um seletor **pseudo-element** aplica estilos em partes do conteúdo do seu documento em cenários onde não há elementos HTML específicos para selecionar. Por exemplo, em vez de colocar a primeira letra para cada parágrafo em seu próprio elemento. você pode estilizá-los todos com `p``::first-letter`.

Aprenda mais
------------

### Referência técnica

* Pseudo-elements
Sloppy mode
===========

A partir do ECMAScript (en-US) 5 é possível optar pelo novo strict mode (modo estrito), que altera a semântica do JavaScript de várias maneiras para melhorar sua resiliência e facilitar a compreensão do que está acontecendo quando há problemas.

O modo normal e non-strict (não estrito) do JavaScript é às vezes chamado de **sloppy mode** (modo desleixado, literalmente). Esta não é uma designação oficial, mas você provavelmente irá se deparar com ela se passar algum tempo escrevendo código JavaScript.

Saiba mais
----------

### Conecimentos Gerais

* "Strict Mode" no capítulo 7 ("JavaScript Syntax") do livro Speaking *JavaScript*.
Seguro
======

Um método HTTP é **seguro** se ele não altera o estado do servidor. Em outras palavras, um método é seguro se ele leva a uma operação de somente leitura. Diversos métodos de HTTP são seguros: `GET`, `HEAD`, ou `OPTIONS`. Todos os métodos seguros também são idempotentes, mas nem todos os métodos idempotentes são seguros. Por exemplo, `PUT` e `DELETE` são ambos idempotentes, entretanto são inseguros.

Mesmo se métodos seguros possuem a semântica de somente leitura, servidores podem alterar o seu estado (e.g., eles podem manter *log* ou estatísticas). O que é importante aqui, é de que chamando um método seguro, o cliente não requer que o servidor mude seu estado, e portanto não gerará carga desnecessária ao servidor. Navegadores podem chamar métodos seguros sem medo de causarem nenhum dano ao servidor: isso permite a eles a possibilidade de fazer atividades como pré-carregamento sem nenhum risco. *Web crawlers* também usam métodos seguros.

Métodos seguros não servem somente para buscar arquivos estáticos, o servidor pode gerar uma resposta para um método seguro no voô, enquanto o *script* gerador garantir segurança: ele não deve ativar gatilhos externos, como ativar um pedido de compras em um site.

É responsabilidade da aplicação no servidor implementar a semântica segura corretamente, o servidor *web* em si, sendo Apache, nginx ou IIS, não pode forçar ela por si só. Em particular, a aplicação não deve permitir que requisições `GET` alterem seu estado.

Uma chamada a um método seguro, não alterando o estado do servidor:
```

GET /pageX.html HTTP/1.1
```


Uma chamada a um método não seguro, que pode alterar o estado do servidor:
```

POST /pageX.html HTTP/1.1
```


Uma chamada a um método idempotente, mas não seguro:
```

DELETE /idX/delete HTTP/1.1
```

Aprenda mais
------------

### Conhecimento geral

* Definição de seguro na especificação HTTP.
### Conhecimento técnico

* Descrição de métodos seguros comuns: `GET`, `HEAD`, `OPTIONS`
* Descrição de métodos inseguros comuns: `PUT`, `DELETE`, `POST`