Tính năng mới trong ES7 (ECMAScript 2016)

ES7 được giới thiệu vào năm 2017 với nhiều tính năng mới được thêm vào. Đây không phải là điều khó hiểu bởi Javascript thực sự là ngôn ngữ rất mạnh, nói chính xác hơn là ngôn ngữ tương lai.

ES7 có những nâng cấp ít hơn so với phiên bản tiền nhiệm của nó là ES6. Vì vậy mình sẽ viết một bài đơn giản và ngắn gọn để nói về những tính năng mới của ES7.

1. Toán tử lũy thừa **

ES7 giới thiệu một toán tử toán học mới được gọi là toán tử lũy thừa. Toán tử này tương tự như sử dụng phương thức Math.pow (). Toán tử lũy thừa được biểu diễn bằng dấu hoa thị kép **. Toán tử chỉ có thể được sử dụng với các giá trị số. Cú pháp để sử dụng toán tử lũy thừa như sau:

base_value ** exponent_value

Ví dụ với 2 lũy thừa ba thì ta sẽ viết như sau:

Bài viết này được đăng tại [free tuts .net]

2**3

Nếu khai báo bằng biến và biểu diễn ở hai cách thì bạn hãy xem ví dụ sau:

let base = 2
let exponent = 3
console.log('Sử dụng Math.pow()',Math.pow(base,exponent))
console.log('Sử dụng toán tử **',base**exponent)

2. Array.includes

Phương thức Array.includes() được giới thiệu trong ES7 nhằm giúp kiểm tra một phần tử có sẵn trong mảng hay không, tương tự như hàm in_array trong PHP.

Trước đây khi kiểm tra một phần tử có xuất hiện trong mảng hay không thì ta phải sử dụng vòng lặp for, lần lượt lặp qua từng phần tử mảng cho đến khi tìm thấy. Nếu duyệt đến cuối mảng vẫn xuất hiện thì phần tử không nằm trong mảng.

Đương nhiên bạn có thể tạo ra một hàm đẻ sử dụng được nhiều lần. Nhưng với ES7 thì bạn không cần phải lo lắng nữa vì đã có phương thức Array.includes.

Lưu ý là phương thức này chỉ dùng cho Object Array thôi nhé, vì vậy nó có một tham số truyền vào, đó cũng chính là giá trị mà ta muốn tìm.

Array.includes(value)

Trường hợp bạn muốn kiểm tra giá trị cần tìm có nằm trong một dãy bắt đầu từ phần tử nào đó thì sử dụng cú pháp 2 tham số như sau:

Array.includes(value,start_index)

Trong đó start_index chính là vị trí bắt đầu, tức là nó sẽ duyệt từ vị trí này đến cuối mảng.

Ví dụ: Kiểm tra xem 50 có nằm trong mảng không

let marks = [50,60,70,80];
//Kiểm tra 50 có nằm trong mảng hay không?
if(marks.includes(50)){
    console.log('Tìm thấy trong mảng');
}else{
    console.log('Không tìm thấy trong mảng');
}

3. Object Rest / Spread

Trong ES6 đã giới thiệu về array rest và spread giúp việc kết hợp và tách mảng trở nên rất dễ dàng. Nhận thấy đây là một tính năng thú vị nên ES7 cũng đã bổ sung nó vào trong Object.

Bạn có thể tách hoặc kết hợp một Object rất dễ dàng. Xem ví dụ dưới đây để hiểu rõ hơn.

var {a, b, c} = {a: 1, b: 2, c: 3};

console.log(a); // 1
console.log(b); // 2
console.log(c); // 3

Trường hợp bạn muốn tách đối tượng ra với số lượng nhỏ hơn, điều này đồng nghĩa với biến cuối cùng sẽ lưu một object chứa các phần tử còn lại.

var {a, b, c, ...x} = {a: 1, b: 2, c: 3, x: 4, y: 5, z: 6};

console.log(a); // 1
console.log(b); // 2
console.log(c); // 3

console.log(x); // { x: 4, y: 5, z: 6 }

