Entendendo o Prototype do JavaScript

Uma das características mais poderosas do JavaScript é a sua capacidade de trabalhar com objetos, que são instâncias de classes ou protótipos. O sistema de protótipos do JavaScript permite que os desenvolvedores criem objetos de forma flexível e eficiente. Neste artigo, vamos explorar o conceito de prototype no JavaScript e entender como ele funciona.

O que é o Prototype / Protótipo?

O prototype é um mecanismo interno do JavaScript que permite aos objetos herdar propriedades e métodos de outros objetos. Essa herança é diferente da herança de classe tradicional encontrada em linguagens orientadas a objetos, como Java e C#. No JavaScript, a herança ocorre através da chamada “herança prototípica” e é baseada em objetos, em vez de classes.

Herança Prototípica

A herança prototípica é a base do sistema de objetos do JavaScript. Cada objeto em JavaScript tem uma referência interna a outro objeto, chamado de “protótipo”. Quando uma propriedade ou método é acessado em um objeto, o JavaScript primeiro verifica se essa propriedade ou método existe no próprio objeto. Se não for encontrado, o JavaScript procurará no protótipo do objeto. Esse processo continua até que a propriedade ou método seja encontrado ou até que a cadeia de protótipos termine.

Essa cadeia de protótipos é a principal característica que permite a herança no JavaScript. Quando um objeto herda de outro objeto, na verdade está herdeiro do protótipo desse objeto.

Funções Construtoras e o Prototype

No JavaScript, funções construtoras são usadas para criar objetos com propriedades e métodos específicos. Quando uma função é chamada com a palavra-chave “new”, um novo objeto é criado e sua referência de protótipo é atribuída ao protótipo da função construtora.

function Pessoa(nome, idade) {
    this.nome = nome;
    this.idade = idade;
}
const pessoa1 = new Pessoa("João", 30);

Neste exemplo, a função Pessoa é uma função construtora e cria objetos com as propriedades nome e idade. Quando criamos um objeto pessoa1 usando a palavra-chave “new”, o protótipo do objeto pessoa1 é configurado para ser o objeto Pessoa.prototype.

Adicionando Propriedades e Métodos ao Prototype

O prototype é um objeto comum e, como tal, você pode adicionar propriedades e métodos a ele. Isso é útil quando você deseja que todos os objetos criados por uma função construtora compartilhem propriedades e métodos sem precisar redefini-los em cada instância.

Pessoa.prototype.apresentar = function() {
    return `Olá, meu nome é ${this.nome} e tenho ${this.idade} anos.`;
};

console.log(pessoa1.apresentar()); // Olá, meu nome é João e tenho 30 anos.

Ao adicionar o método apresentar ao prototype da função construtora Pessoa, todos os objetos criados a partir dela terão acesso a esse método.

Qual a diferença entre herança de classes e herança herança Prototípica no JavaScript?

Bom, esse é um tópico que merece sua própria postagem. E você pode ver detalhes no post Qual a diferença entre Herança de classes e herança Herança Prototípica no JavaScript?

Mas resumidamente, a herança de classes é baseada em classes, enquanto a herança prototípica é baseada em objetos. Essa diferença fundamental afeta a forma como a herança e a reutilização de código são alcançadas em cada paradigma.

Conclusão

Isso ai, o sistema de protótipos do JavaScript é uma característica poderosa e flexível que permite a herança e o compartilhamento. Espero que tenha gostado e aproveita para conferir nossas outras postagens

JavaScriptLandia – Para aqueles que amam JavaScript

O que é?

JavaScriptLandia, o programa de suporte individual da OpenJS Foundation, é um lugar onde todos os fãs de JavaScript, não importa seu sabor ou preferência de tecnologia, podem expressar de forma criativa suporte para o ecossistema JavaScript e comunidades OpenJS

Quais são os benefícios do programa JavaScriptLandia?

  • Um crachá digital para adicionar aos seus perfis online, avatar, blog e/ou site pessoal. Os detalhes serão enviados por e-mail separadamente dentro de uma semana.
  • Reconhecimento nesta página! Novos apoiadores serão adicionados à página semanalmente.
  • Um boletim semanal de apoiadores que o mantém atualizado sobre as últimas novidades dos projetos OpenJS, do Conselho de Projetos Cruzados e do Conselho de Administração. Você também será convidado a participar de discussões sobre governança e novas iniciativas.
  • Descontos para treinamento, certificação, conferências e outras ofertas exclusivas.

Atualizações do site

logo

Olá pessoal, já faz um tempinho que não postamos este tipo de boletim informativo. Mas com todas as coisas que aconteceram nestes últimos 2 anos infelizmente o MundoJS acabou ficando um pouco parado.

Bom, o plano é retomar as atividades aos poucos , demos uma olhada e o que a galera mais tem gostado é de dicas sobre os fundamentos do JS, então vamos começar por lá. Criar tutorais de como fazer as coisas e também focar talvez em vídeos.

Eu costumo a escrever no plural, mas na verdade voltou a ser uma equipe de uma pessoa. O que faz parte… kkkkkk

Como vocês devem ter visto o site ta com outra cara, isso porque, para os próximos meses

foco será:

  • Novos posts com tutorais
  • Focar na velocidade do site
  • Melhorar a performance e segurança do site
  • Aumentar o conteúdo em vídeo
  • Remover as coisas que ninguém, ou quase ninguém, está usando.

O que já fiz nos últimos dias

  1. Novo layout, muito mais leve.
  2. Removido a funcionalidade de push de notificações. Tinha apenas umas 30 pessoas usando ele.
  3. Atualizado o Site, plugins de segurança.
  4. Removido plugins de antigos que a atualização invalidou… Quebrou quase nada.. kkk
  5. Iniciado novas postagens

Por último o plano para o futuro é

  • Continuar postando
  • Criar vídeos
  • Melhorar a área de cursos
  • Criar enquetes e buscar mais gente para contribuir

Extreme Go Horse – Gambiarra é para os fracos

extreme-go-horse

Conheça a metodologia Extreme Go Horse (XGH) onde você não precisa perder tempo com padrões, pensamento, documentação ou qualquer bobagem que vai te fazer produzir código. Aqui você sempre programa 8 mil linhas de código por segundo e se você teve que parar para pensar em fazer uma gambiarra, você lento e não sabe o que ta fazendo… kkkkkk… Bom, chega de enrolar, veja a baixo como funciona

1- Pensou, não é XGH.

XGH não pensa, faz a primeira coisa que vem à mente. Não existe segunda opção, a única
opção é a mais rápida.

2- Existem 3 formas de se resolver um problema, a correta, a errada e a XGH, que é igual à errada, só que mais rápida.

XGH é mais rápido que qualquer metodologia de desenvolvimento de software que você
conhece (Vide Axioma 14).

3- Quanto mais XGH você faz, mais precisará fazer.

Para cada problema resolvido usando XGH, mais uns 7 são criados. Mas todos eles serão
resolvidos da forma XGH. XGH tende ao infinito.

4- XGH é totalmente reativo.

Os erros só existem quando aparecem.

5- XGH vale tudo, só não vale dar o toba.

Resolveu o problema? Compilou? Commit e era isso.

6- Commit sempre antes de update.

Se der merda, a sua parte estará sempre correta.. e seus colegas que se fodam.

7- XGH não tem prazo.

Os prazos passados pelo seu cliente são meros detalhes. Você SEMPRE conseguirá
implementar TUDO no tempo necessário (nem que isso implique em acessar o BD por um
script malaco).

8- Esteja preparado para pular fora quando o barco começar a afundar… ou coloque a culpa em alguém ou algo.

Pra quem usa XGH, um dia o barco afunda. Quanto mais o tempo passa, mais o sistema
vira um monstro. O dia que a casa cair, é melhor seu curriculum estar cadastrado na
APInfo, ou ter algo pra colocar a culpa.

9- Seja autêntico, XGH não respeita padrões.

Escreva o código como você bem entender, se resolver o problema, commit e era isso.

10- Não existe refactoring, apenas rework.

Se der merda, refaça um XGH rápido que solucione o problema. O dia que o rework
implicar em reescrever a aplicação toda, pule fora, o barco irá afundar (Vide Axioma 8).

11- XGH é totalmente anárquico.

A figura de um gerente de projeto é totalmente descartável. Não tem dono, cada um faz o
que quiser na hora que os problemas e requisitos vão surgindo (Vide Axioma 4).

12- Se iluda sempre com promessas de melhorias.

Colocar TODO no código como uma promessa de melhoria ajuda o desenvolvedor XGH a
não sentir remorso ou culpa pela cagada que fez. É claro que o refactoring nunca será
feito (Vide Axioma 10).

13- XGH é absoluto, não se prende à coisas relativas.

Prazo e custo são absolutos, qualidade é totalmente relativa. Jamais pense na qualidade e
sim no menor tempo que a solução será implementada, aliás… não pense, faça!

14- XGH é atemporal.

Scrum, XP… tudo isso é modinha. O XGH não se prende às modinhas do momento, isso é
coisa de viado. XGH sempre foi e sempre será usado por aqueles que desprezam a
qualidade.

15- XGH nem sempre é POG.

Muitas POG’s exigem um raciocínio muito elevado, XGH não raciocina (Vide Axioma 1).

16- Não tente remar contra a maré.

Caso seus colegas de trabalho usam XGH para programar e você é um coxinha que gosta
de fazer as coisas certinhas, esqueça! Pra cada Design Pattern que você usa corretamente,
seus colegas gerarão 10 vezes mais código podre usando XGH.

17- O XGH não é perigoso até surgir um pouco de ordem.

Este axioma é muito complexo, mas sugere que o projeto utilizando XGH está em meio ao
caos. Não tente por ordem no XGH (Vide Axioma 16), é inútil e você pode jogar um tempo
precioso no lixo. Isto fará com que o projeto afunde mais rápido ainda (Vide Axioma 8).
Não tente gerenciar o XGH, ele é auto suficiente (Vide Axioma 11), assim como o caos.

18- O XGH é seu brother, mas é vingativo.

Enquanto você quiser, o XGH sempre estará do seu lado. Mas cuidado, não o abandone. Se
começar um sistema utilizando XGH e abandoná-lo para utilizar uma metodologia da
moda, você estará fudido. O XGH não permite refactoring (vide axioma 10), e seu novo
sistema cheio de frescurites entrará em colapso. E nessa hora, somente o XGH poderá
salvá-lo.

19- Se tiver funcionando, não rela a mão.

Nunca altere, e muito menos questione um código funcionando. Isso é perda de tempo,
mesmo porque refactoring não existe (Vide Axioma 10). Tempo é a engrenagem que move
o XGH e qualidade é um detalhe desprezível.

20- Teste é para os fracos.

Se você meteu a mão num sistema XGH, é melhor saber o que está fazendo. E se você
sabe o que está fazendo, vai testar pra que? Testes são desperdício de tempo, se o código
compilar, é o suficiente.

21- Acostume-se ao sentimento de fracasso iminente.

O fracasso e o sucesso andam sempre de mãos dadas, e no XGH não é diferente. As
pessoas costumam achar que as chances do projeto fracassar utilizando XGH são sempre
maiores do que ele ser bem sucedido. Mas sucesso e fracasso são uma questão de ponto
de vista. O projeto foi por água abaixo mas você aprendeu algo? Então pra você foi um
sucesso!

22- O problema só é seu quando seu nome está no Doc da classe.

Nunca ponha a mão numa classe cujo autor não é você. Caso um membro da equipe
morra ou fique doente por muito tempo, o barco irá afundar! Nesse caso, utilize o Axioma
8.

Princípios do SOLID com TypeScript – SRP

Veja nesse artigo uma rápida introdução ao SOLID e um exemplo prático sobre o SRP (Principio da responsabilidade unica) utilizando TypeScript

Introdução

Fala galera tudo bem? Aproveitando que estamos iniciando uma serie de podcasts sobre os princípios do SOLID no nosso canal DEVSHOW.

  • O (OCP) Princípio Aberto-Fechado
  • L (LSP) Princípio da Substituição de Liskov
  • I (ISP) Princípio da Segregação da Interface
  • D (DIP) Princípio da inversão de dependência

Principio da Responsabilidade Única (SRP)

