Forem: thaisandre

Web Components: uma introdução

thaisandre — Tue, 13 Jul 2021 12:27:55 +0000

Imagine um projeto web que mostre os dados dos usuários em um componente cartão que será usado em várias páginas no projeto:

Ao invés de copiar e colar este código em vários arquivos HTML diferentes, podemos criar nossa própria tag que renderiza este cartão e encapsula os estilos (CSS) e comportamentos (JavaScript).

Primeiro, criamos o arquivo UserCard.js que conterá o código JavaScript deste componente e criamos uma classe representando este componente:

// arquivo UserCard.js

class UserCard {
}

Até aqui, esta é apenas a declaração de uma classe em JavaScript.

Custom Elements

Como queremos criar uma tag, devemos definí-la como um elemento HTML. Para isto, basta fazer nossa classe implementar a interface HTMLElement:

// arquivo UserCard.js

class UserCard extends HTMLElement {
}

HTMLElement é uma interface que implementa outra chamada Element - que é a interface base mais geral da qual todos os objetos em um Document implementam. De acordo com a documentação, se queremos criar uma tag, o mais indicado é usar HTMLElement, já que esta provê todos os recursos necessários para construção de uma tag HTML.

Após isso, colocamos o construtor e chamamos o super() da interface HTMLElement:

// arquivo UserCard.js

class UserCard extends HTMLElement {

    constructor() {
        super();
    }

}

E, por último, precisamos registrar nossa tag no CustomElementRegistry - que está disponível globalmente pela variável customElements e permite registrar um elemento customizado em uma página:

// arquivo UserCard.js

class UserCard extends HTMLElement {

    constructor() {
        super();
    }

}

customElements.define("user-card", UserCard);

O método define() de customElements recebe como parâmetro o nome da tag a ser definida e o objeto que vai encapsular o código necessário para sua construção. O nome da tag exige o caractere "-" (traço). Caso este padrão não seja seguido e o nome da tag seja definido, por exemplo, como usercard, receberemos um DOMException no momento de usar a tag:

Uncaught DOMException: Failed to execute 'define' on 'CustomElementRegistry': "usercard" is not a valid custom element name

Por este motivo manteremos o nome como user-card. E para usar nossa nova tag, devemos importá-la em um arquivo HTML e utilizar com a mesma sintaxe de uma tag comum:

<!-- arquivo index.html -->

<html>
    <head>
        <meta charset="UTF-8">
    </head>
    <body>
        <h2>Web Components</h2>

        <user-card></user-card>

        <script src="UserCard.js"></script>
    </body>
</html>

Como nossa tag não faz nada até o momento, nada vai aparecer no navegador além da frase "Web Components" ao abrir o arquivo index.html. Todo elemento HTML tem a propriedade innerHTML que corresponde ao seu conteúdo. Para vermos algum resultado, vamos sobrescrever esta propriedade com algum conteúdo - por exemplo, com o nome do usuário do componente cartão que estamos desenvolvendo:

// arquivo UserCard.js

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.innerHTML = "<h2>Fulano de Tal<h2>"
    }

}

customElements.define("user-card", UserCard);

Que vai gerar o resultado:

Templates

Nossa tag customizada, apesar de simples, já funciona como esperado. Agora vamos utilizar e entender um pouco sobre outro recurso bastante utilizado quando trabalhamos com componentes web que são os Templates.

Com templates, é possível definir blocos de códigos reutilizáveis. Apesar de já conseguirmos isso sem eles, os templates apresentam uma forma mais racional de fazer isso.

Suponha que queremos repetir o uso de nosso componente várias vezes na página. Seriam muitas chamadas de this.innerHTML = "<h2>Fulano de Tal</h2>". Ou seja, construiria esse elemento várias vezes, sendo que uma única vez já seria necessário.

Ao invés de adicionarmos o conteúdo com innerHTML toda vez que o objeto é construído, podemos usar templates. Como dito na documentação do MDN Web Docs: O elemento HTML <template> é um mecanismo para encapsular um conteúdo do lado do cliente que não é renderizado quando a página é carregada, mas que pode ser instanciado posteriormente em tempo de execução usando JavaScript.

Portanto, ao criarmos algum conteúdo dentro da tag <template>, este conteúdo não é mostrado imediatamente. Mas pode ser clonado para ser posteriormente renderizado:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `<h2>Fulano de Tal</h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        // código removido
    }
}

customElements.define("user-card", UserCard);

Note que criamos o template fora da classe. Agora será preciso clonar o conteúdo deste template que está disponível pelo atributo content. E para clonar o conteúdo, utilizamos o método cloneNode():

template.content.cloneNode(true)

O método cloneNode() recebe um parâmetro booleano para indicar se os elementos filhos do nó que está sendo clonado devem ser clonados juntos ou não. Vamos definir com o valor true para clonar os filhos também.

Agora devemos pegar este elemento clonado e adicionar em nosso componente através do método appendChild():

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `<h2>Fulano de Tal</h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.appendChild(template.content.cloneNode(true));
    }
}

customElements.define("user-card", UserCard);

Esta técnica reduz o custo de análise do HTML porque o conteúdo do modelo é analisado apenas uma vez pelo DOMParser, enquanto que chamar innerHTML dentro do construtor irá analisar o HTML para cada instância. Isso garante uma melhoria na performance de nosso componente.

Atributos

E se quisermos que cada componente que será renderizado na página tenha um conteúdo diferente? Podemos, como qualquer tag HTML, definir atributos. Por exemplo:

<!-- arquivo index.html -->

<html>
    <head>
        <meta charset="UTF-8">
    </head>
    <body>
        <h2>Web Components</h2>

        <user-card name="Fulano de Tal"></user-card>
        <user-card name="Ciclano de Tal"></user-card>

        <script src="UserCard.js"></script>
    </body>
</html>

O atributo name é definido por nós e pode ter o nome que considerarmos conveniente. Neste momento, nosso template está com um conteúdo fixo e devemos modificar de acordo com atributo name recebido pela nossa tag.

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `<h2></h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.appendChild(template.content.cloneNode(true));
        this._name = this.getAttribute("name");
        this.querySelector("h2").textContent = this._name;
    }
}

customElements.define("user-card", UserCard);

Como nosso componente é um HTMLElement, podemos usar e abusar de todos os recursos que uma tag comum do HTML possui, como o método getAttribute() para pegar o valor do atributo name que definimos anteriormente. E teremos o resultado:

Shadow DOM

Agora que aprendemos um pouco sobre templates, vamos adicionar um estilo para nosso componente. Primeiro, vamos adicionar um estilo para a tag h2 diretamente no arquivo index.html:

<!-- arquivo index.html -->

<html>
    <head>
        <meta charset="UTF-8">
        <style>
            h2 {
                color: red;
            }
        </style
    </head>
    <body>
        <h2>Web Components</h2>

        <user-card name="Fulano de Tal"></user-card>
        <user-card name="Ciclano de Tal"></user-card>

        <script src="UserCard.js"></script>
    </body>
</html>

E vamos obter o seguinte resultado:

Como todos os elementos da página, inclusive de nosso componente, estão dentro de uma tag h2, todos receberão o estilo global. Mas podemos adicionar um estilo específico para nosso componente, modificando a cor para azul, por exemplo. Podemos adicionar a tag <style> em nosso template:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `
    <style>
        h2 {
            color: blue;
        }
    </style>
    <h2></h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.appendChild(template.content.cloneNode(true));
        this._name = this.getAttribute("name");
        this.querySelector("h2").textContent = this._name;
    }
}

