Arquivos ES11 - MundoJS

Embora as classes estejam disponíveis para o JavaScript desde o ES2015, elas não incluem campos e métodos privados. Esses recursos foram descartados durante o release inicial devido a divergências no comitê do TC39. Três rascunhos de especificações pretendem levar esses recursos às classes JavaScript em um futuro próximo.

Depois que essas especificações forem formalmente aceitas, os campos e métodos privados poderão ser definidos usando o sinal de hash ‘#’. A decisão de usar o sinal de hash em vez do sublinhado mais tradicional ‘_’ foi tomada para evitar alterações nas bibliotecas existentes, que atualmente marcam os campos privados dessa maneira.

Isso pode parecer contra intuitivo, no entanto, apesar das bibliotecas marcarem campos ou métodos como privados usando o sublinhado, os desenvolvedores de sinal ainda os usam. Transformar essas variáveis em variáveis verdadeiramente privadas pode interromper vários aplicativos e, portanto, retardar a adaptação das novas especificações.

O problema pode ser demonstrado por uma anedota do React, que teve que recorrer a alguns nomes de variáveis bastante contundentes para impedir que os desenvolvedores os usassem (apesar de serem marcados como privados), como ‘_SECRET_DOM_DO_NOT_USE_ORYOU_WILL_BE_FIRED’. (Lê-se _DOM_SECRETO_NAO_USE_OU_VOCE_SERA_DEMITIDO ).

Cada uma das 3 propostas do TC39 aborda um aspecto diferente de campos e métodos privados nas classes. No entanto, deve ser seguro tratá-los como uma única proposta, pois provavelmente serão adicionados ao JavaScript ao mesmo tempo. As propostas são:

Declaração de campos da classe

Atualmente não é possível definir campos (variáveis) direto na classe. Ao invés disso, os desenvolvedores precisam fazê-lo diretamente no construtor da classe.

class Counter { 
  constructor() { 
    this.xValue = 0; 
  } 
}

A proposta pretende adicionar esta habilidade para escrever os campos diretamente na definição da classe.

class Counter { 
  xValue = 0;
  #yValue = 0;
  constructor() { }
}

Criação de métodos privados e de getter e setters privados para as classes.

Esta proposta pretende permitir a adição de métodos privados e o uso de getter e setter privados.

class Counter { 
  get #x() { return #xValue; } 
  set #x(value) { }

  #clicked() { } 
}

Funcionalidades de classes estáticas (static).

Esta proposta define como será implementado a funcionalidade de campos e métodos estáticos, podendo ser públicos ou privados.

class CustomDate { 
  static public() = {} 
  static #private() = {} 
}

Para mais informações veja o post original no link abaixo:

Fonte: https://www.infoq.com/news/2019/10/javascript-private-class-fields/

BigInt é um objeto nativo do JavaScript que fornece um modelo de representação de números inteiros maiores que , que é o maior número que o JavaScript consegue representar, com exatidão, utilizando o tipo primitivo Number.

Sintaxe:

A sintaxe do BigInt é:

BigInt(valor);

Onde:

valor: é o valor numérico do objeto que irá ser criado. Este pode ser uma string ou um número inteiro.

É importante salientar que o BigInt() não é usado com o operador new.

O BigInt é criado com a simples acrescentação de um “n” ao final de um inteiro literal – 10n – ou chamando a função BigInt();

const theBiggestInt = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// 9007199254740991n

const hugeString = BigInt("9007199254740991");
// 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// 9007199254740991n

const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111");
// 9007199254740991n

O BigInt difere-se do Number em alguns assuntos importantes. Por exemplo:

Ele não pode ser usado com métodos no objeto Math;
Ele não pode ser misturado em operações ou qualquer instância de Number. Eles devem ser manipulados com o mesmo tipo.
A precisão de BigInt pode ser perdida com a conversão de valores para Number.

Se você quiser realizar alguns testes, você pode:

Testando com typeof:

typeof 1n === 'bigint'; // true

typeof BigInt('1') === 'bigint'; // true

Se estiver envolvido em um Object, o BigInt será considerado como um tipo normal de “object”:

typeof Object(1n) === 'object'; // true

Você também pode realizar operações com BigInt ou com BigInt envolvido em objeto:

const antigoMaximoInt = BigInt(Number.MAX_SAFE_INTEGER);
// 9007199254740991

const maximoMaisUm = antigoMaximoInt + 1n;
// 9007199254740992n

const oFuturo= antigoMaximoInt + 2n;
// 9007199254740993n, isso funciona agora!

const multiplicando = antigoMaximoInt * 2n;
// 18014398509481982n

const subtraindo = multiplicando – 10n;
// 18014398509481972n

const modulo = multiplicando % 10n;
// 2n

const bigN = 2n ** 54n;
// 18014398509481984n

bigN * -1n
// –18014398509481984n

Observação:

O operador / também funciona. No entanto, se os números forem BigIntS e não BigDecimalS, a operação será arredondada para zero, o que não nos trará nenhum valor fracional.

const divisao = 4n / 2n;
// 2n

const arredondado = 5n / 2n;
// 2n, e não 2.5n

É importante salientar que o BigInt não é estritamente igual a um Number, mas eles podem ser comparados normalmente.

0n === 0;
// false

0n == 0;
// true

1n < 2;
// true

2n > 1;
// true

2 > 2;
// false

2n > 2;
// false

2n >= 2;
// true

O BigInt se comporta como um número quando é convertido em um booleano, e também pode ser usado com operadores lógicos , também dentro de uma estrutura condicional.

if (0n) {
    console.log("Olá, você está dentro do IF");
} else {
    console.log("Olá, você está dentro do ELSE");
}

0n || 12n;
// 12n

0n && 12n;
// 0n

Boolean(0n);
//  false

!0n;
// true

Propriedades:

BigInt.prototype;

Permite a adição de propriedades a um objeto BigInt. Todas as instâncias BigInt são herdadas do BigInt.prototype. O objeto de protótipo do construtor BigInt pode ser modificado para afetar todas as instâncias do BigInt.

Gostou deste artigo? Deixe seu comentário abaixo!

Tag: ES11

JavaScript: Campos privados, classes estáticas e mais

Conheça o BigInt, a nova implementação do ECMAScript 2020

Sintaxe:

Onde:

Observação:

Propriedades: