Aplicativos podem conter configurações sensíveis que não devem ser incluídas em controle de versão. Configurações são, por exemplo, normalmente isoladas em um arquivo com definições de variáveis. Outros usam um arquivo de propriedades no formato JSON. Uma boa prática é isolar mais ainda os valores que são sensíveis em um módulo de segredos.

Uma opção para centralizar e armazenar segredos na nuvem é o Azure Key Vault, traduzido Cofres de Chave. Além de armazenar pares de chave e valor, o Azure Key Vault também lhe permite guardar keys ("chaves") e certificates ("certificados").

Este artigo mostra como armazenar segredos em um aplicativo Node.js usando o Azure Key Vault.

## Cofre de Chaves no Portal do Azure

Depois de cadastrar uma conta no Azure e entrar no sistema, procure por Key Vault, ou `Cofres de chave` em português.

Clique `+ Criar`. Escolha uma assinatura e um grupo de recursos (crie se não tiver um). Digite o nome para o cofre de chaves. Escolha a região e o esquema de preço ("Tipo de preço"). Se quiser modificar as outras opções, sinta-se à vontade. Clique `Próxima`.

Na aba de `Política de accesso`, pode pular porque vamos configurar depois. Clique `Próxima`. Continue a clicar `Próxima` até chegar à aba de `Revisar + criar`. Verifique que tudo está nos conformes e finalmente clique `Criar`.

Vá para a página do cofre e clique `Segredos` na barra lateral.

![Segredos no Azure Key Vault](https://nbkmundotech.us-southeast-1.linodeobjects.com/static/images/ffac7e24-108d-450c-ad5f-da0d60a5a25c.png)

Clique `Gerar/Importar` para adicionar um novo segredo. Escreva o nome e o valor secreto. Conclua com o clique de `Criar`.

![Criar um Segredo no Azure Key Vault](https://nbkmundotech.us-southeast-1.linodeobjects.com/static/images/95d3f926-53d2-4bb5-b183-b47e2525576c.png)

Para acessar o cofre de um aplicativo, precisamos de credenciais. Vamos ver sobre isso na próxima seção.

## Registro de Aplicativo no Azure

O cofre vai precisar de um registro para o qual habilitar a leitura dos segredos. No Portal do Azure, procure por App Registrations, traduzido "Registros de aplicativo".

Clique `+ Novo registro`. Digite um nome para o registro de aplicativo. Lembre-se desse nome pois depois vamos precisar dele para associar à permissão de leitura do cofre. Deixe as configurações padrão ou mude ao seu gosto. Finalize com o clique de `Registrar`.

Na página do novo registro de aplicativo, escolha `Certificados e segredos` na barra lateral. Na aba de `Segredos do cliente`, clique `+ Novo segredo do cliente`. Dê um nome ao segredo do cliente. Finalize ao clicar `Adicionar`.

Anote o valor do segredo do cliente (client secret) pois ele não será exibido novamente.

Copie também o ID secreto (client id; esse pode ser visto novamente).

Clique `Visão geral` na barra lateral da página do registro de aplicativo e copie o ID do diretório (locatário), traduzido de directory (ou tenant) id. Precisaremos desses três valores para conectar ao cofre de chaves partindo do Node.js.

![Segredos de um Registro de Aplicativo no Azure](https://nbkmundotech.us-southeast-1.linodeobjects.com/static/images/086c48c7-9cf1-498c-9452-1e04500418a7.png)

## Políticas de Acesso do Cofre

Agora, volte à página do Cofre de Chaves. Na barra lateral, clique `Políticas de acesso` e em seguida clique `+ Criar`.

A primeira seção lhe permite definir que permissões específicas o registro de aplicativo terá. Seguiremos o Princípio de Menor Privilégio ("least privilege") e só permitiremos `Obter` e `Listar` para a coluna de `Permissões do segredo`. O primeiro lhe permite ler um segredo enquanto o segundo lhe permite obter a lista de segredos. Se você precisar de mais permissões no futuro, dá para editá-las depois da criação. De qualquer maneira, clique `Próxima`.

Digite na caixa de texto o nome do registro de aplicativo que foi criado anteriormente. Clique `Próxima` até chegar em `Revisar + criar`. Verifique os dados e clique `Criar`.

![Políticas de acesso no Azure Key Vault](https://nbkmundotech.us-southeast-1.linodeobjects.com/static/images/b3281425-24a6-4e66-a426-b869257acbf4.png)

## Como Acessar os Segredos do Cofre de Chaves no Node.js

Agora veremos como escrever o código em Node.js (JavaScript no servidor) para acessar os segredos do cofre de chaves. Com o Node.js e o NPM instalado, faça o seguinte:

No terminal, instale os seguintes módulos de NPM:

```sh
npm install @azure/identity @azure/keyvault-secrets
```

O módulo `@azure/identity` será usado para gerar um objeto de credencial que será usado por um cliente de segredos do módulo `@azure/keyvault-secrets`.

Vamos para o código em Node.js:

```js
const AzureIdentity = require('@azure/identity');
const AzureKeyvaultSecrets = require('@azure/keyvault-secrets');

// Pegue os valores que foram copiados anteriormente na parte do registro de aplicativo. Esses valores podem ser obtidos localmente de um arquivo de configuração ou da nuvem de um serviço de configuração como o Azure App Configuration. Recomendo não incluir esse tipo de informação diretamente no código no controle de versão.
const AzureTenantId = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx';
const AzureClientId = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx';
const AzureClientSecret = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';

const credencial = new AzureIdentity.ClientSecretCredential(
  AzureTenantId,
  AzureClientId,
  AzureClientSecret
);
```

No exemplo acima, importamos os módulos necessários para criar uma credencial e para criar um cliente de segredos. A maneira usada aqui para autenticar é com um ClientSecretCredential: forneça o id do diretório (locatário), o id do cliente e o segredo do cliente. Em inglês, AzureTenantId, AzureClientId e AzureClientSecret, respectivamente.

Há outras maneiras de se autenticar, especialmente se você já tiver um aplicativo rodando na nuvem do Azure, mas nesse artigo focarei na maneira de autenticação usada acima. Recomendo ler a documentação do Azure para adaptar o exemplo para outro método.

Agora, vamos criar um cliente para poder acessar o cofre de chaves:

```js
// Precisamos saber do nome do cofre de chaves para acessá-lo. Recomendo incluir esse valor no seu módulo de configuração.
const keyVaultName = 'meu-cofre-de-chaves';

const clienteDeSegredo = new AzureKeyvaultSecrets.SecretClient(`https://${keyVaultName}.vault.azure.net`, credencial);
```

Cria-se um cliente de segredo, SecretClient, ao especificar a URL do cofre de chaves e a credencial. O endereço do cofre pode ser verificado na página do cofre, na `Visão geral`. 

Agora, mostrarei uma maneira de se resgatar todos os segredos atráves de um loop:

```js
for await (const propriedadesDeSegredo of clienteDeSegredo.listPropertiesOfSecrets()) {
  const segredoDaNuvem = await clienteDeSegredo.getSecret(propriedadesDeSegredo.name);
  // Faça o que quiser com o valor aqui:
  console.log(segredoDaNuvem.value);
}
```

No exemplo acima, o método `listPropertiesOfSecrets` lhe retorna uma lista de propriedades de segredos que podem ser usados em uma repetição. O valor retornado do método é uma promessa, então precisamos usar o `for await`.

Para cada `propriedadesDeSegredo`, podemos acessar o nome do segredo pela propriedade `propriedadesDeSegredo.name`.

No caso do valor, não dá para obtê-lo diretamente do `propriedadesDeSegredo`. Temos que chamar a API do cofre de novo com o método `getSecret`, que retorna um objeto com informações do segredo específico. O nome do segredo tem que ser fornecido como argumento para a função `getSecret`.

Como o `getSecret` retorna uma promessa, temos que pegar o valor resolvido com o `await`. Colocamos numa variável chamada `segredoDaNuvem`. Daí é só acessar o valor do segredo com `segredoDaNuvem.value`.

## Integração do Azure Key Vault em um Aplicativo Existente

Há várias maneiras de integrar o uso do Cofres de Chave do Azure no seu aplicativo. Deixo aqui umas sugestões.

Em ambos o exemplos citados abaixo, se cria um arquivo para um módulo central de segredos que pode ser chamado a qualquer hora para obter os valores. A implementação específica, se for com funções, objeto primitivo, ou classe, depende do seu gosto.

Se você quiser economizar nas chamadas da API, você pode carregar os segredos uma vez só na hora do aplicativo iniciar. Nesse caso, os valores do segredos são armazenados na memória enquanto o aplicativo roda. Para recarregar os valores, você teria que reiniciar o aplicativo. Para certos usos, talvez você não queira manter os valores na memória constantemente, então veja o próximo exemplo.

Outra maneira de se integrar o Azure Key Vault é sempre carregar os valores na hora que eles forem requeridos. Esse método é mais caro, pois faz uma chamada de API a cada vez que um valor é requerido. É provavelmente mais seguro em termos de não manter o valor na memória constantemente (dependendo de como o seu aplicativo foi escrito) pois só aparece e é usado só quando for requerido.

Cabe a você entender o seu aplicativo, os casos de uso e o nível de tolerância de risco. Mostramos aqui apenas uns exemplos para estimular a mente com idéias. Como sempre, recomendo aprimorar sempre naquilo que aprendeu e adaptar as idéias ao seu contexto.


Segredos na Nuvem com o Azure Key Vault para Aplicativos Node.js

Certos valores de um aplicativo são isolados em arquivos de configuração. Por exemplo, com variáveis definidas em um arquivo `.env` ou propriedades definidas em um arquivo de formato `.json`.

Hoje em dia podemos centralizar os valores de configuração de um aplicativo na nuvem. Um dos servições de configuração de aplicativo é o Azure App Configuration.

## App Configuration no Portal do Azure

Depois de criar uma conta no Azure e entrar no sistema, procure por App Configuration. Clique `+ Criar`.

Escolha a sua assinatura e um grupo de recursos (crie um se não tiver ainda). 

Nos detalhes de instância, escolha a sua localização. Depois digite um nome para o recurso ("Resource name"). Escolha o esquema de preço ("Pricing tier").

Siga para a próxima seção após clicar `Next`. As próximas seções são opcionais e cabe a você mudar se quiser.

A última seção é para rever o plano. Se tudo estiver nos conformes, clique `Create` para terminar.

Na página da sua instância do App Configuration, tem o `Configuration explorer` na barra lateral.

![Azure App Configuration Explorer](https://nbkmundotech.us-southeast-1.linodeobjects.com/static/images/5b760e8c-5617-4507-b410-1ccb4afcf1c6.png)

Pode-se criar valores de configuração se clicar, na seção do conteúdo principal, `+ Create`, seguido de `Key-value`. Escolha um nome para a chave ("Key") e siga com o seu valor na caixa de texto seguinte ("Value"). Clique `Apply`.

Antes de irmos para o código, é preciso obter as credenciais para acessar os pares de chave-valor. Há maneiras diferentes de se autenticar. Nesse exemplo, usaremos a string de conexão. Clique `Access keys` na barra lateral. Neste exemplo, só permitirei leitura dos valores de configuração, então clique na aba de `Read-only keys`. Copie a string de conexão ("Connection string"), pois este valor será usado no código.

## Biblioteca Cliente para JavaScript

Agora vamos ver como obter os valores da nuvem de um aplicativo de Node.js.

Primeiro de tudo, tem que ter o Node.js e o NPM instalado (outro gerenciador também serve). Instale o seguinte, em um terminal:

```sh
npm install @azure/app-configuration
```

Agora, vamos para o código:

```js
const AzureAppConfiguration = require("@azure/app-configuration");

// Aqui se coloca a string de conexão que foi copiada do portal do Azure
// Sugiro armazenar em um arquivo de configuração, provavelmente não incluído em commit
const AzureAppConfigConnectionString = "Endpoint=https://<seu-app-config>.azconfig.io;Id=<seu-id>;Secret=<seu-secret>";

const appConfigurationClient = new AzureAppConfiguration.AppConfigurationClient(AzureAppConfigConnectionString);
```

Para usar o cliente de configuração de app, o AppConfigurationClient, precisamos importar do módulo `@azure/app-configuration`. Depois, criamos uma instância do cliente, passando a string de conexão como argumento.

Existem várias maneiras de obter os valores de configuração. Nessa demonstração, vamos obter todos os pares de chave-valor:

```js
for await (const configurationSetting of appConfigurationClient.listConfigurationSettings()) {
  // Faça o que quiser aqui com a chave e o valor
  // Por exemplo, armazenar os valores de configuração em uma variável na memória
  // para o uso posterior
  console.log({
    chave: configurationSetting.key,
    valor: configurationSetting.value
  });
}
```

O exemplo acima usa o método `listConfigurationSettings()` para iterar sobre todos os pares de chave-valor. Usamos uma repetição com o `await` porque o método retorna uma promessa. O objeto resolvido de cada promessa da repetição contém as propriedades de chave e do valor: `key` e `value`, respectivamente.

## Integração em um Aplicativo Existente

Há várias maneiras de integrar o uso de Azure App Configuration no seu aplicativo.

Em ambos o casos que serão citados abaixo, se cria um arquivo para um módulo central de configuração que pode ser chamado a qualquer hora para obter os valores. A implementação específica, se for somente com funções, objeto, ou classe, depende do seu gosto.

Se você quiser economizar nas chamadas da API, você pode carregar as configurações uma vez só na hora do aplicativo iniciar. Nesse caso, os valores de configuração são armazenados na memória enquanto o aplicativo roda. Para recarregar os valores, você teria que reiniciar o aplicativo.

Outra maneira de se integrar o App Configuration é sempre carregar os valores na hora que eles forem requeridos. Esse método é mais caro, pois faz uma chamada de API a cada vez que um valor é requerido. Para economizar um pouco mais, cache, a prática de se lembrar dos valores por um certo tempo para evitar fazer as mesmas requisições repetidamente, pode ser implementado. Verifique na documentação do Azure App Configuration, pois provalmente já tem essa funcionalidade.


Como Carregar Configuração de Aplicativo do Azure App Configuration

Em programação orientada à objetos, os atributos de um objeto são normalmente definidos com acesso privado para não serem lidos ou modificados diretamente. Em vez do acesso direto a propriedade, funções *getter* e *setter* são definidas para disponibilizar uma API de leitura e modificação, respectivamente.

Por exemplo, suponha que temos uma classe que representa um veículo:

```
class Veiculo {
  private marca: string;

  constructor(aMarca: string) {
    this.marca = aMarca;
  }

  obterMarca() {
    return this.marca;
  }

  modificarMarca(novaMarca: string) {
    this.marca = novaMarca;
  }
}
```

Podemos criar um veículo da seguinte maneira:

```
let carro = new Veiculo("Honda");
```

Mas o acesso e modificação da marca do veículo após sua construção não é permitida:

```
console.log(carro.marca);
carro.marca = "Toyota";
```

O compilador mostra o seguinte erro para ambas as expressões:

```
Property 'marca' is private and only accessible within class 'Veiculo'.
```

Vamos agora criar uma classe derivadas de um Veiculo: `Carro`. Veja o código abaixo:

```
class Carro extends Veiculo {
  imprimirMarca() {
    console.log(this.marca);
  }
}
```

A classe `Carro` herda o `constructor` da base classe `Veiculo`, então não precisamos defini-lo novamente.

O metodo `imprimirMarca` vai dar erro porque `this.marca` não é acessível da classe derivada, `Carro`. A marca é uma propriedade da base classe `Veiculo`, com acesso `private`:

```
Property 'marca' is private and only accessible within class 'Veiculo'.
```

Para podermos ter acesso direto de uma propriedade da base classe na classe derivada, precisamos usar o modo de acesso **protected**:

```
class Veiculo {
  protected marca: string;

  // ...
}
```

Agora, a chamada de `imprimirMarca` de um objeto da classe `Carro` irá funcionar sem problemas. O acesso à propriedade `marca` da superclasse `Veiculo` é permitido.

Para aprender mais sobre o TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=jOJYBcjJ0CE&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


Como Usar protected para Acessar Membros Privados de uma Base Classe no TypeScript

A palavra-chave `class`, introduzida no ECMAScript 2015, nos permite definir uma classe em JavaScript. O TypeScript também tem suporte ao paradigma. Um dos elementos da programação orientada à objetos é a herança de classes para reutilizar o código. No JavaScript tradicional, a herança é feita através de protótipos. Já com a palavra-chave `class`, podemos fazer a herança através da palavra-chave `extends`.

Vamos supor que temos uma base classe chamada `Individuo`. Vamos simplificar o nosso exemplo e considerar mais duas classes: um individuo poderia ser um estudante ou um funcionário de uma empresa. Por causa disso, podemos usar herança e definir que:

```
Um Estudante é um Individuo
Um Funcionario é um Individuo
```

Então a base classe é `Individuo` e as classes derivadas são `Estudante` e `Funcionario`. O primeiro é também chamado de superclasse e os segundos são subclasses.

Vamos aprender com um código. Primeiro definimos a base classe:

```
class Individuo {
  nome: string;
  constructor(oNome: string) {
    this.nome = oNome;
  }
}
```

Agora, para herdarmos da base classe, usamos a palavra-chave `extends` logo após o nome dela. Depois segue com o nome da classe derivada:

```
class Estudante extends Individuo {
}

class Funcionario extends Individuo {
}
```

Não definimos nenhum membro para as classes derivadas, mas ambas irão herdar a propriedade `nome` e o `constructor` de `Individuo`.

Podemos então adicionar propriedades e métodos específicos para cada subclasse. Por exemplo, um `Estudante` tem uma `disciplina` de estudo e um funcionário tem um `salario`.

```
class Estudante extends Individuo {
  disciplina: string;

  constructor(oNome: string, aDisciplina: string) {
    super(oNome);
    this.disciplina = aDisciplina;
  }
}

class Funcionario extends Individuo {
  salario: number;

  constructor(oNome: string, oSalario: number) {
    super(oNome);
    this.salario = oSalario;
  }
}
```

No exemplo acima, precisamos adicionar um novo `constructor` à cada classe derivada para poder iniciar as propriedades específicas de cada classe. Note que podemos reutilizar o código do constructor da base classe `Individuo` com a chamada de `super`.

É importante ressaltar que `super` deve ser chamado para iniciar os valores compartilhados através da base classe e que não se deve referenciar `this.` no corpo do constructor antes da chamada de `super()`.

Vamos testar nossas classes:

```
let fJoao: Funcionario = new Funcionario("Joao", 123);
let eAna: Estudante = new Estudante("Ana", "Arquitetura");
```

Note que também podemos criar uma variável do tipo da base classe e ainda armazenar tanto um `Estudante` como um `Funcionario`:

```
let individuo: Individuo = fJoao;
individuo = eAna;
```

O código acima funciona porque um `Funcionario` é um `Individuo` e um `Estudante` também é um `Individuo`.

Para aprender mais sobre o TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=jOJYBcjJ0CE&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


Herança de Classes no TypeScript

A programação orientada à objetos no JavaScript é originalmente realizada através de funções e herança prototípica. Com o advento do ECMAScript 2015, coloquialmente chamado de “ES6”, foi adicionada a palavra chave **class**, agora nos permitindo criar classes de maneira similar à linguagens como C++, C#, e Java.

O TypeScript também tem suporte a declaração de classes através da palavra chave `class`. Vamos ver um exemplo:

```
class Forma {
  nome: string;

  constructor(oNome: string) {
    this.nome = oNome;
  }
}
```

O exemplo acima define uma classe chamada de `Forma`, que tem como atributo a propriedade `nome`. A função `constructor()` é chamada quando você construir um objeto baseado na classe e atribui um nome à forma.

O acesso de membros da classe é por padrão `public`, se nada for definido explicitamente. Entao podemos instanciar um objeto e acessar a propriedade `nome` diretamente:

```
let retang: Forma = new Forma("Retangulo");
console.log(`O nome da forma é ${retang.nome}`);
```

A expressão acima primeiro declara uma variável do tipo `Forma` e atribui ao seu valor uma nova instância de `Forma`, com o nome Retangulo. Note que a string Retangulo é passada como argumento para o `constructor`, que por si atribui o nome do objeto `this.nome`.

O `console.log` imprime uma mensagem que inclui acesso ao nome da Forma diretamente, sem passar por um método *getter*.

Vamos adicionar duas propriedades à classe Forma: `largura` e `altura`. Ambas devem ser do tipo `number`.

```
class Forma {
  nome: string;
  largura: number;
  altura: number;

  constructor(oNome: string, aLargura: number, aAltura: number) {
    this.nome = oNome;
    this.largura = aLargura;
    this.altura = aAltura;
  }
}
```

Agora podemos fazer um método para calcular a área da forma:

```
class Forma {
  // ...
  public obterArea(): number {
    return this.largura * this.altura;
  }
}
```

Como já mencionado, o acesso dos membros de uma classe em TypeScript é `public` por padrão, mas o exemplo acima o define explicitamente. Acesso público significa que o membro pode ser referenciado por fora da classe. Isso é o oposto do acesso privado (`private`), em que é proibido a referência do membro de fora da classe ou instância.

O método não tem nenhum parâmetro porque os valores necessários para calcular a área já são parte dos atributos do objeto.

O tipo do valor de retorno do método `obterArea` é explicitamente definido como `number`, mas poderia ser omitido e o compilador deduziria o tipo ao analizar a expressão de retorno.

Vamos testar o método `obterArea`:

```
let retang: Forma = new Forma("Retangulo", 3, 4);
console.log(`A area do retângulo é ${retang.obterArea()}`);
```

Saída:

```
A area do retângulo é 12
```

Para não expor os atributos `largura` e `altura` do objeto ao mundo de fora, que tal redefinir essas propriedades com acesso privado?

```
class Forma {
  // ...
  private largura: number;
  private altura: number;
  // ...
}
```

Dessa maneira, se o usuário do objeto tentar referenciar `retang.largura`, o compilador irá emitir um erro dizendo que o acesso não é permitido devido a propriedade ser privada:

```
Property 'largura' is private and only accessible within class 'Forma'.
```

Para aprender mais sobre o TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=czp3QV55v1k&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


Uma Breve Introdução a Classes no TypeScript

No JavaScript, temos funções nomeadas e funções anônimas. O segundo tipo pode ser armazenado em uma variável, como no exemplo abaixo, já escrito com anotações de tipo do TypeScript:

```
let minhaFuncao = function(a: string, b: number): string {
  return `O valor da string é ${a} e o valor do numero é ${b}`;
};
```

Variáveis no TypeScript podem ter uma anotação de tipo, por exemplo:

```
let meuNumero: number = 48;
```

A expressão acima declara uma variável do tipo `number` com o valor 48.

Podemos adicionar o tipo de uma variável que armazena uma função da seguinte maneira, usando o nosso exemplo anterior:

```
let minhaFuncao: (x: string, y: number) => string =
function(a: string, b: number): string {
  return `O valor da string é ${a} e o valor do numero é ${b}`;
};
```

No exemplo acima, o tipo da variável `minhaFuncao` é a assinatura de função `(x: string, y: number) => string`.

Os nomes dos parâmetros foram mudados de propósito para você saber que o que importam são os tipos e não os nomes. O nome da variável na assinatura pode ser diferente da definição no lado direito do igual, mas os tipos não podem ser diferentes.

Note que separamos os parâmetros de entrada do tipo do valor de saída com a seta `=>`. No exemplo, temos como parâmetros da função o `x` e `y`, de tipo `string` e `number`, respectivamente. O tipo do valor de retorno e declarado no lado direito da seta `=>`, nesse caso uma `string`.

Declarar a assinatura do tipo da variável as vezes pode deixar a linha muito longa, então podemos aproveitar a inferência de tipo do compilador do TypeScript. Às vezes definindo de um lado da expressão basta para que o compilador deduza os tipos do outro lado.

Para aprender mais sobre o TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=jOJYBcjJ0CE&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


Como Definir o Tipo de uma Variável que Armazena uma Função no TypeScript

Considere uma simples função que leva dois números como argumento. O valor de retorno é a multiplicação dos dois números:

```
function multiplicar(a: number, b: number) {
  return a * b;
}
```

O compilador do TypeScript é inteligente e deduz o tipo do valor de retorno da função acima baseado na expressão de retorno. Mas se você quiser definir o tipo do valor de retorno explicitamente, adicione os dois pontos e o tipo logo após a lista de parâmetros entre os parênteses:

```
function multiplicar(a: number, b: number): number {
  return a * b;
}
```

No exemplo acima, a expressão `a * b` resulta em um valor do tipo `number`, o mesmo tipo definido explicitamente na parte de retorno da assinatura da função.

Para aprender mais sobre o TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=jOJYBcjJ0CE&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


Como Adicionar o Tipo de Retorno de uma Função em TypeScript

Considere um exemplo de herança entre duas classes: a base classe Veiculo e a classe derivada Carro:

```
class Veiculo {
  constructor() {
  }
}

class Carro extends Veiculo {
  constructor() {
    super();
  }
}
```

Os construtores foram definidos em branco para focarmos no assunto de construtores protegidos.

Considere as seguintes expressoes:

```
let umVeiculo: Veiculo;
umVeiculo = new Carro();
```

A variável `umVeiculo` é declarada com tipo `Veiculo`. Podemos atribuir um objeto do tipo `Carro` à essa variàvel porque um `Carro` é um `Veiculo`.

Agora vamos ver outra expressão:

```
let veiculo: Veiculo = new Veiculo();
```

Nesse caso criamos um objeto usando a base classe `Veiculo`. Mas há situações em que não queremos permitir a instanciação de objetos do tipo da base classe. Isto é, só queremos permitir a construção de instância de objetos cuja classe é `Carro`, `Moto`, etc.

A maneira de resolver o problema é através da palavra chave **protected**. Basta adicionar à esquerda da assinatura do **constructor** da base classe:

```
class Veiculo {
  protected constructor() {
  }
}
```

Agora, a seguinte expressão irá causar um erro:

```
let veiculo: Veiculo = new Veiculo();
```

```
Constructor of class 'Veiculo' is protected
and only accessible within the class declaration.
```

Com a adição de `protected` antes da assinatura do `constructor()`, não é mais possível criar objetos baseados diretamente na base classe Veiculo. Em vez disso, o usuário tem criar objetos a partir de classes derivadas de `Veiculo`. No caso acima, temos que usar `new Carro()`.

Para aprender mais sobre o TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=jOJYBcjJ0CE&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


O Construtor Protegido no TypeScript

Uma função trivial para adicionar dois números pode ser escrita da seguinte maneira em JavaScript:

```
function somar(a, b) {
  return a + b;
}
```

Certos bugs como o seguinte podem às vezes acontecer:

```
let soma = somar("3", 5);
console.log(soma);
```

O script acima imprime o seguinte:

```
35
```

Observe que 3 + 5 deveria ser 8, mas devido ao primeiro argumento não ser o número 3, mas uma string que contém o caractere "3", obtemos um resultado incorreto. Isto porquê no JavaScript uma `string` + `number` irá causar uma operação de concatenação, cujo resultado no exemplo é "35".

Questões como essas podem ser detectadas facilmente no TypeScript na hora de compilação, sem termos que esperar até a hora de execução para verificar.

Vamos adicionar uma anotação de tipo para cada parâmetro da função em exemplo:

```
function somar(a: number, b: number) {
  return a + b;
}
```

Para definir o tipo do parâmetro, escreve-se dois pontos seguidos do tipo. No exemplo acima, o requiremento é que cada parâmetro seja um número, `number`.

Agora, ao compilar a função acima junto a chamada de `somar` abaixo, o compilador irá indicar um erro.

```
let soma = somar("3", 5);
console.log(soma);
```

```
Argument of type '"3"' is not assignable to parameter of type 'number'.
```

Para consertar o problema, basta passar um número no primeiro argumento, sem aspas:

```
let soma = somar(3, 5);
```

Saída da Execução:

```
8
```

Um dos grandes benefícios do TypeScript é poder detectar códigos problemáticos cedo, na etapa de compilação. Isso previne ter que rodar o script e testar na hora de execução.

É importante ressaltar que se escrevermos código diretamente em JavaScript, sem o passo da compilação do TypeScript, há uma chance do erro não ser detectado. Isso porque ainda que o script execute sem nenhum erro explícito, o JavaScript normal não tem cheque de tipos e, do seu ponto de vista, pensa que tudo está correto.

Para aprender mais sobre TypeScript, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=czp3QV55v1k&list=PLUbb2i4BuuzBcH1iS242xjztUwMI4erNb

Nos vemos lá!


Como Adicionar Anotações de Tipo nos Parâmetros de uma Função em TypeScript

A estrutura que associa uma chave à um valor na linguagem
Golang é chamada de *Map*.

O tipo é formado da seguinte maneira:

```
map[TIPO_DA_CHAVE]TIPO_DO_VALOR
```

Por exemplo, para criar um mapa de `string` para `int`:

```
map[string]int
```

A construção acima significa que o `map` aceita como chave uma **string**; essa string é associada à um valor do tipo **int**.

Imagine que em uma escola, os alunos fazem uma prova e recebem uma nota como resultado. Podemos associar o nome de cada aluno ao valor de sua nota dessa maneira:

```
var notas map[string]int
notas = make(map[string]int)

notas["Ana"] = 9
notas["Maria"] = 10
// e assim por diante...
```

A primeira linha do exemplo acima declara uma variável para armazenar um map de `string` para `int`.

Logo em seguida, criamos o map usando a função **make**. Vale a pena lembrar que `make` também é usado para criar *slices* (fatias de *array*). Nesse caso, usamos o `make` para criar um map que associa uma `string` à um valor `int`.

As linhas que seguem associam o nome de cada estudante ao valor da nota recebida na prova. A notação para adicionar ou atualizar um par de chave-valor em Golang é, em geral:

```
notas[CHAVE] = VALOR
```

Podemos também acessar o valor correspondente a chave assim:

```
fmt.Println(notas["Maria"]) // => 10
```

Mas temos que tomar cuidado porque pode ser que a chave não exista no Map, em cujo caso o valor zero do tipo do valor associado é retornado:

```
fmt.Println(notas["Estudante Que Nao Existe"]) // => 0
```

A chave mapeia para um valor do tipo `int`, cujo valor zero é `0`.

Há uma maneira de checar se a chave existe antes se referenciar o seu valor. Para aprender mais sobre a estrutura Map na linguagem Golang, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=Zp1AA6dDQZ4&list=PLUbb2i4BuuzCX8CLeArvx663_0a_hSguW


Como Criar uma Estrutura de Hash Map na Linguagem Golang

Ponteiros são variáveis que armazenam o endereço da memória usada por uma certa informação.

Por exemplo, vamos definir uma variável para armazenar um valor inteiro:

```
var a int = 37
``` 

A variável `a` armazena o valor 37, um inteiro, na memória.

Para criar um ponteiro que aponta para o endereço da variável `a`, usamos a seguinte notação:

```
var p *int = &a
```

Na expressão acima, declaramos um ponteiro com nome `p`. O tipo de dados é um ponteiro para um `int`, por isso tem um asterisco antes de `int`. No lado direito do sinal de igual, temos o *ampersand* & para obter o endereço da variável `a`.

Com o ponteiro `p` acima, podemos acessar o valor apontado por ele usando o operador de desreferenciação (*dereferencing*), que é um asterisco antes do nome da variável:

```
fmt.Printf("O valor apontado por p é %d\n", *p)
// => O valor apontado por p é 37
```

Podemos também modificar o valor referenciado pelo ponteiro fazendo uma atribuição da seguinte maneira:

```
*p = 62
```

Ao imprimir o valor de `a`, veremos que ele mudou:

```
fmt.Println(a) // => 62
```

Para aprender mais sobre como definir ponteiros na linguagem Golang, assista à aula do NBK Mundo Tech:

https://www.youtube.com/watch?v=BBUQZ7pJxn4&list=PLUbb2i4BuuzCX8CLeArvx663_0a_hSguW

Nos vemos lá!


Como Definir Ponteiros na Linguagem Golang

As linhas de código em Golang são normalmente executadas em sequência, na ordem em que são escritas. Mas será que há alguma maneira de adiar a chamada de uma certa função?

A resposta é sim, usando a palavra-chave **defer**. Vamos aprender o conceito de adiar uma chamada de função com um exemplo. No código abaixo, temos duas linhas (dentro do corpo da função `main`) que imprimem texto ao console.

```
func main() {
  fmt.Println("Oi")
  fmt.Println("Tudo bem?")
}
```

A ordem de execução dos comandos é como escrita, então esperamos ver o seguinte no terminal:

```
Oi
Tudo bem?
```

Agora, o que será que acontece quando introduzimos a palavra-chave `defer` antes da chamada da primeira linha do corpo de `main`:

```
func main() {
  defer fmt.Println("Oi")
  fmt.Println("Tudo bem?")
}
```

Aqui está a saída do código acima:

```
Tudo bem?
Oi
```

Note que a segunda linha foi executada antes da primeira. Mas o que aconteceu? Bem, a palavra-chave **defer** faz a chamada da função que segue ser adiada. 

Em mais detalhes, há uma *stack* de chamadas. Essa pilha armazena todas as chamadas que foram adiadas usando `defer`. Se tivermos três chamadas para o `defer`, como o seguinte:

```
defer fmt.Println("1")
defer fmt.Println("2")
defer fmt.Println("3")
```

Então as três chamadas serão adicionadas a pilha de chamadas, na seguinte ordem, do topo para o fundo:

```
// topo da stack
fmt.Println("3")
fmt.Println("2")
fmt.Println("1")
// fundo da stack
```

Quando chegar no final do corpo da função `main()`, os comandos armazenados nessa stack serão executados, começando do topo da stack.

Então a primeira chamada a ser adiada na verdade será a última a ser executada;

A última chamada a ser adiada será a primeira a ser executada.

Isso segue o conceito de *last-in-first-out* (LIFO): a última entrada é a primeira saída.

Para concluir, no último exemplo veremos a seguinte saída:

```
3
2
1
```

Para aprender mais sobre o `defer`, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=meofoK5_OCI&list=PLUbb2i4BuuzCX8CLeArvx663_0a_hSguW


Como Adiar (defer) a Execução de Funções na Linguagem Golang

Na linguagem Go podemos criar "fatias" ou "pedaços" de vetores usando a seguinte notação:

```
[]tipo
```

Por exemplo, para criar um *slice* (fatia) de elementos do tipo string, escrevemos:

```
[]string
```

Podemos criar uma lista de nomes usando fatias literais:

```
nomes := []string{"Joao", "Maria", "Zeus"}

nomes[0] // => Joao
nomes[1] // => Maria
nomes[2] // => Zeus
```

Sabemos criar uma fatia de uma dimensão, mas será que dá para adicionar mais uma dimensão? A resposta é sim. Basta adicionar mais um par de colchetes ao tipo da variável.

Por exemplo, no jogo da velha, temos uma grade ou tabuleiro de 3 linhas e 3 colunas (3x3). Podemos representar a grade usando uma fatia de duas dimensões, cada elemento da fatia exterior sendo uma fatia de elementos do tipo string:

```
grade := [][]string {
  []string{"O", "X", "-"},
  []string{"-", "O", "-"},
  []string{"-", "-", "X"},
}
```

A variável acima armazena informações que representam o seguinte tabuleiro:

```
O X -
- O -
- - X
```

Ao ler a definição da variável, podemos pensar da seguinte maneira:

[]**[]string** -- Uma fatia ([]) de fatia de string ([]string)

Isto é, cada elemento da fatia será uma fatia também.

`grade[0]` lhe permite acessar o primeiro elemento da fatia, que tem valor:

```
[]string{"O", "X", "-"}
```

Para acessar cada elemento específico dessa fatia interior, usamos mais um par de colchetes à direita do que já temos, com o índice do elemento entre eles. Por exemplo, para acessar o X da fatia acima, usamos:

grade[0]**[1]** // => X

O primeiro par de colchetes nos dá acesso à primeira linha enquanto o segundo par nos dá acesso a segunda coluna dessa primeira linha.

Para aprender mais sobre matrizes de pedaços na linguagem Go, assista às aulas do NBK Mundo Tech:

https://www.youtube.com/watch?v=0NRpqnCqjZU&list=PLUbb2i4BuuzCX8CLeArvx663_0a_hSguW

Nos vemos lá!


Slices de Duas Dimensões (Matriz) na Linguagem Golang

Muitos aplicativos de React hoje em dia usam o Redux para a gestão dos dados do aplicativo.

Os dados são armazenados em uma única store, também chamada de Estado do Aplicativo. Essa entidade é, na maioria dos casos, nada mais nada menos que um simples objeto de JavaScript, com propriedades indexadas por uma chave e que tem um valor correspondente.

Normalmente o objeto do Estado é dividido em varias subseções, cada uma responsável, por exemplo, por um recurso diferente do aplicativo.

A função `connect()` do módulo de npm `react-redux` é normalmente usada para disponibilizar partes do Estado do Aplicativo via props passadas ao componente alvo.

Por exemplo:

```
const mapStateToProps = state => {
  return {
    propriedade1: state.recurso1.propriedade1,
    propriedade2: state.recurso2.propriedade2
  };
}

connect(mapStateToProps)(MeuComponente);
```

Para acessar `propriedade1` e `propriedade2`, sempre temos que fornecer ao `mapStateToProps` o caminho para achar os dados: `state.recurso1.propriedade1` e `state.recurso2.propriedade2`, respectivamente.

Vários componentes podem ter que requerir esses dados, então teríamos que escrever os caminhos de acesso numeras vezes.

Se um dos caminhos mudar, todos os componentes terão que ser atualizados com o novo caminho.

Para evitar isso, podemos criar seletores: simples funções que tomam o `state` como argumento, seguem o caminho requerido, e finalmente retornam os dados correspondentes:

```
const propriedade1Seletor = (state) => {
  return state.recurso1.propriedade1;
}

const propriedade2Seletor = (state) => {
  return state.recurso2.propriedade2;
}
```

Esses seletores podem ser armazenados em um arquivo e exportados para todos os componentes que precisarem acessar a parte do Estado do Aplicativo correspondente ao seletor.

Partindo do exemplo anterior, um certo componente que precisasse acessar os dados propriedade1 e propriedade2 teria que usar:

```
const mapStateToProps = state => {
  return {
    propriedade1: propriedade1Seletor(state),
    propriedade2: propriedade2Seletor(state)
  };
}
```

Agora se o caminho de cada recurso mudar, só é preciso mudar o código do seletor. Não precisa mudar nada nos componentes que usam o seletor. A lógica de percorrer o caminho para achar os dados está encapsulada na implementação do seletor.

Para aprender mais sobre seletores com React and Redux, assista às aulas no NBK Mundo Tech:

https://www.youtube.com/watch?v=Ud2lp4Hrb10&list=PLUbb2i4BuuzDC2mvVwiqokO2ReWb6qSYI&index=1


O Conceito de Seletores no Redux

Abordaremos aqui como fazer o for loop, a estrutura de repetição "para," na linguagem de programação Go.
### sadsd
# Estrutura de Repetição

A estrutura de repetição "para" pode ser escrita da seguinte forma em Go:

```golang
for i := 1; i <= 10; i++ {
  fmt.Println("Valor da Variável de Iteração:", i)
}
```

# A Construção da Estrutura

A assinatura da construção do for loop é divida em três partes:

1. inicialização
2. condição
3. incrementação

Na primeira parte, normalmente iniciamos uma variável de itereção que será usada dentro do corpo de repetição. No exemplo, definimos uma variável chamada `i`, com valor inicial de 1, que se tornará tipo inteiro (`int`).

Na segunda parte, determinamos a condição para que a repetição ocorra. Nesse caso, a repetição irá ocorrer enquanto o valor de `i` for menor ou igual a 10.

Na terceira parte, incrementamos o valor da variável de iteração `i`. Inicialmente com valor 1, `i` se tornará 2. Depois 3, 4, 5, etc até chegar a 11 no final da repetição.

# Resultado da Execução do Código

Segue o resultado do código executado:

```sh
Valor da Variável de Iteração: 1
Valor da Variável de Iteração: 2
Valor da Variável de Iteração: 3
Valor da Variável de Iteração: 4
Valor da Variável de Iteração: 5
Valor da Variável de Iteração: 6
Valor da Variável de Iteração: 7
Valor da Variável de Iteração: 8
Valor da Variável de Iteração: 9
Valor da Variável de Iteração: 10
```

# Passo a Passo

Na estrutura de repetição para, a inicialização é feita e a variável de iteração `i` é atribuída um valor inicial 1.

Logo segue o cheque da condição. Se a condição `i <= 10` for verdadeira, o corpo da repetição é executado. Inicialmente, `1 <= 10` é verdadeiro e a mensagem com o valor da variável de iteração é imprimida no console.

Depois do fim do corpo da iteração, a parte de incrementação da variável de controle é executada. O valor de `i` se torna 2.

Com isso, a condição do loop é checada novamente, agora sendo `2 <= 10`. Como o resultado é verdadeiro, o corpo do loop executa e imprime `Valor da Variável de Iteração: 2` no console. Depois de terminar a iteração, a variável `i` tem valor incrementado, de 2 para 3.

E assim por diante, a repetição dos passos acima continua até que o valor de `i` se torne 11, onde o cheque da condição do for loop se torna `11 <= 10`, que resulta em valor falso. A repetição então termina e o programa continua a execução depois do bloco do for loop. No nosso exemplo, não há mais nada a executar.

# Alguns Detalhes

É importante ressaltar que a primeira e terceira parte da estrutura for são opcionais. Por isso o for loop pode ser convertido para um "while" loop, a estrutura de repetição "enquanto".

A parte de incrementação pode ser também uma decrementação, ou mudança para qualquer outro valor, não necessariamente com diferença de 1.

# Assista a Aula de Golang no NBK Mundo Tech

Aprenda mais sobre como criar um for loop na linguagem Go com uma aula do NBK Mundo Tech:

https://www.youtube.com/watch?v=ExjKZckZ--w

# Deixe Seus Comentários

O que você achou? Deixe sua opinião e comentários!


Como Fazer o For Loop em Golang - Tutorial de Programação na Linguagem Go

Neste tutorial aprenderemos como instalar as ferramentas para compilar o código escrito na linguagem Go. Vamos usar o gerenciador de pacotes da distribuição de Linux.

Apresentaremos duas escolhas: a primeira no Ubuntu (ou sistemas baseados no Debian); a segunda no Fedora (ou sistemas baseados no Red Hat).

# Ubuntu

Se você for ao [site de pacotes do Ubuntu](https://packages.ubuntu.com) e fizer uma busca por "golang," encontrarás um pacote de nome exato. No entanto devemos instalar o pacote de nome `golang-go`, com o sufixo `-go`.

## Atualizando a Lista de Pacotes do Gerenciador

Abra o Terminal e digite o seguinte comando:

```sh
sudo apt update
```

O uso de `sudo` é para rodar o comando como usuário root.

## Comando para Instalar Go

Depois de atualizar a lista de pacotes do seu sistema usando o comando acima, é hora de instalar as ferramentas da linguagem Go:

```sh
sudo apt install golang-go
```

O comando acima instala o compilador, o ligador, e a biblioteca padrão compilada. O comando `apt` é uma interface em nível mais alto que o `apt-get`. Tambem funciona se você usar o `apt-get`.

## Testando a Instalação

Pronto, agora é só testar se deu tudo certo com o comando:

```sh
go version
```

Se aparecer um texto parecido com

```
go version go1.10.4 linux/amd64
```

Significa que deu tudo certo. Se não, você receberá uma mensagem de erro dizendo que o comando não foi encontrado (e uma sugestão para instalar o pacote).

# Fedora

Uma busca por `golang` no [site de pacotes do Fedora](https://apps.fedoraproject.org/packages) lhe apresentará o pacote do mesmo nome. Vamos instalar esse pacote.

## Instalação do Pacote Usando o Gerenciador

Abra o Terminal e digite o seguinte comando:

```sh
sudo dnf install golang
```

Temos que usar `sudo` para rodar o comando como administrador. O comando `dnf` é o sucessor do `yum`. A opção `install` é para instalar o pacote.

## Teste da Instalação do Pacote

Se aparecer um texto parecido com

```
go version go1.11.4 linux/amd64
```

Significa que deu tudo certo. Se não, você receberá uma mensagem de erro dizendo que o comando não foi encontrado.

# Aprenda Golang com Vídeo Aulas

Não perca o curso de Go iniciante no NBK Mundo Tech:

https://www.youtube.com/watch?v=OaslPXsv9U0

# Deixe seu Comentário

E aí, deu tudo certo? Deixe sua opinião e comentários.


Como Instalar Golang no Linux (Ubuntu / Fedora)

Uma das primeiras coisas que aprendemos em programação é a declaração e definição de variáveis para armazenar valores.

# Variáveis

Uma variável tem um nome e o tipo de dado.

Variáveis podem armazenar valores numéricos, caracteres e outros.

# Declaração de Variável em Go

Vamos aprender como declarar uma variável em Go. Primeiro, você usa a palavra-chave `var`. Depois, diga o nome da variável. Finalmente, termine com o tipo da variável:

```
var idade int
```

No exemplo acima, definimos uma variável para armazenar a idade de uma pessoa.

A palava-chave `var` se refere a uma declaração de variável. O nome da variável é idade. O tipo é `int`, que significa um valor inteiro (um número sem ponto flutuante ou decimal).

Usamos o tipo `int` porque a idade de uma pessoa é um número inteiro e não faz sentido usar, por exemplo, uma idade de 34.43, que é um valor de ponto flutuante.

# Definição da Variável

Para definir o valor da variável, você pode iniciar o valor na própria declaração ou depois.

Se for na própria declaração:

```
var idade int = 35
```

É só digitar o sinal de igual seguido do valor. O sinal de igual significa uma operação de atribuição.

Agora, se tivesse definido depois da declaração, seria assim:

```
var idade int

idade = 35
```

Basta digitar o nome da varíavel, seguido do operador de atribuição (o sinal de igual) e o valor, que é 35 nesse exemplo.

# Armazenando Strings

Há outros tipos de dados para definir uma variável. Por exemplo, para criar uma variável para armazenar o nome de uma pessoa, você poderia digitar:

```
var nome string
nome = "Ana Maria"
```

# Aula de Golang - Aprenda Mais com Curso Completo

Por essa aula é só. Para mais tutoriais sobre a linguagem Go, confira o curso completo do NBK Mundo Tech:

<https://www.youtube.com/watch?v=5-puLY9rzuE>

# Compartilhe e Deixe a sua Opinião

O que você achou? Não hesite em deixar o seu comentário.


Como Definir uma Variável na Linguagem Go (Tutorial de Golang)

Neste tutorial, vamos aprender a linguagem de programação Go!

# Println

Para imprimir uma linha no console, precisamos usar a função `Println` do pacote `fmt`:

```
fmt.Println("Olá Mundo")
```

Note que a declaração não precisa terminar com um ponto e vírgula.

# Função Principal

Devemos por a declaração acima dentro de uma função. Todo programa de Go começa na função principal, chamada `main`:

```
func main() {
  fmt.Println("Olá Mundo")
}
```

Note que a palavra-chave `func` é usada para definir uma função. O nome da função segue, após um espaço. Depois vem a lista de parâmetros. Nesse caso não há nenhum, então fica só os parênteses sem nada dentro. O corpo da função é definido entre as chaves.

# Importando o Pacote

Estamos quase terminando. Para que o programa acima possa funcionar, precisamos importar o pacote fmt, que é usado para imprimir uma mensagem ao terminal:

```
import "fmt"

func main() {
  fmt.Println("Olá Mundo")
}
```

# Definindo o Pacote Principal e o Arquivo de Código

Ponha o código acima em um arquivo com a extensão `.go` e defina o nome do pacote na primeira linha do arquivo:

> arquivo.go
```
package main

import "fmt"

func main() {
  fmt.Println("Olá Mundo")
}
```

O pacote `main` é o pacote principal, que define onde o programa começa a execução. Note que temos dois elementos com o mesmo nome main: o pacote e a função principal.

# Aula de Golang - Aprenda Mais com Curso Completo

Você pode aprender mais sobre Golang no **NBK Mundo Tech**. Confira as aulas:

https://www.youtube.com/watch?v=WQ-mg59x9PU

# Compartilhe e Deixe a sua Opinião

O que você achou? Não hesite em deixar o seu comentário.


Primeiro Programa em Go (Tutorial de Golang)

Já jogou o jogo da velha? Que tal desenvolver esse jogo usando o desenvolvimento web?

O NBK Mundo Tech em 2018 começou a apresentar aulas sobre o assunto. Aprenda a implementar a programação do jogo no navegador com HTML, CSS, e JavaScript:

https://www.youtube.com/watch?v=iwgTdYuARcs&list=PLUbb2i4BuuzC8Jj1R8ZYqx_Wkjwl2qn9P

Nos vemos no NBK Mundo Tech!


Jogo da Velha com HTML, CSS, JavaScript - Retrospectiva NBKMT 2018

Já ouviu falar da linguagem de programação **Go**?

Também chamada de **Golang**, a linguagem foi criada por engenheiros da Google em 2009. Ela se tornou uma linguagem popular no desenvolvimento de software no lado do servidor (backend).

**Que tal aprender Go no NBK Mundo Tech?** Segue o link para as aulas:

https://www.youtube.com/watch?v=WQ-mg59x9PU&list=PLUbb2i4BuuzCX8CLeArvx663_0a_hSguW

Nos vemos no NBK Mundo Tech!


Aprenda Golang (Curso de Programação Go) - Retrospectiva NBKMT 2018

Hoje em dia, muitos aplicativos obtém os seus dados através de chamadas à um servidor no backend.

Normalmente os dados são solicitados via um pedido HTTP. No caso do desenvolvimento web, através de XMLHTTPRequest (XHR).

Quando você solicita dados à uma API REST, em muitos casos nem todos os dados necessários vêm em um só pedido. Por causa disso, você tem que fazer múltiplos pedidos só para reunir os dados e finalmente mostrar na visão.

É comum também certos dados presentes na resposta do servidor serem descartados pelo frontend.

Os acontecimentos acima custam muito em termos de largura de banda, principalmente para aqueles usuários que utilizam dispositivos móveis com uma conexão não muito rápida.

Há uma ferramenta que lhe permite pedir exatamente o que o frontend quiser: com o GraphQL, você solicita os dados que você quiser, sem mais, sem menos, em um só pedido ao servidor backend.

O NBK Mundo Tech preparou várias aulas sobre o GraphQL, usando o framework de backend Express em Nodejs. Conheça:

https://www.youtube.com/watch?v=OtYA_GcsMQM&list=PLUbb2i4BuuzAHToiiVdFwrFSpw3FUj6Qh

Nos vemos no NBK Mundo Tech!


Aprenda GraphQL com Express - Retrospectiva NBKMT 2018

Já pensou em adotar um padrão para nomear as suas classes de CSS?

Usando a Metodologia BEM, você segue o padrão de nomeação usando:

```
bloco__elemento--modificador
```
&nbsp;
Confira as aulas sobre BEM para entender melhor essa metodologia:

https://www.youtube.com/watch?v=6LqDwraAtTM&list=PLUbb2i4BuuzCIcGrsYbXdNLTEaJmJLVK5

Nos vemos no NBK Mundo Tech!


Metodologia BEM para Nomear Classes de CSS - Retrospectiva NBKMT 2018

O NBK Mundo Tech apresentou uma aula tutorial sobre funções geradoras no JavaScript. Em inglês, *generator functions*, são aquelas funções com o asterisco após a palavra-chave function:

```javascript
function* minhaFuncaoGeradora() {
  yield 1;
  yield 2;
  yield 3;
}
```

Confira a aula no nosso canal e entenda o que está acontecendo no código acima:

https://youtu.be/mXadwO6tGbI


Funções Geradoras do JavaScript - Retrospectiva NBKMT 2018

Já trabalhou com promessas no JavaScript? Há outra maneira de lidar com uma Promise, em vez de usar o bloco de `.then()`!

Em 2018, o NBK Mundo Tech apresentou uma aula sobre o tema. Aprenda o uso da palavra chave **await** em funções definidas como **async**. Assista já a esta aula sobre o assunto no NBK Mundo Tech:

https://youtu.be/oJPZp9ZP1DI


Gestão de Promessas com o Async Await - Retrospectiva NBKMT 2018

O ano de 2018 no NBK Mundo Tech começou com várias aulas sobre o React.

Em "React: Componentes Controlados," você aprende como criar o seus próprios componentes de React na web, de maneira controlada. Elementos como a Caixa de Texto, Checkbox, Radio e Seletor.

O curso também inclui conteúdo sobre a criação de testes unitários com o framework Jest e a ferramenta Enzyme.

Confira já esse curso gratuito:

<https://www.youtube.com/watch?v=Dfsq02FaQ_o&list=PLUbb2i4BuuzAZISr_WSergXu56iUTgF4v&index=25>

Te vejo no NBK Mundo Tech!


Retrospectiva NBKMT 2018 - React: Componentes Controlados

O desenvolvimento web do frontend de um website ou aplicativo consiste de três elementos: o **HTML**, o **CSS**, e o **JavaScript**.

O **HTML** é uma linguagem de markup. Ele é usado para definir a **estrutura** fundamental do website. O documento de HTML é escrito por meio de **tags**. Cada tag pode conter informações adicionais com a adição de **atributos**.

Enquanto o HTML define a estrutura básica do site, o **estilo** é definido por meio do **CSS**. As cores, as fontes, o espaço e posicionamento de vários elementos da página são exemplos da aplicação do CSS.

O aspecto final do desenvolvimento de frontend vêm da linguagem de programação popularmente chamada de **JavaScript**. O HTML junto ao CSS definem websites estáticos e não chegam a ser aplicativos próprios até terem um certo nível de **interação** com o usuário que pode ser definido usando "scripts" escritos em JavaScript.

Em conclusão, o desenvolvimento de frontend depende de três elementos:

1. O uso do HTML para definir o esqueleto da página;

2. A aplicação de folhas de estilo de CSS para enfeitar o website;

3. O desenvolvimento de códigos escritos em JavaScript para tornar o site dinâmico, assim tornando-o um aplicativo.

*Já pensou em seguir o caminho de um desenvolvedor de frontend? Deixe sua resposta nos comentários!*


O Desenvolvimento Web do Frontend

O desenvolvimento web é normalmente dividido em duas partes: o **frontend** e o **backend**.

O **frontend** consiste do desenvolvimento da parte gráfica do aplicativo ou website. É aquilo que o usuário vê na sua frente, por isso o uso do termo "front."

A parte relacionada ao armazenamento, processamento e manutenção dos dados que apoiam o funcionamento do aplicativo é chamada de **backend**, porque está por trás ("back") daquilo que o usuário vê.

Os responsáveis pelo desenvolvimento da parte da frente são chamados de desenvolvedores de frontend ("Frontend Developer").

Os responsáveis pelo desenvolvimento dos bastidores são chamados de desenvolvedores de backend ("Backend Developer").

Há também desenvolvedores que têm a habilidade de mexer tanto com o frontend como o backend -- estes são chamados desenvolvedores **fullstack** ("Fullstack Developer").

*Que tipo de desenvolvedor web você quer ser? Deixe a sua resposta abaixo.*


Artigos