customElements.define("user-card", UserCard);

Agora temos dois estilos na página para tag h2, o estilo global dentro do arquivo index.html e o estilo dentro de nosso componente. Qual será que vai ser aplicado em cada caso? Ao renderizar a página, obtemos:

Repare que o estilo de nosso componente foi aplicado também para o conteúdo da tag h2 fora dele. Isso acontece porque o template com o estilo de nosso componente é carregado por último e acaba por sobrescrever o estilo da tag h2 externo.

Você pode argumentar que podemos evitar isso utilizando classes CSS e você está totalmente correto! Mas imagine o cenário de um projeto grande em que cada desenvolvedor é responsável por um componente específico. Há grandes chances de nomes iguais de classes CSS serem utilizadas, e isso pode gerar um grande transtorno.

Para evitar este tipo de conflito que trabalharemos com outro recurso chamado de Shadow DOM. A ideia é encapsular código HTML, CSS e JavaScript de nosso componente para não provocar e/ou sofrer alteração externa.

O Shadow DOM é uma sub árvore do DOM que tem seu próprio escopo e que não faz parte do DOM original, tornando possível construir interfaces modulares sem que entrem em conflito uma com a outra.

fonte da imagem: MDN Web Docs

Como especificado no MDN Web Docs, existem algumas terminologias do Shadow DOM que devemos conhecer:

Shadow host: o nó DOM regular ao qual o Shadow DOM está anexado.
Shadow tree: a árvore DOM dentro do Shadow DOM.
Shadow boundary: o lugar onde termina o Shadow DOM e começa o DOM regular.
Shadow root: o nó raiz da Shadow tree.

Dito isto, vamos ver como funciona na prática. Iremos isolar nosso componente dentro de um Shadow DOM. Para isso, precisamos criar o nó raiz Shadow Root dentro de nosso componente - que será o Shadow Host. A classe HTMLElement possui o método attachShadow() que podemos utilizar para abrir e criar uma referência para um Shadow Root.

Um Shadow Root possui dois modos: aberto e fechado. Antes de entrarmos nas diferenças entre esses dois modos, iremos criar nosso Shadow Root no modo aberto para ver como ele funciona. O método attachShadow() exige que passemos o modo como parâmetro:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `
    <style>
        h2 {
            color: blue;
        }
    </style>
    <h2></h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.attachShadow({mode: 'open'}); // criando o Shadow Root
        this.appendChild(template.content.cloneNode(true));
        this._name = this.getAttribute("name");
        this.querySelector("h2").textContent = this._name;
    }
}

customElements.define("user-card", UserCard);

Após esta mudança, ao renderizar novamente a página, vemos que nosso componente não é renderizado e volta a receber o estilo global definido para a tag h2:

Mas é possível verificar que o Shadow Root foi criado inspecionando a página através da ferramenta DevTools do navegador pela aba Elemets:

Note que o conteúdo do template também foi anexado a tag <user-card> mas não é mostrado já que está fora do Shadow Root. Uma vez aberto o Shadow Root, devemos anexar os conteúdos, como nosso template, dentro dele. Após a chamada do método attachShadow(), uma referência ao objeto Shadow Root aberto é disponibilizado através do atributo shadowRoot:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `
    <style>
        h2 {
            color: blue;
        }
    </style>
    <h2></h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.attachShadow({mode: 'open'});
        this.shadowRoot.appendChild(template.content.cloneNode(true));  // código modificado
        this._name = this.getAttribute("name");
        this.shadowRoot.querySelector("h2").textContent = this._name; // código modificado
    }
}

customElements.define("user-card", UserCard);

Agora, nosso componente é renderizado como antes porque foi anexado ao Shadow Root, vamos novamente inspecioná-lo pela ferramenta DevTools:

Note que agora o conteúdo está dentro do Shadow Root. E como ele está dentro de uma Shadow Tree separada do DOM original, os estilos globais não afetam nosso componente e o resultado da renderização da página é este:

Este foi um exemplo utilizado para encapsular os estilos. Mas o mesmo vale para eventos que possam ser registrados em nosso componente - como um evento de click que pode afetar muitos elementos de uma página e o Shadow DOM vai garantir o encapsulamento.

Agora que vimos um pouco como o Shadow DOM funciona, vamos entender a diferença entre os modos aberto e fechado. O Shadow Root no modo aberto permite que façamos modificações em sua estrutura utilizando JavaScript. Se quisermos acessar o Shadow Root de nosso componente, basta digitar no console:

document.querySelector("user-card").shadowRoot

Isso nos permite acessar o shadowRoot de nosso componente:

E fazer modificações em seu conteúdo, como modificar o conteúdo da tag h2 de nosso componente:

Repare que o encapsulamento, neste sentido, é quebrado já que podemos modificar sua estrutura através do JavaScript. Para que o encapsulamento seja realmente aplicado é que existe o modo fechado do Shadow DOM. Vamos modificar nosso componente para o modo fechado:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `
    <style>
        h2 {
            color: blue;
        }
    </style>
    <h2></h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this.attachShadow({mode: 'closed'});  // modificado para o modo fechado
        this.shadowRoot.appendChild(template.content.cloneNode(true));
        this._name = this.getAttribute("name");
        this.shadowRoot.querySelector("h2").textContent = this._name;
    }
}

customElements.define("user-card", UserCard);

Mas, ao fazer isso, nosso componente nem sequer é renderizado:

Isso acontece porque o acesso ao atributo shadowRoot não é mais possível. this.shadowRoot agora vai retornar null e receberemos o seguinte erro no console:

Portanto, não será mais possível acessar o shadowRoot externamente pelo JavaScript:

Só será possível fazê-lo dentro de nosso componente. Para isso, criaremos uma referência para ele e assim será possível manipulá-lo e clonar o template para que seja renderizado na página:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `
    <style>
        h2 {
            color: blue;
        }
    </style>
    <h2></h2>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this._shadowRoot = this.attachShadow({mode: 'closed'});
        this._shadowRoot.appendChild(template.content.cloneNode(true));
        this._name = this.getAttribute("name");
        this._shadowRoot.querySelector("h2").textContent = this._name;
    }
}

customElements.define("user-card", UserCard);

Dessa maneira, nosso componente é renderizado como antes:

E o acesso ao shadowRoot, via JavaScript, continua retornando null:

Agora temos nosso componente encapsulado e fechado para modificações externas com JavaScript. É evidente que ainda podemos acessá-lo da seguinte forma:

Mas, seguindo as boas práticas da linguagem, isso deve ser evitado já que indica que este atributo é privado e não deve ser acessado fora da classe UserCard.

Isolando o CSS

Escrever código CSS dentro de um template string não é o ideal. O melhor seria se o código CSS de nosso componente ficasse em um arquivo externo de estilos.

Primeiro, vamos criar o arquivo UserCard.css.

/* arquivo UserCard.css */

h2 {
    color: blue;
}

Em seguida, modificamos nosso componente para utilizar este arquivo CSS - importando o arquivo através da tag <link>:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = ` 
    <link type="text/css" rel="stylesheet" href="UserCard.css"></link>
    <h2></h2>`;

class UserCard extends HTMLElement {
    // código omitido
}

customElements.define("user-card", UserCard);

Também é possível utilizar o recurso de regra atribuída do CSS através do @import:

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = ` 
    <style>@import url("UserCard.css")</style>
    <h2></h2>`;

class UserCard extends HTMLElement {
    // código omitido
}

customElements.define("user-card", UserCard);

Mas como comentado no MDN Web Docs, o carregamento de um estilo externo feito dessa maneira dentro do ShadowRoot pode causar o temido FOUC (Flash of Unstyled Content) - ou seja, pode ocorrer um flash do conteúdo não estilizado enquanto o CSS é carregado.

Por este motivo, muitos desenvolvedores mantêm o conteúdo dos estilos dentro da tag <style> no template string ao invés de tentar evitar FOUC com código adicional - até o momento não existe uma maneira fácil e rápida de evitar isso.

Por facilidade e para evitar este tipo de problema, optaremos por manter o código de estilos dentro do template string, utilizando a tag <style>.

Finalizando o componente do cartão

Agora que entendemos um pouco sobre componentes, podemos voltar ao nosso objetivo final que era criar o componente de cartão de usuários. Basta refatorarmos o código modificando o template de nosso componente e fazendo os ajustes em seu construtor. O código final ficaria assim:

<!-- arquivo index.html -->

<html>
    <head>
        <meta charset="UTF-8">
    </head>
    <body>
        <h2>Web Components</h2>

        <user-card name="Fulano de Tal" job="Desenvolvedor de Software" image="user.png"></user-card>

        <script src="UserCard.js"></script>
    </body>
</html>

// arquivo UserCard.js

const template = document.createElement('template');
template.innerHTML = `
    <style>
        .card {
            font-family: Arial;
            border: 1px solid #c5c9d1;
            border-radius: 4%;
            width: 150px;
            height: 60px;
            display: flex;
            color: #5b6069;
            font-size: 12px;
            padding: 10px;
        }

        .card:hover {
            background-color: hsl(0, 0%, 97%);
        }

        .card-image,
        .card-content {
            padding: 5px;
        }

        .user-image {
            width: 45px;
            height: 45px;
        }

        .user-name {
            font-weight: bold;
        }

        .user-job {
            font-style: italic;
            font-size: 10px;
            margin-top: 2px;
        }
    </style>
    <div class="card">
        <div class="card-image">
            <img class="user-image" src="user.png"/>
        </div>
        <div class="card-content">
            <div class="user-name"></div>
            <div class="user-job"></div>
        </div>    
    </div>`;

class UserCard extends HTMLElement {

    constructor() {
        super();
        this._shadowRoot = this.attachShadow({mode: 'closed'});
        this._shadowRoot.appendChild(template.content.cloneNode(true));
        this._name = this.getAttribute("name");
        this._job = this.getAttribute("job");
        this._image = this.getAttribute("image");
        this._shadowRoot.querySelector(".user-name").textContent = this._name;
        this._shadowRoot.querySelector(".user-job").textContent = this._job;
        this._shadowRoot.querySelector(".user-image").src = this._image;
    }
}

customElements.define("user-card", UserCard);

E temos como resultado o componente do cartão do usuário, podendo ser reutilizado em qualquer outra página HTML de nosso projeto:

Conclusão

Web Components (componentes web) possui uma especificação própria. Como descrito no MDN Web Docs, Web Components é uma suíte de diferentes tecnologias que permite a criação de elementos customizados reutilizáveis — com a funcionalidade separada do resto do seu código — e que podem ser utilizados em suas aplicações web.

Para utilizar Web Components não é necessário nenhuma biblioteca adicional ou framework, desde que o navegador implemente as seguintes especificações da Web Api:

Custom Elements - permite definir tags customizadas
Templates - permite definir blocos de códigos reutilizáveis
Shadow DOM - permite encapsular o código do componente em uma árvore separada do DOM

Segundo a documentação, atualmente Web Componentes é suportado por padrão no Firefox (versão 63), Chrome, Opera e Edge (versão 79). O Safari já suporta boa parte delas mas não todas. De todo modo, é possível usar Web Components em qualquer navegador através do Polyfill - que nada mais é do que um pedaço de código (geralmente JavaScript) utilizado para simular os recursos ausentes do navegador o mais próximo possível.

Web Components é ainda um conceito novo quando utilizado em JavaScript nativo. Componentes são muito utilizados por bibliotecas e frameworks como Angular, React e Vue - ferramentas sólidas e muito famosas dentro da comunidade front-end. E Web Components, por ser nativo, pode ser utilizado juntamente com essas ferramentas.

Se considerarmos uma equipe grande, separada em vários times, em que cada time utiliza uma ferramenta diferente para cada parte de um projeto, pode acontecer de existir partes em comum entre elas como uma tela de login - com a mesma estrutura para dar unidade ao projeto. Com Web Components, é possível criar um componente nativo que seja compartilhado entre os times. Ou seja, facilita a interoperabilidade do sistema.

Um artigo interessante que compara Web Components com demais ferramentas, levando em consideração estilos de código, performance e bundle-size, é o All the Ways to Make a Web Component do pessoal do WebComponents.dev. Vale dar uma conferida!

No mais, a ideia deste post era apresentar conceitos básicos sobre Web Components e como construir um simples componente com pouco código. Web Components vai muito além. Em futuros posts desta série pretendo mostrar outros recursos como o ciclo de vida de um componente, registro de eventos, componentes compostos e como podemos gerenciar melhor o estado de seus atributos. Até a próxima!

nltk e processamento de linguagem natural

thaisandre — Thu, 08 Jul 2021 15:10:18 +0000

"And what is the use of a book", thought Alice, "without pictures or conversations?"

nltk (Natural Language Toolkit) é um pacote para trabalhar com Processamento de Linguagem Natural (NLP) no Python. Por linguagem natural entende-se a linguagem usada no dia a dia na comunicação entre pessoas.

Muitos dados são gerados, dia a dia, por blogs, redes sociais e páginas web. A maioria destes dados estão em formato de texto não estruturado e são usados por empresas para entender seus clientes e melhorar (e produzir novos) produtos. NLP é útil em detecção de erros gramaticais e traduções automáticas, análise de sentimento em discursos, motores de busca, filtros de spam, etc…

O nltk possui muitos recursos para análise de texto e conheceremos alguns deles.

instalação

sudo pip3 install -U nltk

acessando os dados

Vamos analisar o livro Alice no País das Maravilhas, de Lewis Carroll, disponível pelo projeto Gutenberg neste link.

O nltk possui um pacote com amostras de dados para uso, inclusive alguns do próprio projeto Gutenberg. A lista completa dos dados disponíveis pode ser acessada aqui. O pacote não vem habilitado por padrão, para instalá-lo, faça:

>>> import nltk
>>> nltk.download()

Uma janela deve abrir. É recomendado que você modifique o local do download para usr/share/nltk_data - diretório do Linux para armazenar dados que não serão modificados (mais informações aqui). Caso esteja utilizando Windows, a recomendação é salvar no diretório C:\nltk_datae no Mac em /usr/local/share/nltk_data.

Também é possível instalar via linha de comando:

$ sudo python3 -m nltk.downloader -d /usr/local/share/nltk_data all

Uma vez que o download dos dados esteja concluído, podemos carregar e usar seu pacotes através do comando import:

>>> import nltk.corpus as corpus

A palavra corpus é utilizada na língua inglesa para denotar uma coleção de material escrito ou falado em formato legível por máquina, montado para fins de pesquisa lingüística. O pacote corpus possui exatamente isso, várias amostras de textos que podemos utilizar para análise. Usaremos o atributo gutenberg para acessar alguns textos do projeto Gutenberg que carregamos com o download dos dados do nltk.

>>> type(corpus.gutenberg)
<class 'nltk.corpus.reader.plaintext.PlaintextCorpusReader'>

corpus.gutenberg é um atributo do tipo PlaintextCorpusReader. Este objeto, segundo a documentação (acesse pelo comando help(corpus.gutenberg)), é um leitor para corpus de texto plano - é assumido que parágrafos são divididos usando quebra de linha, as frases
finalizam com pontuações específicas (como ponto, exclamação ou interrogação) e palavras podem ser dividas em unidades.

Vamos checar os textos disponíveis neste objeto:

>>> corpus.gutenberg.fileids()
['austen-emma.txt', 'austen-persuasion.txt', 'austen-sense.txt', 'bible-k
jv.txt', 'blake-poems.txt', 'bryant-stories.txt', 'burgess-busterbrown.tx
t', 'carroll-alice.txt', 'chesterton-ball.txt', 'chesterton-brown.txt',
'chesterton-thursday.txt', 'edgeworth-parents.txt', 'melville-moby_dick.t
xt', 'milton-paradise.txt', 'shakespeare-caesar.txt', 'shakespeare-hamle
t.txt', 'shakespeare-macbeth.txt', 'whitman-leaves.txt']

A função fileids() mostra os arquivos disponíveis. Para acessar o livro Alice no País das Maravilhas, usaremos o seu fileid que é o carroll-alice.txt através do método raw():

>>> alice = corpus.gutenberg.raw('carroll-alice.txt')
>>> type(alice)
<class 'str'>

O método raw() retorna uma string com todo o conteúdo do livro. Quem já trabalhou com strings conhece a dificuldade de trabalhar com estes objetos. Outros objetos do nltk irão nos ajudar para conseguir analisar melhor este conteúdo.

tokenization

Tokenization é o nome dado para o processo de dividir uma grande quantidade de texto em pequenas quantidades - essas pequenas quantidades são chamadas de tokens. Essa é uma divisão importante para fazer análises textuais.

O nltk possui um módulo chamado tokenize que facilita o processo de divisão de um texto. A função word_tokenize() divide um texto por palavras e pontuações:

from nltk.tokenize import word_tokenize
>>> texto = 'Hello, how are you?'
>>> word_tokenize(texto)
['Hello', ',', 'how', 'are', 'you', '?']

Além da divisão por palavras, podemos querer dividir um texto em sentenças para calcular a média de palavras por sentenças, por exemplo. Para isso usamos a função sent_tokenize():

from nltk.tokenize import sent_tokenize
>>> texto = 'Hello, how are you? Fine, thanks!'
>>> sent_tokenize(texto)
['Hello, how are you?', 'Fine, thanks!']

E para dividir em parágrafos, usamos line_tokenize():

from nltk.tokenize import line_tokenize
>>> texto = 'Lorem ipsum dolor sit amet, amet blandit suscipit quam tellu
s vitae mauris, ut metus tellus, curabitur et elit, in volutpat, fringill
a aliquam. \nDonec cras tristique, quis eu. Ipsum integer quis sapien ves
tibulum wisi vel, scelerisque justo massa nulla tempor in, placerat ut se
m nunc ultrices ac, quis conubia.'
>>> line_tokenize(texto)
>>> ['Lorem ipsum dolor sit amet, amet blandit suscipit quam tellus vitae
mauris, ut metus tellus, curabitur et elit, in volutpat, fringilla aliqua
m.',
'Donec cras tristique, quis eu. Ipsum integer quis sapien vestibulum wis
i vel, scelerisque justo massa nulla tempor in, placerat ut sem nunc ultr
ices ac, quis conubia.']

No próprio objeto gutenberg, temos funções prontas como paras(), sents() e words() que retornam o conteúdo do texto separados por parágrafos, sentenças e palavras, respectivamente. Você pode testar cada um deles:

>>> paragrafos = corpus.gutenberg.paras('carroll-alice.txt')
>>> paragrafos
[[['[', 'Alice', "'", 's', 'Adventures', 'in', 'Wonderland', 'by', 'Lewi
s', 'Carroll', '1865', ']']], [['CHAPTER', 'I', '.'], ['Down', 'the', 'Ra
bbit', '-', 'Hole']], ...]

>>> sentencas = corpus.gutenberg.sents('carroll-alice.txt')
>>> sentencas
[['[', 'Alice', "'", 's', 'Adventures', 'in', 'Wonderland', 'by', 'Lewis'
, 'Carroll', '1865', ']'], ['CHAPTER', 'I', '.'], ...]

>>> palavras = corpus.gutenberg.words('carroll-alice.txt')
>>> palavras
['[', 'Alice', "'", 's', 'Adventures', 'in', ...]

>>> type(paragrafos)
<class 'nltk.corpus.reader.util.StreamBackedCorpusView'>
>>> type(sentencas)
<class 'nltk.corpus.reader.util.StreamBackedCorpusView'>
>>> type(palavras)
<class 'nltk.corpus.reader.util.StreamBackedCorpusView'>

Todos eles retornam um objeto do tipo StremBackedCorpusView que representa uma visualização do corpus através de uma sequência de tokens iterável. Este objeto também possui métodos, como o count() para contar o número de vezes que um elemento aparece na sequência de tokens.

primeiras análises

Vamos usar o count() para checar o número de vezes que determinados personagens são citados no texto. Por exemplo, se queremos saber quantas vezes a palavra "Alice" aparece, fazemos:

>>> palavras.count('Alice')
396

Vamos fazer a contagem de mais alguns personagens:

>>> personagens = ['Alice', 'Rabbit', 'Caterpillar', 'Cat', 'Hatter', 'Do
rmouse', 'Hare', 'Queen', 'King', 'Gryphon' ]
>>> for p in personagens:
...     print('{}: {}'.format(p, palavras.count(p)))
...
Alice: 396
Rabbit: 45
Caterpillar: 0
Cat: 26
Hatter: 55
Dormouse: 40
Hare: 31
Queen: 74
King: 61
Gryphon: 55

Legal, obtemos a frequência de aparição de cada personagem no livro. Mas e se quisermos saber em quais partes do livro estes personagens aparecem? O nltk facilita essa visualização através da classe Text.

A classe Text funciona como um wrapper de uma sequência de tokens (como nossa variável palavras) e ajuda na exploração de textos. Seus métodos executam várias análises e exibe seus resultados, como é o caso do método dispersion_plot(), que plota um gráfico de dispersão. Primeiro precisamos de uma instância de Text com o conteúdo do livro, e obteremos através da variável palavras:

>>> palavras_text = nltk.Text(palavras)

Vamos checar a frequência da palavra "Alice" ao longo do texto:

>>> palavras_text.dispersion_plot(['Alice'])

Agora vamos visualizar as partes em que os personagens que definimos anteriormente aparecem no livro através de um gráfico de dispersão:

palavras_text.dispersion_plot(personagens)

Essa imagem, além de mostrar a frequência que cada personagem aparece na história, permite visualizar os momentos que eles interagem. O eixo x representa o deslocamento das palavras referenciando o índice da sequência do texto.

"Alice", sendo a protegonista, aparece com mais frequência e por toda a história do livro. Vemos que "Caterpillar" (a Lagarta Azul) interage pouco - apenas no início da história - e "Hatter" (Chapeleiro), "Dormouse" (Arganaz) e "Hare" (Lebre de Março) aparecem com uma frequência parecida no meio da história, no momento do famoso chá. O "Rabbit" (Coelho Branco) já interage com "Alice" em vários momentos da história (começo, meio e fim) mas com um frequência pequena.

Podemos usar a função de distribuição de frequência do nltk para determinar as palavras mais frequentes (especificamente tokens), que são usadas em um determinado texto. Para facilitar a visualização, vamos utilizar a classe FreqDist que representa a distribuição dos valores que aparecem com maior frequência em uma amostra. Essa classe possui um método plot() que recebe um número inteiro como parâmetro representando a quantidade dos valores que queremos mostrar. Vamos gerar um gráfico com as 20 palavras mais frequentes no
texto:

>>> freq = nltk.FreqDist(palavras_text)
>>> freq.plot(20)

Esse gráfico não está bom. Veja que ele está contando as palavras que são pontuações (como ponto final e exclamações). Vamos eliminar as pontuações. Podemos filtrar pela função isalpha() do objeto str do próprio Python:

>>> freq_sem_pontuacao = nltk.FreqDist(dict((word, freq) for word, freq i
n freq.items() if word.isalpha()))
>>> freq_sem_pontuacao.plot(20, title="20 palavras mais populares (sem po
ntuação)")

Já está um pouco melhor! Ainda assim, o gráfico traz palavras comuns como “a”, “the”, “to”, etc… Queremos eliminar este tipo de palavra que é irrelevante para nossa busca e aparece com frequência em qualquer texto. Para isso, o nltk possui um recurso chamado de stopwords (palavras de parada). Vamos eliminar também essas stopwords.

Primeiro guardaremos as stopwords da língua inglesa - já que o texto está em inglês - em uma variável chamada stopwords:

>>> stopwords = nltk.corpus.stopwords.words('english')

E filtramos também por essas stopwords (no caso, sem elas):

>>> freq_sem_pontuacao_e_sem_stopwords = nltk.FreqDist(dict((word, freq)
for word, freq in freq.items() if word not in stopwords and word.isalpha
()))
>>> freq_sem_pontuacao_e_sem_stopwords.plot(20, title="20 palavras mais p
opulares (sem stopwords ou pontuações)")

Agora está bem melhor. Vemos que a personagem mais citada no texto, depois de "Alice" é a "Queen" (a Rainha). Podemos facilmente plotar esse gráfico com todos os nomes próprios (ou o que a morfologia chama de substantivos próprios) se existisse uma maneira fácil de identificá-los pelo texto. O nltk possui esse recurso.

explorando o tagger

O nltk possui uma função chamada pos_tag() que infere uma classe (substantivo, adjetivo, advérbio, verbo, etc..) para cada palavra. Como esta função recebe uma lista de tokens, vamos usar a função word_tokenize() com o texto puro:

>>> alice_txt = nltk.corpus.gutenberg.raw('carroll-alice.txt')
>>> words = nltk.word_tokenize(alice_txt)
>>> tags = nltk.pos_tag(words)
>>> tags
[('[', 'JJ'), ('Alice', 'NNP'),("'s", 'POS'), ('Adventures', 'NNS'), ('i
n', 'IN'), ('Wonderland', 'NNP'), ('by', 'IN'), ('Lewis', 'NNP'), ('Carro
ll', 'NNP'), ('1865', 'CD'), (']', 'NNP'), ('CHAPTER', 'NNP'), ('I', 'PR
P'), ('.', '.'), ('Down', 'RP'), ('the', 'DT'), ('Rabbit-Hole', 'JJ'), (
'Alice', 'NNP'), ('was', 'VBD'), ...

Veja que para cada token foi gerada uma tag. A lista completa com a definição de cada uma delas pode ser acessada através do código abaixo:

>>> nltk.help.upenn_tagset()

Estamos interessados nos substativos próprios no singular, ou seja, na tag NNP:

>>> substantivos_proprios= []
>>> for word,tag in tags:
...     if tag in ['NNP'] and word.isalpha():
...         substantivos_proprios.append(word)
...
>>>

Agora que temos a lista de todos os substantivos próprios, vamos plotar o gráfico dos 20 mais frequentes:

>>> freq_substantivos_proprios=nltk.FreqDist(substantivos_proprios)
>>> freq_substantivos_proprios.plot(20, title='20 substantivos próprios m
ais frequentes')

Agora sabemos mais claramente os 20 personagens da história mais citados no texto. E podemos plotar o gráfico da dispersão de com eles, da mesma maneira que fizemos anteriormente com nossa lista de personagens.

>>> mais_comuns = freq_substantivos_proprios.most_common(n=20)
>>> personagens_mais_comuns = []
>>> for nome,freq in mais_comuns:
...     personagens_mais_comuns.append(nome)
...
>>> palavras_text.dispersion_plot(personagens_mais_comuns)

Agora, além dos 20 personagens que aparecem com maior frequência no texto, temos como eles estão dispersos no texto. Note que as palavras "Rabbit" e "White" aparecem com uma frequência parecida, já que fazem referência ao "Coelho Branco", mas nem sempre aparecem juntas. O mesmo acontece com "Hare" e "March" - já que essas palavras fazem referência a "Lebre de Março" . Neste caso, poderíamos excluir desta lista as palavras "White" e "March" para uma análise mais precisa.

Da mesma maneira, podemos querer plotar o gráfico de frequência dos 20 verbos mais usados no texto. Usamos, desta vez, a tag VB:

>>> verbos = []
>>> for word,tag in tags:
...     if tag in ['VB']:
...         verbos.append(word)
...
>>> freq_verbos=nltk.FreqDist(verbos)
>>> freq_verbos.plot(20, title='20 verbos mais frequentes')

E ver analisar sua dispersão pelo texto:

>>> mais_comuns = freq_verbos.most_common(n=20)
>>> verbos_mais_comuns = []
>>> for nome,freq in mais_comuns:
...     verbos_mais_comuns.append(nome)
...
>>> palavras_text.dispersion_plot(verbos_mais_comuns)

Tente fazer o mesmo com os adjetivos, advérbios e substantivos.

análise de sentimento

O nltk é um pacote bastante completo e possui subpacotes para analisar o sentimento de frases. Será que o texto possui mais sentenças que passam sentimentos negativos, positivos ou
neutros? Vamos analisar isso.

O subpacote para analisar sentimento é o nltk.sentiment que possui o módulo vader com diversas funcionalidade para obter métricas de sentimento de uma sentença. VADER é acrônimo de Valence Aware Dictionary and Sentiment Reasoner, ou seja, um dicionário de valência e de raciocínio de sentimento. A palavra valência , em linguística, é o número de elementos gramaticais com os quais uma determinada palavra, especialmente um verbo, pode combinar em uma sentença.

Análise de sentimentos em um texto é uma tarefa complexa e exige muito estudo de linguística. Sorte que o nltk já fez todo este trabalho por nós. O código deste módulo pode ser acessado através deste link.

Para analisar o sentimento de uma sentença, vamos utilizar a classe SentimentIntensityAnalyzer que nos dá uma pontuação de intensidade de sentimento de determinadas sentenças.

Primeiro, vamos importar essa classe e instanciá-la:

>>> from nltk.sentiment.vader import SentimentIntensityAnalyzer
>>> sa = SentimentIntensityAnalyzer()

Esta classe possui o método polarity_scores() que vai gerar as pontuações. Vejamos um exemplo:

>>> frase = 'Good job, nltk!'
>>> sa.polarity_scores(frase)
{'neg': 0.0, 'neu': 0.385, 'pos': 0.615, 'compound': 0.4926}

O retorno é um dicionários com pontuações de -1 a 1, do tipo float, para as chaves neg (sentimento negativo), neu (sentimento neutro), pos (sentimento positivo) e compound (sentimento dos três anteriores combinados). Esta pontuação é exatamente o cálculo da valência.

Veja que a frase "God Job, nltk!" ("Bom trabalho, nltk!") tem uma pontuação positiva alta e a pontuação composta de 0.4926 - ou seja, acima de 0, portanto é uma frase que passa um sentimento positivo.

O vader é muito utilizado para analisar sentimentos de posts em redes sociais. É extremamente rápido e não necessita de treinamento.

Vamos analisar nosso texto para ter uma métrica do número de sentenças positivas, neutras e negativas que ele possui. Para isso utilizaremos a pontuação composta.

Primeiro, vamos dividir nosso texto em sentenças:

>>> alice_txt = nltk.corpus.gutenberg.raw('carroll-alice.txt')
>>> sentencas = nltk.sent_tokenize(alice_txt)
>>> sentencas

Agora, vamos criar duas listas, uma para as sentenças e outra para as pontuações:

>>> lista_pontuacoes = []
>>> lista_sentencas = []
>>> for sentenca in sentencas:
...     lista_sentencas.append(sentenca)
...     pontuacao = sa.polarity_scores(sentenca)
...     lista_pontuacoes.append(pontuacao['compound'])
...

Para plotar o gráfico de quantidade de cada uma das classificações (neutras, negativas e positivas), vamos usar o pandas, uma biblioteca do Python bastante usada para análise de dados. Para instalar o pandas, execute o código abaixo no terminal:

$ pip3 install pandas

Vamos criar um dataframe com estes dados:

>>> import pandas as pd
>>> df = pd.DataFrame({'sentenca': lista_sentencas, 'pontuacao': lista_po
ntuacoes})

A variável df guarda um dataframe, um tipo de dado retangular que representa uma tabela com as colunas senteca e pontuacao. Cada linha dessa tabela, portanto, possui o valor da sentença e sua respectiva pontuação de análise de sentimento (no caso, a pontuação composta).

Você pode checar esta estrutura através da função head() do dataframe:

>>> df.head(10)

Após executado, vai mostrar as primeiras 10 linhas desta tabela. Agora, vamos selecionar apenas as sentenças negativas. O pandas consegue selecionar isso muito facilmente. Uma sentença com sentimento negativo é aquela que possui pontuação menor do que 0 :

>>> selecao_neg = df.pontuacao < 0
>>> negativas = df[selecao_neg]
>>> negativas.head(10)

Selecionamos e guardamos apenas as sentenças negativas em outro dataframe que nomeamos de negativas. Vamos ver sua quantidade:

>>> len(negativas)
394

Legal! Agora sabemos que 394 sentenças do livro Alice no País das Maravilhas passa um sentimento negativo. Vamos fazer o mesmo para os positivos e neutros:

>>> selecao_pos = df.pontuacao > 0
>>> positivas = df[selecao_pos]
>>> len(positivas)
443
>>> selecao_neu = df.pontuacao == 0
>>> neutras = df[selecao_neu]
>>> len(neutras)
788

Sabemos que o texto possui mais sentenças que passam um sentimento positivo do que negativo, mas as neutras superam. Vamos plotar um gráfico de barras para visualizar melhor os resultados:

>>> sentimentos = pd.DataFrame({'sentimentos':['negativo', 'neutro', 'pos
itivo'], 'quantidade':[len(negativas), len(neutras), len(positivas)]})
>>> sentimentos.plot(kind='bar', x='sentimentos', y='quantidade', color=[
'lightblue'], rot=0)

referências

Documentação do nltk. http://www.nltk.org

Steve Bird, Edwan Klein e Edward Loper; Processamento de Linguagem Natural com Python - Analizando textos com Natural Language Toolkit. http://www.nltk.org/book/

Programação assíncrona

thaisandre — Tue, 11 May 2021 01:35:30 +0000

Quando fazemos uma ligação telefônica para uma pessoa para passar uma mensagem, dependemos de outra ação que é a da pessoa atender a chamada. Vamos tentar representar isso em código utilizando a linguagem JavaScript:

function ligacao() {
    console.log("eu faço a chamada");
    console.log("a pessoa atende e diz alô");
    console.log("eu digo alguma informação"); 
}

ligacao();

A saída será:

eu faço a chamada
a pessoa atende e diz alô
eu digo alguma informação

Callbacks

Na realidade, a pessoa não atende a mensagem imediatamente, ela pode demorar alguns segundos para atender. Podemos representar essa "demora" através da função setTimeout que executa uma função após determinado período de tempo. Ela recebe dois argumentos - o primeiro é a função que representa a ação a ser executada e o segundo o valor em milisegundos representando o tempo mínimo de espera para que ela seja executada:

setTimeout(() => {
    console.log("a pessoa atende e diz alô")
}, 3000);

Como resultado, após 3 segundos, temos:

a pessoa atende e diz alô

Agora vamos utilizar este recurso no nosso exemplo:

function ligacao() {
    console.log("eu faço a chamada");
    setTimeout(() => {
        console.log("a pessoa atende e diz alô")
    }, 3000);
    console.log("eu digo alguma informação"); 
}

saída:

eu faço a chamada
eu digo alguma informação
a pessoa atende e diz alô

Note que nosso programa apresenta um problema: a pessoa que fez a chamada (no caso, eu) acaba dizendo alguma coisa antes da outra pessoa atender. Ou seja, a execução não aconteceu de maneira síncrona, mantendo a ordenação esperada. O conteúdo dentro de setTimeout não foi executado imediatamente após a primeira chamada de console.log.

O JavaScript é single-threaded. O que quer dizer, grosso modo, que possui uma stack principal de execução do programa e executa um comando por vez, do início ao fim, sem interrupções. No momento em que cada operação é processada, nada mais pode acontecer.

Acabamos de ver que o funcionamento de nosso programa é diferente quando encontra a função setTimeout. No Node.js, o método setTimeout pertence ao módulo timers que contém funções que executam algum código após um determinado período de tempo. Não é necessário importar este módulo no Node.js já que todos estes métodos estão disponíveis globalmente para simular o JavaScript Runtime Environment dos navegadores.

A chamada da função que passamos como primeiro argumento para o setTimeout é enviada para outro contexto, chamado WEBApi que define um timer com o valor que passamos como segundo argumento (3000) e aguarda este tempo para colocar a chamada da função na stack principal para ser executada - ocorre um agendamento desta execução. Porém, este agendamento só é concretizado após a stack principal ser limpa, ou seja, após todo código síncrono ser executado. Por este motivo, a terceira e última chamada de console.log é chamada antes da segunda.

A função que passamos como primeiro argumento para o método setTimeout é chamada de função callback. Uma função callback é toda função passada como argumento para outra função que de fato vai executá-la. Esta execução pode ser imediata, ou seja, executada de maneira síncrona. No entanto, callbacks são normalmente utilizados para continuar a execução de um código em outro momento na linha do tempo, ou seja, de maneira assíncrona. Isso é bastante útil quando temos eventos demorados e não queremos travar o restante do programa.

Nosso código ainda tem problemas. A pessoa que faz a ligação quer apenas dizer alguma coisa após a outra pessoa atender a chamada. Podemos refatorar o código da seguinte maneira:

function fazChamada(){
    console.log("eu faço a chamada");
}

function pessoaAtende() {
    setTimeout(() => {
        console.log("a pessoa atende e diz alô")
    }, 3000);
}

function euDigoAlgo() {
    setTimeout(() => {
        console.log("eu digo alguma informação");
    }, 5000); // tempo de espera maior 
}

function ligacao() {
    fazChamada();
    pessoaAtende();
    euDigoAlgo();
}

ligacao();

Podemos definir um tempo de espera maior para dizer algo na chamada, mas ainda assim não sabemos ao certo o quanto a pessoa vai demorar para atender. Se ela atender imediatamente, vai demorar para receber a mensagem e desligar a chamada sem que isso aconteça. Além de ser bastante ruim e trabalhoso ficar configurando os tempos de cada execução, o código fica muito grande e confuso com muitas condicionais.

Promises

Para nossa sorte, o JavaScript possui um recurso chamado Promise que representa, como seu nome sugere, uma promessa de algo que será executado futuramente. Como a execução que esperamos pode falhar, este recurso também ajuda muito nos tratamentos de erros.

Segundo a Wikipédia, um Promise atua como representante de um resultado que é, inicialmente, desconhecido devido a sua computação não estar completa no momento de sua chamada. Vamos construir um objeto Promise para entender seu funcionamento:

const p = new Promise();
console.log(p);

Isso vai gerar um TypeError com a mensagem "TypeError: Promise resolver is not a function". Um objeto Promise precisa receber uma função para resolver um valor. Ou seja, precisamos passar uma função callback para executar algo:

const p = new Promise(() => console.log(5));

Este código imprime o valor 5. Agora vamos imprimir o próprio objeto Promise:

const p = new Promise(() => console.log(5));
console.log(p);

Saída:

5
Promise { <pending> }

Note que o callback foi executado, mas seu estado está pendente. Toda vez que criamos um objeto Promise, seu estado inicial é pendente já que representa a promessa de algo que será resolvido no futuro. Neste caso, como o callback será executado de maneira síncrona, vai imprimir o resultado de sua execução. E, portanto, não é útil neste caso específico.

Pode acontecer do callback executar o processamento de um valor que será necessário no futuro. Para que este valor esteja disponível, será preciso que a promessa seja resolvida através da função anônima resolve que cria uma nova promessa com o valor realizado. Exemplo:

const p = new Promise((resolve) => {
    resolve(5);
});
console.log(p);

Saída:

Promise { 5 }

Agora a promessa não está mais pendente, ela foi resolvida e embrulha o valor 5. Isso quer dizer que tudo deu certo. Porém, ainda é uma promessa. Para imprimir o valor, precisamos utilizar o método then que anexa callbacks para a resolução:

const p = new Promise((resolve) => {
    resolve(5);
});
p.then(value => console.log(value));

Saída:

Mas um erro pode acontecer quando a promessa tentar resolver um valor:

const p = new Promise((resolve) => {
    try {
        throw new Error("algo de errado ocorreu"); // um erro acontece
        resolve(5);
    } catch(err) {
        return err;
    }
});
console.log(p);
p.then(v => console.log(v))

Saída:

Promise { <pending> }

A promessa está pendente, mas nada foi executado ao chamarmos then(v => console.log(v)) porque um erro aconteceu antes que a promessa fosse resolvida. Para sabermos qual erro ocorreu, precisamos passar outro callback que será responsável por tratar falhas quando a promessa de um resultado for rejeitada, chamado reject.

const p = new Promise((resolve, reject) => {
    try {
        throw new Error("algo de errado ocorreu");
        resolve(5);
    } catch(err) {
        reject(err);  // chamada de reject
    }
});
console.log(p);

Saída:

Promise {
  <rejected> Error: algo de errado ocorreu
      at /home/caelum/Documents/estudos/js/exercicios/promise.js:58:15
      at new Promise (<anonymous>)
      at Object.<anonymous> (/home/caelum/Documents/estudos/js/exercicios/promise.js:56:11)
      at Module._compile (internal/modules/cjs/loader.js:1063:30)
      at Object.Module._extensions..js (internal/modules/cjs/loader.js:1092:10)
      at Module.load (internal/modules/cjs/loader.js:928:32)
      at Function.Module._load (internal/modules/cjs/loader.js:769:14)
      at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:72:12)
      at internal/main/run_main_module.js:17:47
}
(node:14346) UnhandledPromiseRejectionWarning: Error: algo de errado ocorreu
...

O estado da promessa agora será rejected. Além do estado da promessa, o Node.js mostra um warning com a seguinte mensagem: "UnhandledPromiseRejectionWarning: Error: algo de errado ocorreu". Ou seja, a promessa rejeitada não foi tratada. Após a chamada de then, que só será executado em caso de sucesso, podemos chamar o catch que será chamado em caso de erro:

const p = new Promise((resolve, reject) => {
    try {
        throw new Error("algo de errado ocorreu");
        resolve(5);
    } catch(err) {
        reject(err);
    }
});
p.then(v => console.log(v)).catch(err => console.log(err.message));
//console.log(p);

Saída:

algo de errado ocorreu

A mensagem de erro será impressa na execução do catch.

Promises são bastante úteis para chamadas assíncronas, quando precisamos saber sobre os estados de execuções futuras e tratar melhor as partes do código que dependem dessas execuções.

Agora, vamos voltar ao nosso exemplo. Podemos utilizar Promises para melhorar o código e fazer com que a pessoa que fez a chamada diga algo após a outra pessoa atender a chamada:

function fazChamada(){
    console.log("eu faço a chamada");
}

function pessoaAtende() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            let atendeu = Math.random() > 0.5; 
            if(atendeu) {
                resolve("alô");
            } else {
                reject(new Error("a pessoa não atendeu")); 
            }
        }, 3000);

    });
}

function pessoaDiz(msg) {
    console.log(`a pessoa atende e diz ${msg}`);
}

function euDigoAlgo() {
    console.log("eu digo alguma informação");
}

function ligacao() {
    fazChamada();
    pessoaAtende()
        .then((msg) => pessoaDiz(msg))
        .then(euDigoAlgo)
        .catch(err => console.log(err.message));
}

ligacao();

Para deixar o código mais realista, adicionamos a linha let atendeu = Math.random() > 0.5; para representar se a pessoa atendeu ou não. E tratamos o caso em que ela não atende como uma falha na ligação.

No caso da pessoa atender, teremos a saída:

eu faço a chamada
a pessoa atende e diz alô
eu digo alguma informação

Caso ela não atenda, a saída será:

eu faço a chamada
a pessoa não atendeu

Async/Await

Nosso código funciona e conseguimos representar uma chamada telefônica mais próxima da realidade. Porém, o código da função ligacao() possui uma chamada encadeada de várias promessas - e poderia ser muito mais complexo do que isso, como muitas chamadas encadeadas de then(). Dependendo da complexidade dessas chamadas, pode ser um código difícil de ler e entender. Um código síncrono é, na maioria dos casos, mais fácil de ler e entender.

Na especificação ES2017 foram introduzidas duas novas expressões - async e await - que deixam o trabalho com Promises mais confortável para o desenvolvedor. A expressão async é utilizada quando queremos criar funções assíncronas. Quando posicionada antes da declaração de uma função, quer dizer que essa função retorna um objeto do tipo Promise:

async function retornaUm() {
    return 1;
}
console.log(retornaUm());
retornaUm().then(console.log);

Que vai gerar a saída:

Promise { 1 }
1

Portanto, ao utilizar a expressão async em uma função, seu retorno é embrulhado em um objeto Promise. Agora que entendemos como funciona o async vamos ver como o await funciona.

O uso do await somente é permitido em escopo de um função async - deste modo, a palavra-chave async além de embrulhar seu retorno em uma promessa, permite o uso do await. A palavra-chave await faz com que o JavaScript espere até que uma promessa seja resolvida (ou rejeitada) e retorne seu resultado.

async function retornaUm() {
    return 1;
}

async function retornaDois() {
    var num = await retornaUm();
    return num + 1;
}

retornaDois().then(console.log)

Saída:

A função retornaDois espera a promessa retonraUm ser resolvida para seguir sua execução. Portanto, espera a promessa ser finalizada. O mesmo acontece quando o valor é rejeitado:

async function funcao() {
    await Promise.reject(new Error("um erro ocorreu"));
}

funcao().catch(err => console.log(err.message));

Saída:

um erro ocorreu

E é similar a:

async function funcao() {
    await new Error("um erro ocorreu");
}

funcao().catch(err => console.log(err.message));

Saída:

um erro ocorreu

Como o código posicionado após o await lança um erro, podemos fazer um tratamento com o bloco try/catch:

async function funcao() {
    try {
        await Promise.reject(new Error("um erro ocorreu"));
    } catch(err) {
        console.log(err.message);
    }
}

funcao();

Note que o código fica mais fácil de ler e raramente usamos as chamadas encadeadas de then e catch. Com a introdução de funções assíncronas com async/await, a escrita de um código assíncrono fica parecido com a escrita de um código síncrono.

Agora que aprendemos como funciona o async/await, podemos refatorar nosso código para utilizar este recurso:

function fazChamada(){
    console.log("eu faço a chamada");
}

function pessoaAtende() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const atendeu = Math.random() > 0.5;
            if(atendeu) {
                resolve("alô");
            } else {
                reject(new Error("a pessoa nao atendeu")); 
            }
        }, 3000);
    });
}

function pessoaDiz(msg) {
    console.log(`a pessoa atende e diz ${msg}`);
}

function euDigoAlgo() {
    console.log("eu digo alguma informação");
}

async function ligacao() {
    fazChamada();
    try {
        const msg = await pessoaAtende();
        pessoaDiz(msg);
        euDigoAlgo();
    }catch(err) {
        console.log(err.message);
    }
}

ligacao();