Esse é o primeiro principio e na minha opinião o mais simples e o mais importante, ele diz que uma classe deve ter apenas um motivo para mudar” ou sejadeve ter apenas uma responsabilidade. Caso a sua classe tenha mais de uma razão para mudar, ela está fazendo mais de uma coisa, logo quebrando esse principio.

import * as express from "express";
import * as bodyParser from "body-parser";
import * as nodemailer from "nodemailer";
import config from '../config/configs';


class App {

    public app: express.Application;

    constructor() {
        this.app = express();
        this.app.use(bodyParser.json());
        this.routes();
    }
    routes() {

        this.app.route("/").get((req, res) => {
            res.send({ 'result': 'version 0.0.2' })
        });

        this.app.route("/").post((req, res) => {
            const message = Object.assign({}, req.body);
            let result = this.sendMail(message.to, message.subject, message.message);
            res.status(200).json({ 'result': result })
        });
    }


    sendMail(to?: string, subject?: string, message?: string) {

        let mailOptions = {
            from: "",
            to: to,
            subject: subject,
            html: message
        };

        const transporter = nodemailer.createTransport({
            host: config.host,
            port: config.port,
            secure: false,
            auth: {
                user: config.user,
                pass: config.password
            },
            tls: { rejectUnauthorized: false }
        });

        transporter.sendMail(mailOptions, function (error, info) {
            if (error) {
                return error;
            } else {
                return "E-mail enviado com sucesso!";
            }
        });
    }
}

export default new App();
  • O método de envio de e-mail deveria estar em uma outra classe separada
import * as nodemailer from "nodemailer";
import config from './config/configs';

class Mail {

    sendMail(to?: string, subject?: string, message?: string) {

        let mailOptions = {
            from: "",
            to: to,
            subject: subject,
            html: message
        };

        const transporter = nodemailer.createTransport({
            host: config.host,
            port: config.port,
            secure: false,
            auth: {
                user: config.user,
                pass: config.password
            },
            tls: { rejectUnauthorized: false }
        });

        transporter.sendMail(mailOptions, function (error, info) {
            if (error) {
                return error;
            } else {
                return "E-mail enviado com sucesso!";
            }
        });
    }

}

export default new Mail;
import * as express from "express";

const indexRouter = express.Router();

indexRouter.route("/").get((req, res) => {
    res.send({ 'result': 'version 0.0.3' })
});

export default indexRouter;

emailRouter.ts

import * as express from "express";
import mail from "../mail";

const emailRouter = express.Router();

emailRouter.route("/").post((req, res) => {
    const message = Object.assign({}, req.body);
    let result = mail.sendMail(message.to, message.subject, message.message);
    res.status(200).json({ 're sult': result })
});

export default emailRouter;

E por fim atualizamos o arquivo app.ts com o seguinte trecho de código:

import * as express from "express";
import * as bodyParser from "body-parser";
import indexRouter from "../router/indexRouter";
import emailRouter from "../router/emailRouter";


class App {
    public app: express.Application;

    constructor() {
        this.app = express();
        this.app.use(bodyParser.json());
        this.routes();
    }
    routes() {     
        this.app.use("/", indexRouter);
        this.app.use("/", emailRouter);      
    }
}

export default new App();

Gostou deste artigo? Comente abaixo!

Referência: https://programadriano.medium.com/princ%C3%ADpios-do-solid-com-typescript-1e585c6eeb5e

Princípios do SOLID com TypeScript – OCP

Veja nesse artigo um exemplo prático do principio OCP — Princípio Aberto-Fechado

Introdução

Dando continuidade a minha série de artigos sobre os princípios do SOLID com TypeScript e aproveitando a liberação do episódio 2 do nosso podcast: DevShow #22 SOLID OCP. Hoje irei abordar o segundo principio do SOLID, OCP.

Image for post

enum TipoDeArquivo {
    pdf,
    excel
}


class Arquivos {
    Exportar(arquivo: TipoDeArquivo, data: any) {

        if (arquivo == TipoDeArquivo.excel) {
            // exportar data para excel
        }

        if (arquivo == TipoDeArquivo.pdf) {
            // exportar data para pdf
        }
    }
}
enum TipoDeArquivo {
    pdf,
    excel,
    word
}


