Статьи

Web 2.0, встретить JavaScript 2.0

Декабрь 24, 2017

Ну, я полагаю, это неоспоримый факт о нас, типах программистов — время от времени мы просто не можем не волноваться о чем-то действительно занудном. Для меня сейчас это определенно JavaScript 2.0. Я просто смотрел на предлагаемые спецификации, и я действительно очень рад тому, что у нас впереди.

Я полагаю, важно отметить, что эти новые функции являются предварительными. Техническая документация для JavaScript 2.0, ECMAScript Edition 4, в настоящее время разрабатывается TC39 . Хотя это все еще в стадии разработки, обзор того, что было предложено в настоящее время, можно найти здесь (PDF). Ожидается, что команда завершит разработку спецификаций к концу осени этого года, и мы можем ожидать, что большинство из этих потрясающих улучшений останутся в финальной версии.

Итак, без дальнейших задержек, вот лишь некоторые из множества обновлений, появившихся в JavaScript 2.0:

OOP!

Пришлось начинать с этого — он такой большой, что должен был быть первым. Введение реальных языков и интерфейсов в язык, вероятно, является наиболее радикальным изменением, которое придет с JavaScript 2.0. Технически говоря, ООП не будет ничего нового для JavaScript. JavaScript уже имеет объекты и даже предлагает полную поддержку наследования через цепочку прототипов — однако наследование прототипов в JavaScript является сложным делом и часто может привести к неожиданным результатам (особенно для тех, кто привык к классическому наследованию в таких языках, как Java и C #).

JavaScript не только вводит классы в язык, но и полностью устраняет примитивы. Null и undefined будут единственными не истинными объектами в JavaScript 2.0. Должным образом, такие классы, как boolean и string, будут обеспечивать классы-оболочки для обратной совместимости.

Что касается создания и создания базового «класса», процесс будет очень похож на использование функции конструктора, как в более ранних версиях JavaScript. Рассмотрим следующие примеры:

/* JavaScript 1.x "Class" Definition*/
function Foo() {
	this.a = "a";
	this.b = "b";
}
var myFoo = new Foo(); // class instantiation

/* JavaScript 2.0 Class Definition */
class Bar {
	this.a = "a";
	this.b = "b";
}
var myBar = new Bar(); // class instantiation

Один только этот hardy, кажется, стоит пересмотра, но классы обеспечат гораздо большую гибкость благодаря множеству его указателей и директив (конечных, динамических, расширяемых, реализуемых и т. Д.). Также обратите внимание, что функции конструктора могут быть изменены, тогда как классы будут связаны как константы и, следовательно, не могут быть изменены.

Объектно-ориентированное программирование сделало для программирования то, что реляционные базы данных сделали с постоянством — оно доминировало. Я не могу вспомнить ни одной вещи, которую я бы предпочел увидеть в JavaScript 2.0, чем именно это.

Проверка типа времени компиляции

Компоненты JavaScript 2.0 могут запрашивать компиляцию в строгом режиме. Это проверит целостность нескольких ключевых аспектов перед выполнением. Частичный список этих проверок включает в себя:

  • Проверка статического типа
  • Проверка того, что упоминаемые имена известны
  • Проверяет незаконные присвоения констант
  • Гарантирует, что сравнения сделаны только между допустимыми типами

 

Я говорил константы?

Я уверен, что сделал. Для такой очевидной директивы константы уже давно придут. Ранее разработчикам JavaScript приходилось использовать соглашения об именах для защиты своих констант, но в JavaScript 2.0 это уже не так.

/* JavaScript 1.x constant */
var FOO = 'bar';  // look, I'm all upper cases, so pretty please don't change me

/* JavaScript 2.0 constant */
const FOO = 'bar'; // go ahead, try me...

Однако для реализации некоторых побочных эффектов этого изменения может потребоваться некоторое время, поскольку директива константы теперь будет применяться к некоторым существующим базовым объектам JavaScript (таким как указатель на прототип объекта).

Перегрузка оператора

Потому что я, что бы ты ни говорил, если бы я не был, то почему бы мне … не обращать внимания. Неправильно, злоупотребляйте этим, делайте с ним все, что хотите. Операторы теперь все, что вы хотите.

Оператор Not Null («!»)

Обнуляемость — это концепция, знакомая всем, кто работал с базами данных, аннотациями гибернации в Java или множеством других технологий. Короче говоря, он позволяет вам указать, может ли объект быть нулевым или нет. Рассмотрим следующий пример:

class Person! {
 ...
}
var x = new Person();

var x = null; // throws error

I’ll be honest and admit that I wasn’t sure if the error gets thrown on assignment, or when you attempt to read. For now, examples in the documentation are sparse, but either way this will be a handy feature. The mechanism that makes this new operator possible is union types (also new). I won’t be delving into those in this article, but they would definitely be worth reading up on at the original source.

Real Namespaces

JavaScript developers have long been implementing namespaces by stuffing everything into a single global object. While this is not a bad convention (and it’s much better than cluttering the global namespace), the reality is that it abuses the purpose of objects for the sake of simulating pseudo-namespaces. Well, have a guilty conscience no more, because now you have real bonafide namespaces that are actually made for being, well, namespaces.

Program Units

This is a simple addition, but to me it yields great benefits. Program units allow you to bundle up «program fragments» that don’t need to be loaded until requested. This ability has all sorts of potential, not excluding bandwidth optimization.

Perhaps more significant, though, this is also a big step towards providing structured, reusable code libraries. Since the units that you reference will be loaded at most once, you now have a mechanism for maintaining elegant code libraries. Consider the following example:

use unit Person "http://mysite/library/classes/Person";
use unit DisplayUtil "http://mysite/library/utils/DisplayUtil";

var bob = new Person();
document.writeln(DisplayUtil.display(bob));

Even in this short, fanciful example you can see how your code can start to take on a highly organized and logical structure — much like many of the server side languages you may have worked with. Personally, I think this is one of the strongest improvements found in the specifications.

Conclusion

Well, needless to say, JavaScript 2.0 is shaping up to be a devastatingly awesome improvement. The specifications go on for about 40 pages of size 12 font, so I’m not even going to try and provide a complete overview. But as I’ve said, everything I’ve mentioned above can be found in the proposed language overview (PDF) — and there’s several more goodies to be found in there as well. Thanks for reading!

28
Share: