Skip to main content

Artigos

  • Artigos

Private x​


    // A versão 3.8 adicionou os campos privados, que é uma maneira de declarar
    // que um campo de uma classe é inacessível fora daquela classe, incluindo subclasses.

    // Por exemplo, a classe Pessoa abaixo não permite que ninguém usando uma
    // instância da classe leia o primeiroNome, sobrenome, e o prefixo.

    class Pessoa {
    #primeiroNome: string;
    #sobrenome: string;
    #prefixo: string;
    
    constructor(primeiroNome: string, sobrenome: string, prefixo: string) {
        this.#primeiroNome = primeiroNome;
        this.#sobrenome = sobrenome;
        this.#prefixo = prefixo;
    }

    cumprimentar() {
        // Na Islândia é preferível que usemos o nome completo ao invés de [prefixo] [sobrenome]
        // https://www.w3.org/International/questions/qa-personal-names#patronymic
        if(navigator.languages[0] === "is") {
        console.log(`Góðan dag, ${this.#primeiroNome} ${this.#sobrenome}`);
        } else {
        console.log(`Olá, ${this.#prefixo} ${this.#sobrenome}`);
        }
    }
    }

    let jeremias = new Pessoa("Jeremias", "Beremias", "Sr.");
        
    // Você não pode acessar nenhum dos campos dessa classe de fora dela:

    // Por exemplo, isso não funciona:
    console.log(jeremias.#primeiroNome);

    // Nem isso:
    console.log("Sobrenome de Pessoas:", jeremias["#sobrenome"]);

    // Uma pergunta comum que fazemos é "Porque você usaria isso no lugar da
    // palavra-chave 'private' dentro de uma classe?" - vamos fazer uma 
    // comparação sobre para ver como isso funciona após a 3.8:

    class Cachorro {
    private _nome: string;
    constructor(nome: string) {
        this._nome = nome;
    }
    }

    let rex = new Cachorro("Rex");
    // Não permite que você acesse através da notação de ponto
    rex._nome = "Caramelo";
    // Mas permite que seja acessado através da notação de colchetes.
    rex["_nome"] = "Bidu";

    // A referência de private no TypeScript só existe no nível de tipos, o que
    // significa que você só pode confiar nisso. Agora com os campos
    // privados fazendo parte da linguagem JavaScript, você pode então
    // garantir de uma forma melhor a visibilidade no seu código.

    // Nós não planejamos descontinuar a palavra-chave `private` 
    // no TypeScript, então os seus códigos ja existentes vão continuar
    // a funcionar, mas agora você pode escrever código de uma forma mais
    // proxima da linguagem JavaScript.

    // Você pode aprender mais sobre campos de classes na proposta da tc39
    // https://github.com/tc39/proposal-class-fields/
    // e nas notas de lançamentos beta:
    // https://devblogs.microsoft.com/typescript/announcing-typescript-3-8-beta/#ecmascript-private-fields

Require x Import​

No TypeScript, require e import são duas formas distintas de incluir módulos e bibliotecas em seu código, e sim, estão relacionadas às diferentes versões do ECMAScript (ES), o padrão de linguagem para JavaScript.

require​

  • Origem: Originou-se no ambiente Node.js e é utilizado principalmente com CommonJS, um sistema de módulos padrão para JavaScript antes da adoção do ES6.
  • Sintaxe: Utiliza-se require() para carregar módulos. Por exemplo: const express = require('express');.
  • Características: Com o require, os módulos são carregados dinamicamente e sincronicamente. É muito comum em projetos mais antigos ou em partes do Node.js que ainda não suportam completamente o ES6+.

import​

  • Origem: Introduzido no ECMAScript 2015 (ES6) como parte da especificação da linguagem para suportar módulos ES nativos.
  • Sintaxe: Utiliza-se import para incluir módulos. Por exemplo: import express from 'express';.
  • Características: O import permite importações estáticas e dinâmicas (através de import() para importações assíncronas). Ele suporta a extração de partes específicas de um módulo (destructuring), o que pode ajudar a reduzir o tamanho do código final ao evitar a importação de todo o módulo quando apenas partes dele são necessárias.

Relação com as versões do ECMAScript​

  • A diferença entre require e import está fortemente atrelada às versões do ECMAScript. O require é mais alinhado com o CommonJS, que não faz parte de nenhuma especificação ECMAScript, enquanto o import é parte do ES6 e de versões posteriores.
  • Com o avanço do JavaScript e o aumento do suporte a ES6+, o uso de import tem se tornado mais prevalente, especialmente em novos projetos ou em projetos que estão sendo atualizados para usar módulos nativos do ES.
CommonJS

CommonJS é uma especificação de módulos utilizada principalmente em ambientes JavaScript do lado do servidor, como Node.js. Foi desenvolvida para padronizar a maneira como os códigos JavaScript são escritos e organizados em módulos, permitindo uma melhor modularidade, reutilização e encapsulamento de código em projetos JavaScript.

Principais características do CommonJS:​

  1. Modularização: O CommonJS define uma estrutura para dividir o código JavaScript em módulos separados, que podem ser carregados e utilizados conforme necessário. Isso é crucial para construir aplicações grandes e complexas, onde a manutenção e a organização do código são fundamentais.

  2. Sincronização: No CommonJS, os módulos são carregados sincronicamente. Isso significa que o código espera que um módulo seja totalmente carregado e disponível antes de continuar a execução. Essa característica é especialmente útil no lado do servidor, onde a latência de leitura de arquivos locais é geralmente baixa e a execução sincronizada simplifica o fluxo de controle do código.

  3. Utilização do require: A função require() é usada para importar módulos. Quando um módulo é requerido, o CommonJS procura o arquivo especificado, executa o código dentro dele e geralmente retorna um objeto, função ou qualquer outra entidade definida para exportação. Por exemplo:

    const fs = require('fs');  // Importando o módulo de sistema de arquivos do Node.js

  4. Exportação de módulos: Os módulos podem exportar funcionalidades específicas usando module.exports ou apenas exports. Isso permite que partes específicas do módulo sejam disponibilizadas para outros módulos que as importam. Por exemplo:

    function soma(a, b) {
        return a + b;
    }

    module.exports = soma;  // Tornando a função soma disponível para outros módulos

Utilização e Contexto​

  • Node.js: CommonJS é amplamente utilizado em Node.js para estruturar aplicações devido à sua simplicidade e eficácia na gestão de dependências do lado do servidor.

  • Navegadores: CommonJS não é nativamente suportado nos navegadores. Para usar módulos CommonJS no navegador, ferramentas como Browserify ou Webpack são necessárias para transformar os módulos CommonJS em um formato que possa ser executado em um ambiente de navegador.

Evolução e Alternativas​

Com a introdução do ECMAScript 6 (ES6), que inclui seu próprio sistema de módulos (usando import e export), o CommonJS começou a ser menos utilizado em alguns contextos, especialmente em aplicações que são executadas tanto no servidor quanto no navegador. O sistema de módulos ES6 oferece funcionalidades semelhantes de modularização, mas com o benefício adicional de ser suportado nativamente pelos navegadores modernos e permitir a carga assíncrona de módulos.

CommonJS ainda é relevante e amplamente usado, especialmente em projetos Node.js, devido à sua robustez e a vasta quantidade de módulos existentes que foram escritos usando essa especificação.