class Arquivos {
    Exportar(arquivo: TipoDeArquivo, data: any) {

        if (arquivo == TipoDeArquivo.excel) {
            // exportar data para excel
        }

        if (arquivo == TipoDeArquivo.pdf) {
            // exportar data para pdf
        }

        if (arquivo == TipoDeArquivo.word) {
            // exportar data para word
        }

    }
}
abstract class Arquivos {
    Exportar(data: any) { }
}


class GerarExcel extends Arquivos {
    Exportar(data: any) {

    }
}

class GerarPDF extends Arquivos {
    Exportar(data: any) {

    }
}

class GerarWord extends Arquivos {
    Exportar(data: any) {

    }
}

Gostou deste artigo? Comente abaixo!

Referência: https://programadriano.medium.com/princ%C3%ADpios-do-solid-com-typescript-2c6a4911242d

Tornando o código mais rápido usando Sets JavaScript

Muitos desenvolvedores limitam-se a utilização de objetos globais básicos, como strings, objetos, números, arrays e booleanos. Na maioria das vezes, isso realmente é tudo que você precisa mas, para tornar o código mais eficiente, nem sempre isso é todo o necessário.

Para isso, existem os Sets JavaScript, que tornam o seu código mais rápido a medida que ele é escalonado. O uso de sets traz resultados que seriam impossíveis de obter somente com arrays.

E como os sets são diferentes?

Bom, os arrays são coleções de dados indexados, ou seja, cada valor dos dados em um array é ordenado por um índice. Por exemplo:

let mainArray = [a, b, c, d];
console.log(mainArray.indexOf(a));
// 0
console.log(mainArray.indexOf(c));
// 2

Já os Sets são coleções codificadas. Não usam índices, mas ordenam os seus dados utilizando chaves. Seus elementos são iteráveis na ordem de inserção e não podem conter dados duplicados, ou seja, cada conjunto de dados deve ser único.

E quais são os benefícios?

  • Utilizar métodos como indexOf() ou includes() para verificar a existência de um elemento em um array é muito lento;
  • Nos Sets, você pode excluir o elemento pelo seu valor. Em um array, você pode utilizar o splice com base no índice do elemento, tornando-o lento pela dependência de índices;
  • É mais rápido adicionar elementos aos Sets do que adicionar elementos em um array utilizando metodos como push() ou unshift();
  • Um Set pode armazenar NaN;
  • Sets armazenam apenas valores únicos. Se você não pode trabalhar com duplicatas, esta é uma vantagem.

O quão mais rápido são os Sets?

Os métodos que o array utiliza possuem uma complexidade de tempo linear de O (N), ou seja, o tempo de execução necessário aumenta conforme aumenta o tamanho dos dados. Mas métodos que utilizam Sets para manipulações como inserção, exclusão e pesquisa possuem uma complexidade de tempo  O (1), e isso significa que o tempo de execução não varia, pois o tamanho dos dados não influencia no tempo de execução dos métodos.

Teste:

Realizando um teste, vamos criar um array e um set com um milhão de entradas cada:

let newArray = [], newSet = new Set(), n = 1000000;

for (let i = 0; i < n; i++){
    newArray.push(i);
    newSet.add(i);
}

Agora, pesquisaremos o número 425123 no array e no set:

let result; 
console.time('Array');
result = newArray.indexOf(425123) !== -1;
console.timeEnd('Array');

console.time('Set');
result = newSet.has(425123);
console.timeEnd('Set');

E a saída foi:

// Array: 1.201ms
// Set: 0.029ms

Gostaram deste artigo? Comente abaixo!

Referência: https://medium.com/@bretcameron/how-to-make-your-code-faster-using-javascript-sets-b432457a4a77

Bootstrap 5 – Mudanças

Olá pessoal, neste artigo mostraremos as novidades do Bootstrap 5. A versão alfa já está disponível e há muitas diferenças entre as versões 4 e 5. Mas quais serão as mudanças?

jQuery

O Bootstrap 5 não depende mais do jQuery. Isso mesmo! O jQuery não é mais uma dependência no Bootstrap 5. Ele mudou para a utilização do próprio JavaScript (Vanilla) e isso é mérito do próprio jQuery. Ele foi uma peça fundamental no desenvolvimento Front-End, impulsionando mudanças nas tecnologias de desenvolvimento de interfaces web na última década. Os projetos construídos em Bootstrap 5 serão significativamente mais leves em tamanho e no carregamento de páginas.

Uma das alterações possíveis foi trocar a abordagem do plugin de botão em HTML e CSS para alternar estados. Você pode visualizar a lista de alterações relacionadas ao JavaScript na versão alfa do Bootstrap 5 aqui.

Novos visuais e sensações

O site e documentação agora não possuem mais largura total da página, melhorando a visibilidade e legibilidade, tornando o site mais semelhante à página de conteúdo, e não a um aplicativo. A barra lateral de seções expansíveis foi atualizada para uma navegação mais rápida. O Bootstrap também possui um novo logotipo que foi inspirado no CSS.

Fim do suporte ao Internet Explorer

O suporte para o Internet Explorer foi abandonado na versão 5. O foco da atualização é a construção de ferramentas mais amigáveis para o futuro.

Propriedades personalizadas no CSS

Graças ao fim do suporte ao Internet Explorer, foi possível começar a utilizar propriedades personalizadas ao CSS. A equipe de atualização do Bootstrap está trabalhando para utilizar os poderes das propriedades personalizadas Sass e CSS para um sistema mais flexível.

Personalização da documentação

A documentação foi aprimorada em diversos lugares, aumentando as explicações, removendo ambiguidades e fornecendo mais suporte para entender o Bootstrap. A documentação personalizada expande a página Theming da v4 com mais conteúdo e fragmentos de código para construir sobre arquivos Sass de origem Bootstrap. A paleta de cores também foi expandida na v5. Você pode personalizar a aparência da sua aplicação sem sair da base de código. Isso ajudará a tornar os sites baseados em Bootstrap mais acessíveis para todos.

Formulários

A documentação e componentes dos formulários foi revisada e foram consolidados todos os estilos de formulários na nova seção Formulários. Cada caixa de seleção, rádio, arquivo, entre outros, inclui uma aparência personalizada para unificar o estilo e comportamento dos controles de formulário no S.O. e navegador.

Você pode verificar mais atualizações no seguinte link: https://blog.getbootstrap.com/2020/06/16/bootstrap-5-alpha/

Gostou deste artigo? Comente abaixo!

Referências:

O método Call

Neste artigo falaremos mais sobre o método call() que nos permite reaproveitar métodos em contextos (this) diferentes. No artigo tentarei explicar as coisas com a menor complexidade possível e resumirei alguns itens, então para aquele que sabem bem JavaScript por favor calma ai… rsrsrsr

Primeiro vamos entender mais sobre a chamada em si. É importante saber que ela:

  • É nativa, não precisa chamar biblioteca, framework, etc…
  • É um método das funções. Sim, se você ainda não sabia as funções são um tipo de dado que possui métodos/funções próprias;
    • Se ficou confuso, aguarde o exemplo.
  • Recebe um parâmetro que informa o seu contexto onde estarão os dados a executar;
    • Nesse caso contexto é uma função, objeto ou até o window se você estiver procurando pelo em ovo.
  • Pode receber mais parâmetros depois do this. Estes parâmetros se referem qualquer outro valor que você queira enviar para a função;

Note que eu estou usando as palavras função e método de forma alternada. Isso é porque eles são a mesma e tem mais diferença entre function e arrow function do que eles. 🙂

Exemplo básico

// Se chamar essa função do jeito que está aqui, vai exibir undefined pois this.umLocal não tem um valor atribuido a ele.
function ola(){
    console.log(`Olá ${this.umLocal}`);
}

// Agora vamos criar um objeto mais simples possível com a variavel umLocal
const teste = {
    umLocal : "MundoJS"
}

//Lembra quando eu disse que o call é um método das funções? Olhá só…
ola.call(teste);

Se você executar o código acima verá que ele exibirá Olá MundoJS no console. Vejamos o que aconteceu então:

  1. Criamos uma função chamada ola().
  2. Essa função exibe algo no console e chama o this.umLocal
  3. Sem fazer a chamada call() a função olha dentro de seu contexto (o this dela), não acha nada e exibe a mesma coisa
  4. Criamos um objeto com uma variável.
    1. Note que não precisamos dizer que é no contexto do objeto, mas está lá
  5. Invocamos o método call() da função ola passando o “teste” como novo contexto.
  6. Ao tentar executar a função, desta vez ela olha no teste e encontra a variável para usá-la no console.log()

Vejamos então mais alguns exemplos

1 – Passando os parâmetros da função:

// Desta vez ola recebe um parâmetro chamado saudacao
function ola(saudacao){
// aviso: se colocar this.saudacao ele não vai achar no call()…
// a explicação do porque sai bastante do artigo, mas se você entender bem de “this” e functions já deve ter se ligado. Caso queira saber mais, prende um comentário pedindo um tutorial sobre this
    console.log(`${saudacao} ${this.umLocal}`);
}

const teste = {
    umLocal : "Universo"
}
// O primeirpo parâmetro do call sempre é o “this”, depois disso você pode chamar todos os parâmetros da própria função.
ola.call(teste, "Olá");

2 – Usando métodos de Arrays em objetos que são listas mas não vetores.

Com o ES6 vieram diversos métodos muito uteis como o filter, forEach,reduce, etc… dai você tenta usar ele em uma lista que não é um vetor/array [] e não da certo pois eles não possuem isso.

// Erro pois é um HTMLCollection
document.getElementsByTagName("p").forEach(x => console.log(x));

// Vamos criar um objeto parecido com um vetor
let arrayLike = {
  0: "Olá",
  1: "MundoJS",
  length: 2
};

// e uma função para ser chamada no reduce()
function juntar(acc, cur){
    acc = `${acc} ${cur}`;
}

// Erro
// Motivo: O seu objeto parece um array (possui indices e length) mas não é um vetor e por isso não tem o método reduce nele
arrayLike.reduce(juntar);

// Agora se chamarmos o reduce e passarmos forçarmos ele a aceitar nosso objeto como o contextosArray.prototype.reduce.call(arrayLike, juntar);

Isso ai então pessoal, espero que o artigo ajude a matar algumas duvidas sobre o call e qualquer coisa perguntem aqui nos cometários. Até mais.

TypeScript: Upload de arquivos para o Azure Storage

Veja nesse artigo como fazer upload dos seus arquivos para o Azure Blob Storage

npm i multer-azure-blob-storage --save
import * as multer from 'multer';
import { MulterAzureStorage } from 'multer-azure-blob-storage';


const azureStorage: MulterAzureStorage = new MulterAzureStorage({
    connectionString: 'connectionString',
    accessKey: 'accessKey',
    accountName: 'accountName',
    containerName: 'containerName',
    containerAccessLevel: 'blob',
    urlExpirationTime: 60
});

const uploadAzure = multer({ storage: azureStorage });

export default uploadAzure;

Em seguida, caso esteja acompanhando esse passo a passo utilizando o projeto do meu artigo anterior, atualize o método post dentro do seu arquivo index.ts com o trecho de código abaixo:

app.post('/', uploadAzure.single('file'), (req, res) => {
    if (!req.file) {
        res.send('Erro ao fazer upload do arquivo!');
    } else {
        res.send('Arquivo enviado com sucesso!');
    }
})

Obs.: Não esquece de importar no inicio do arquivo o módulo abaixo:

import uploadAzure from './uploadAzure';

Image for post

2º no campo de pesquisa digite: blob e selecione a primeira opção demonstrada abaixo:

Image for post

3º Clique em create:

Image for post

Image for post

Image for post
Em seguida cole ele dentro da variável connectionString:
Image for post
2º copie o valor de Key (1 ou 2):
Image for post
E cole dentro da variável accessKey
Image for post
3º Copie o valor de Storage account name:
Image for post
E cole em accountName:
Image for post
npm run compile
//esse comando deve fazer o transpile
npm start
//esse comando deve rodar o projeto na porta 3000
Image for post
Acessando agora o nosso serviço Storage accounts, va em -> Storage Explorer -> Blob Containers -> clique no nome do container que você criou e veja a listagem dos arquivos que você fez upload:
Image for post

Referências:https://medium.com/typescript/typescript-upload-de-arquivos-para-o-azure-storage-838fccc83a2e