Tách ra thì quá dễ dàng rồi, bây giờ bạn muốn gom lại thì sao? Ta chỉ cần khai báo một biến mới và gán danh sách các object một cách bình thường.

var a = 1, b = 2, c = 3;
var x = {x: 4, y: 5, z: 6};

var obj = {a, b, c, ...x};

console.log(obj); //{a: 1, b: 2, c: 3, x: 4, y: 5, z: 6};

4. Async Functions

Đây được xem là một trong những bản nâng cấp đáng giá nhất của ES7. Nếu trước đây để xử lý bất đồng bộ trong ES5 thì ta sử dụng callback function, và trong ES6 thì ta sử dụng promise. Nhưng bây giờ ES7 đã có async và await.

Hãy xem một ví dụ dưới đây mà mình lấy từ trang viblo.asia, tác giả là bạn Đào Tùng.

Callback function trong ES5

 myFirstOperation(function(error, firstResult) {
    mySecondOperation(firstResult, function(error, secondResult) {
        myThirdOperation(secondResult, function(error, thirdResult) {
            \* viết code xử lý với kết quả nhận được ở  hoạt động thứ 3 *\
        });
    });
});

Trường hợp bạn muốn xử lý 100 cấp thì đoạn code sẽ quá dài phải không các bạn? Điều này sẽ đẫn đến lỗi callback hell. Và ES7 đã giới thiệu Promise.

  myFirstPromise()
        .then(firstResult => mySecondPromise(firstResult)
        .then(secondResult => myThirdPromise(secondResult)
        .then(thirdResult => {
            \* viết code xử lý với kết quả nhận được ở  hoạt động thứ 3 *\
        },
        error => {
            \* xử lý lỗi *\
        }

Nhìn có vẻ đơn giản và dễ hiểu hơn rất nhiều, loại bỏ được vấn đề phân cấp quá dài và gây ra lỗi callback hell. Vây thì trong ES7 cải tiến thế nào?

async function myOperations() {
    const firstResult = await myFirstOperation();
    const secondResult = await mySecondOperation(firstResult);
    const thirdResult = await myThirdResult(secondResult);
   \* viết code xử lý với kết quả nhận được ở  hoạt động thứ 3 *\
}

try {
    myOperations();
} catch(e) {
     \* xử lý lỗi *\
}

Thứ tự chạy từ trên xuống dưới nên rất rõ ràng và tường minh. Đây chính là phần nâng cấp rất hay mà mình thấy khắc phục được những nhược điểm của ES5 và ES6 khi xử lý bất đồng bộ.

5. Observables

Khi bạn gắn một sự kiện click vào button và bạn thử click 2 hay nhiều lần thì sự kiện đó kích hoạt tương đương với số lần mà bạn click. Điều này đã khiến các nhà phát triển phải đối mặt với vấn đề quản lý sự kiện trong một đối tượng DOM.

Trước đây để giải quyết vấn đề này thì ta sử dụng một biến flag dùng để lưu trữ trạng thái của đối tượng. Ban đầu sẽ gắn trạng thái cho nó là false (chưa click), sau khi click thì flag có giá trị true (đã click), dựa vào trạng thái này ta sẽ kiểm soát được số lần click.

Vấn đề này đã được giải quyết trong ES7 bằng cách sử dụng đối tượng Observable.

Giả sử mình tạo sự kiện reszie để lắng nghe người dùng khi họ thay đổi kích thước của trình duyệt.

var resize = new Observable((o) => {

  // listen for window resize and pass height and width
  window.addEventListener("resize", () => {
    var height = window.innerHeight;
    var width = window.innerWidth;
    o.next({height, width});
  });

});

Hoặc sự kiện change:

var change = new Observable((o) => {

  // listen for a data model's change event
  // and pass along the key and value that changed
  myModel.on("change", (key, value) => {
    o.next({ key, value });
  });

});

Trên là một số chia sẻ về những tính năng mới của ES7. Vì mình viết một cách khái quát nên vẫn còn sơ sài, bạn có thể truy cập vào đây để xem kỹ hơn nhé.