Generator Function Là Gì | Triển Khai Iterator

Cách tạo Generator trong Python đơn giản

Sau khi hiểu được Generator là gì thì chắc hẳn bạn đang thắc mắc về cách tạo Generator trong Python đúng không? Câu trả lời dưới đây sẽ giải đáp cho bạn. Để tạo được Generator trong Python thì bạn dùng từ khó def tương tự với định nghĩa một hàm. Trong Generator, sử dụng câu lệnh yield để trả về một phần tử thay cho câu lệnh return như bình thường khác. Nếu các hàm có chứa ít nhất một yield thì chắc chắn đây đã là một hàm Generator. Với trường hợp này thì cả yield và return sẽ được trả về các giá trị từ ham. Chỉ có điều khác biệt là return sẽ chấm dứt hoàn toàn một hàm còn yield sẽ chỉ tạm dừng lại các trạng thái bên trong hàm rồi sau đó vẫn có thể tiếp tục được ngay khi gọi lần sau. Ví dụ dễ hiểu như sau: khi bạn gọi phương thức _next_() lần thứ nhất thì ngay sau đó Generator sẽ thực hiện các công trình tính toán giá trị rồi gặp các từ khóa yield nào nó sẽ trả ngay các phần từ trở lại vị trí đó. Ngay khi bạn gọi phương thức _next_() lần thứ 2 thì Generator sẽ không bắt đầu chạy tại vị trí đầu tiên mà ngay phía sau từ khóa yield thứ nhất. Cứ như vậy, thì Generator sẽ tạo ra được các phần tử trong dãy cho đến khi không thể gặp được từ khóa yield nào nữa thì sẽ thực hiện giải phóng Stoplteration.

Cách tạo Generator trong Python khá đơn giản

Triển khai iterator

Khi muốn triển khai một iterator, chúng ta phải tạo thủ công method

next()

. Vì generator là iterable, nên chúng có thể giúp chúng ta đơn giản hóa việc triển khai iterator.

Mình xin sử dụng ví dụ từ bài viết Iterators và Iterables trong JavaScript:


const obj = { blog: "homiedev.com", categories: ["ReactJS", "JavaScript", "TypeScript"], isFrontEndBlog: true, }; obj[Symbol.iterator] = function () { let i = 0; let values = Object.values(this); return { next: () => { return { value: values[i++], done: i > values.length, }; }, }; };


Bây giờ, chúng ta có thể sử dụng generator để triển khai iterator như sau:


const obj = { blog: "homiedev.com", categories: ["ReactJS", "JavaScript", "TypeScript"], isFrontEndBlog: true, *[Symbol.iterator]() { const values = Object.values(this); for (let index = 0; index < values.length; index++) { const element = values[index]; yield element; } }, }; for (const element of obj) { console.log(element); }


Như các bạn có thể thấy, method

Symbol.iterator

nhìn đơn giản hơn khi chúng ta sử dụng generator.

Kết quả sẽ như sau:


homiedev.com ['ReactJS', 'JavaScript', 'TypeScript'] true


Bằng cách sử dụng generator chúng ta có thể tạo một chức năng quản lý dữ liệu như thêm phần tử vào danh sách, lặp qua những phần tử đã thêm vào danh sách, ví dụ:


class List { constructor() { this.elements = []; } count() { return this.elements.length; } isEmpty() { return this.elements.length === 0; } add(element) { this.elements.push(element); } *[Symbol.iterator]() { for (let element of this.elements) { yield element; } } } let list = new List(); list.add("Homiedev"); list.add("Front-End"); list.add("JavaScript"); for (let item of list) { console.log(item); }


Kết quả:


Homiedev Front-End JavaScript


Như vậy là chúng ta đã tìm hiểu qua generator trong JavaScript. Hi vọng bài viết giúp ích cho các bạn. Chúng ta sẽ gặp lại nhau trong các bài viết sắp tới nhé 😁.

Generators có thể xem như là cách áp dụng của iterables

Điều khiến generators trở nên đặc biệt bởi vì chúng là những functions có khả năng hoãn lại quá trình execution mà vẫn giữ nguyên được context.

Đây là một tính năng rất quan trọng khi ta phải dùng tới những executions đòi hỏi phải có quãng pause nhưng context phải được để nguyên nhằm để recover lại trong tương lai khi cần đến.

Bạn có từng nghe qua quá trình phát triển async chưa?

Syntax – Cú pháp

Syntax (Cú pháp) cho generators bắt đầu với

function*

declaration của chính nó (nhớ lưu ý cái asterisk) và

yield

dành cho khi generator muốn dừng (pause) execution.

function* generator() { // A yield ‘foo’ // B }

Với

next

function, chúng ta có thể kiểm soát được quá trình tạo ra một generator từ

generator

sẵn có.

Khi chạy

next

function, thì code của

generator

sẽ được thực hiện (execute) và cho đến khi gặp

yield

thì sẽ ngừng lại.

Lúc đó,

yield

sẽ xen vào và khiến cho

generator

execution bị đình chỉ (pause).

const g = generator() g.next() // { value: ‘foo’, done: false } // Our generator’s code A gets executed // and our value ‘foo’ gets emitted through yield. // After this, our generator’s execution gets suspended. g.next() // { value: undefined, done: true } // At this stage the remaining code (i.e. B) gets executed. // Because no value is emitted we get ‘undefined’ as the value, // and the iterator returns ‘true’ for iteration done.


yield

được sinh ra cùng lúc với generator và cho phép chúng ta đưa ra các giá trị mà mình muốn. Tuy nhiên, nó chỉ thực hiện được khi ở trong phạm vi của generator.

Nếu thử dùng

yield

với một giá trị trong callback thì cho dù đã declared trong generator thì nó vẫn sẽ bị lỗi.

function* generator() { [‘foo’,’bar’].forEach(e => yield e) // SyntaxError // We can’t use ‘yield’ inside a non-generator function. }

yield*


yield*

được tạo ra nhằm có khả năng gọi một generator nằm trong một generator khác.

function* foo() { yield ‘foo’ } // How would we call ‘foo’ generator inside the ‘bar’ generator? function* bar() { yield ‘bar’ foo() yield ‘bar again’ } const b = bar(); b.next() // { value: ‘bar’, done: false } b.next() // { value: ‘bar again’, done: false } b.next() // { value: undefined, done: true }

Bạn có thể thấy iterator, thuộc

bar

generator, không hề chạy như đúng ý ta khi call

foo

.

Đó là mặc dù

foo

execution cho ra một iterator, nhưng ta sẽ không có lặp lại (iterate) nó được.

Vì thế mà ES6 cần có operator

yield*


function* bar() { yield ‘bar’ yield* foo() yield ‘bar again’ } const b = bar(); b.next() // { value: ‘bar’, done: false } b.next() // { value: ‘foo’, done: false } b.next() // { value: ‘bar again’, done: false } b.next() // { value: undefined, done: true }

Đồng thời nó cũng hoàn toàn có thể áp dụng với data consumers

for (let e of bar()) { console.log(e) // bar // foo // bar again } console.log([…bar()]) // [ ‘bar’, ‘foo’, ‘bar again’ ]


yield*

có khả năng kiểm tra và chạy qua hết tất cả ngõ ngách trong generator để

yield

ra phần nó cần.

function* bar() { yield ‘bar’ for (let e of foo()) { yield e } yield ‘bar again’ }

Generators cũng chính là Iterators

Generators thực chất là những iterables đơn giản. Nói cách khác chúng cũng sẽ theo luật của

iterable

và

iterator

.

Luật của

iterable

cho ta biết một object sẽ nên return một function itera với key là

Symbol.iterator

.

const g = generator() typeof g[Symbol.iterator] // function

Còn luật của

iterator

cho ta biết iterator nên là một object chỉ tới yếu tố tiếp theo của iteration. Object này phải chứa một function gọi là

next


const iterator = g[Symbol.iterator]() typeof iterator.next // function

Bởi vì generators là iterables nên chúng ta có thể dùng data consumer

for-of

, để iterate (lặp lại) giá trị của generators (values).

for (let e of iterator) { console.log(e) // ‘foo’ }

Return

Chúng ta còn có thể add vào

return

cho generator, thế nhưng

return

sẽ hoạt động hơi khác đi tùy thuộc vào cách generators’ data được iterated.

function* generatorWithReturn() { yield ‘foo’ yield ‘bar’ return ‘done’ } var g = generatorWithReturn() g.next() // { value: ‘foo’, done: false } g.next() // { value: ‘bar’, done: false } g.next() // { value: ‘done’, done: true } g.next() // { value: undefined, done: true }

Khi ta thực hiện iteration bằng tay, sử dụng

next

, sẽ nhận được returned value (i.e.

done

) cũng chính là

value

cuối của iterator object và khi

done

đưa ra kết quả true.

Mặt khác, khi sử dụng defined data consume như

for-of

hoặc

destructuring

thì returned value sẽ bị bỏ qua.

for (let e of g) { console.log(e) // ‘foo’ // ‘bar’ } console.log([…g]) // [ ‘foo’, ‘bar’ ]

yield*

Như bạn đã biết

yield*

được tạo ra nhằm có khả năng gọi một generator nằm trong một generator khác.

Ngoài ra, nó còn cho phép chúng ta lưu trữ value returned bằng executed generator.

function* foo() { yield ‘foo’ return ‘foo done’ } function* bar() { yield ‘bar’ const result = yield* foo() yield result } for (let e of bar()) { console.log(e) // bar // foo // foo done }

Throw

Chúng ta có thể dùng

throw

trong một generator và

next

sẽ truyền exception ra.

Và khi một exception bị đẩy ra, iterator (lặp) sẽ bị phá và state của nó sẽ được set thành

done: true


function* generatorWithThrow() { yield ‘foo’ throw new Error(‘Ups!’) yield ‘bar’ } var g = generatorWithReturn() g.next() // { value: ‘foo’, done: false } g.next() // Error: Ups! g.next() // { value: undefined, done: true }

Generators cũng chính là Data Consumers

Generators ngoài khả năng như một data producers, với

yield

, nó cũng có thể consume data khi dùng

next

.

function* generatorDataConsumer() { // A console.log(‘Ready to consume!’) while (true) { const input = yield; // B console.log(`Got: ${input}`) } }

Có một vài điểm khá thú vị sau đây

// (1) var g = generatorDataConsumer() // (2) g.next() // { value: undefined, done: false } // Ready to consume! // (3) g.next(‘foo’) // { value: undefined, done: false } // Got: foo

Generator Creation (1)

Ở stage này, chúng ta đang tạo ra generator .

Và execution sẽ dừng lại tại điểm .

Next đầu tiên (2)

Execution đầu tiên của

next

giúp cho generator được executed cho tới khi gặp phải

yield

.

Tất cả các giá trị (value) trong stage này khi đi qua

next

sẽ bị lơ đi. Nguyên nhân là vì vẫn chưa có gặp một

yield

nào cả.

Và execution của chúng ta chỉ dừng lại tại điểm khi một value nào đó được đưa ra bởi

yield

.

Next tiếp theo (3)

Lúc này thì value đã đi qua

yield

và như vậy execution sẽ bị ngừng lại.

Hãy dùng Cases

Implement Iterables

Bởi generators là một iterable implementation, khi chúng được tạo ra thì chúng ta cũng sẽ có một iterable object với từng

yield

đại diện cho một giá trị sẽ được đưa ra trên từng iteration. Nói cách khác chúng ta có thể dùng generators để tạo ra iterables.

Ví dụ sau đây sẽ thể hiện generator như là iterable với khả năng lập một dãi các số nguyên cho tới khi nó đạt

max

. Và ta cũng dùng

for-of

để lập những giá trị trên.

Các bạn cũng cần lưu ý rằng

yield

sẽ khiến các execution bị dừng lại tại một điểm và các iteration sẽ khiến cho execution chạy tiếp tại các điểm đó.

function* evenNumbersUntil(max) { for (let value = 0; value <= max; value += 2) { // When ‘value’ is even we want to ‘yield’ it // as our next value in the iteration. if (value % 2 === 0) yield value; } } // We can now user ‘for-of’ to iterate over the values. for (let e of evenNumbersUntil(10)) { console.log(e) // 0 // 2 // 4 // 6 // 8 // 10 }

Asynchronous Code

Ta còn có thể dùng generators với những async code như

promises

.

Tiện thể thì cũng coi như là để giới thiệu về

async/await

trên ES8.

Ví dụ dưới đây cũng sẽ cho ta thấy cách tìm kiếm một JSON file nhờ vào

promises

. Đây là ví dụ của Jake Archibald thuộc developers.google.com.

function fetchStory() { get(‘story.json’) .then(function (response) { return JSON.parse(response) }) .then(function (response) { console.log(‘Yey JSON!’, response) }) }

Nhờ vào co library và một generator, code của chúng ta sẽ nhìn giống như synchronous code.

const fetchStory = co.wrap(function* () { try { const response = yield get(‘story.json’) const text = yield JSON.parse(response) console.log(‘Yey JSON!’, response) } })

Với

async/await

thì nó vẫn sẽ khá giống so với phiên bản trên

async function fetchStory() { try { const response = await get(‘story.json’) const text = await JSON.parse(response) console.log(‘Yey JSON!’, response) } }

Cú pháp


function* name([param[, param[, ... param]]]) { statements }


• name: tên hàm.
• param: tham số đầu vào của hàm, tối đa 255 tham số.
• statements: nội dung của hàm.

Hàm sẽ không được thực thi ngay sau khi gọi, mà thay vào đó generator function trả về iterator, giống như con trỏ trong vòng lặp. Sau khi hàm

next()

của iterator được gọi, generator function sẽ thực thi hàm cho đến khi gặp từ khóa

yield

đầu tiên. Yield sẽ trả về giá trị cho iterator, generator function kết thúc cho đến khi hết giá trị để yield.

Generator là gì?

Để một lập trình viên có thể xây dựng được iterator thì việc theo dõi các bước như: triển khai class bằng phương thức inter_()và_next_(), theo dõi những tình trạng ở bên trong, Stopiteration trong trường hợp xảy ra khi không có giá trị được trả về. Generator còn được dùng với mục đích giải quyết tất cả các vấn đề này. Generator là cách đơn giản được dùng để có thể tạo ra iterator. Bạn có thể đơn hiểu đơn giản Generator là gì như sau: Generator là một trong những hàm trả về một đối tượng (iterator) mà ở đó chúng ta có thể lặp lại (một giá trị ở một thời điểm).

Generator là gì?

Ngoài ra, chúng cũng có nhiệm vụ tạo ra đối tượng theo kiểu danh sách, tuy nhiên bạn chỉ có thể phê duyệt nó qua những phần tử generator một lần duy nhất. Bởi vì, Generator không lưu các dữ liệu trong bộ nhớ nên khi lặp lại thì chúng sẽ tạo ra phần tử tiếp theo trong dãy rồi trả về phần tử đó. Bạn có nhu cầu tìm việc Python vui lòng tham khảo bài viết sau: https://itnavi.com.vn/job/python

Giá trị trả về

Khi chúng ta gọi Generator function : ” nameYourFuntion() ” , nó không trả về các kiểu dữ liệu cơ bản mà đẩy về một iterator object . Hàm next() của iterator object được sử dụng để truy xuất các node dữ liệu sau mỗi bước resume lại generator function. Khi đó generator function sẽ thực thi hàm cho đến khi gặp từ khóa yield , hoặc return kế tiếp chưa được duyệt ở bước trước. P/s : iterator định nghĩa một chuẩn để tạo ra list các giá trị hữu hạn hoặc thậm chí vô hạn. Nó giúp bạn lấy ra giá trị mong muốn khi list kết quả đã được khởi tạo xong toàn bộ.

Yield

• Yield được sử dụng ở một vài nơi và có vẻ khái niệm cũng hơi khác nhau. Trong ruby, javascript hay làm chỉ định trong laravel framework … mỗi nơi có một định nghĩa và cách sử dụng khác nhau. Ngay cả anh google dich cũng sẽ làm bạn lúng túng về nó, “năng suất” , “bày ra”, “sản sinh” . Tôi nghe thì thấy có vẻ chả liên quan gì lập trình và chả thấy có gì tò mò để tìm hiểu. Tuy nhiên trong javascript thì yeild lại khá dễ hiểu và dễ hình dung nhé.
• Về cơ bản, yeild là từ khóa dùng để tạm dừng và cũng để tiếp tục việc thực thi bên trong generator function.

Sử dụng


function* generatorFunc(index) { while (index < 2) { yield index++; } } const iterator = generatorFunc(0); console.log(iterator.next()); // log output: {value : 0, done : false} console.log(iterator.next()); // log output: {value : 1, done : false} console.log(iterator.next()); // log output: {value : underfined, done : true}


Như đã đề cập ở trên thì iterator được khởi tạo bằng generatorFunc với index bắt đầu bằng 0. Bạn có thể thấy yeild ở đây, trong ví dụ này chính là một phiên bản khác giống như return vậy. Nó trả về một đối tượng IteratorResult với hai thuộc tính là “value” và “done”.


value : kết quả của biểu thức trả về. done : nhận giá trị false nếu quá trình generator chưa hoàn thành, true nếu ngược lại.


Giá trị của index được giữ lại sau mỗi lần chúng ta gọi next() và tất nhiên là cả ngữ cảnh của hàm generator cũng thế cho đến khi toàn bộ yield, return đã được duyệt qua..

3.Yield*

Yield* là một dạng ủy quyền thực thi. Ở đây, yield* có thể nhúng mã của một generator function ngay sau nó hoặc là ủy quyền trực tiếp cho một iterator object.

Cú pháp :


yield* [[expression]]


expression ở đây trả về iterator object như đã nói, có thể là generator function, hoặc mảng, hoặng string, hoặc list, ….

Ví dụ :


function* g2() { yield 3; yield 4; } function* g1() { yield* [1, 2]; yield* g2(); yield* '56'; yield* Array.from(arguments); } var iterator = g(9, 10); console.log(iterator.next()); // {value: 1, done: false} console.log(iterator.next()); // {value: 2, done: false} console.log(iterator.next()); // {value: 3, done: false} console.log(iterator.next()); // {value: 4, done: false} console.log(iterator.next()); // {value: "5", done: false} console.log(iterator.next()); // {value: "6", done: false} console.log(iterator.next()); // {value: 9, done: false} console.log(iterator.next()); // {value: 10, done: false} console.log(iterator.next()); // {value: undefined, done: true}


Bạn có thể sử dụng yield* theo nhiều cách như trên, miễn rằng đằng sau đó trả về một object có kiểu thuộc iterator.

Chú ý : yield* là một biểu thức chứ không phải là một câu lệnh, do đó nó sẽ phản ánh lại giá trị được return về. Ví dụ :


function* g2() { yield* [1, 2]; return 't sẽ trở thành vua hải tặc, vd như vậy xem chạy ko'; } var rs; function* g() { rs = yield* g2(); } var iterator = g(); console.log(iterator.next()); // {value: 1, done: false} console.log(iterator.next()); // {value: 2, done: false} console.log(iterator.next()); // {value: undefined, done: true}, // g2() đã trả về {value: 't sẽ trở thành vua hải tặc, vd như vậy xem chạy ko', don


All rights reserved

function* và yield trong Javascript generator function

Một trong những chức năng, cũng như vấn đề mà mọi developer javascript/nodejs đều gặp phải là lập trình bất đồng bộ (async) và callback hell khó điều khiển.

May thay, function* là một trong những chức năng mới của Javascript trong ECMAScript 2015 (6th Edition, hay tắt là ES6). function* giúp khai báo 1 generator function, trả về 1 Generator object. Với chức năng mới này, hàm có thể dừng thực thi bất cứ thời điểm nào, đợi async chạy xong, xong tiếp tục thực thi.

JavaScript Generators

Như chúng ta đã biết, một function thông thường trong JavaScript không thể tạm dừng giữa chừng và sau đó tiếp tục tại nơi nó đã tạm dừng.

Ví dụ:


function display() { console.log('Đây là'); console.log('blog'); console.log('homiedev.com'); }


Ở ví dụ này, hàm

display()

thực thi từ trên xuống. Cách để thoát

display()

là sử dụng return hoặc đưa ra một lỗi. Nếu chúng ta gọi lại hàm

display()

, nó sẽ bắt đầu thực thi từ trên xuống.


display();


Kết quả:


Đây là blog homiedev.com


Vậy làm thế nào để tạm dừng một hàm và sau đó tiếp tục tại nơi nó đã tạm dừng?

ES6 giới thiệu một loại hàm mới khác với một hàm thông thường gọi là function generator hoặc generator. Sử dụng hàm này, chúng ta có thể tạm dừng và tiếp tục tại nơi đã tạm dừng. Một generator được sử dụng như ví dụ sau:


function* goGroceryShopping() { console.log('Dừng lại lần 1'); yield 'hamburger - 🍔'; console.log('Dừng lại lần 2'); yield 'meat - 🥩'; }


Ở hàm

goGroceryShopping()

:

1. Đầu tiên, chúng ta sử dụng dấu hoa thị (*) sau
   
function

   keyword. Dấu hoa thị biểu thị rằng
   
goGroceryShopping()

   là một generator, không phải là một hàm thông thường.
2. Sử dụng câu lệnh yield trả về một giá trị và tạm dừng việc thực thi hàm.

Bây giờ ta thử gọi hàm

goGroceryShopping()

nhé:


let gen = goGroceryShopping();


Ở đoạn code trên, đầu tiên chúng ta sẽ thấy không có gì ở

console

. Nếu

goGroceryShopping()

là một hàm thông thường thì chúng ta sẽ thấy dữ liệu hiển thị ở

console

.

Chúng ta đã thực thi hàm

goGroceryShopping()

, lúc này giá trị trả về từ hàm này sẽ được gán cho biến

gen

, cùng xem kết quả trả về là gì nhé.


console.log(gen);


Kết quả:


Generator { }


Trong ví dụ này, generator trả về một object Generator mà không thực thi phần thân của nó khi nó được gọi.

Object Generator trả về một object khác có hai thuộc tính (properties) là:

done

và

value

. Nói cách khác, object Generator là iterable.

Để tìm hiểu về iterable và những thứ liên quan, bạn đọc bài viết: Iterators và Iterables trong JavaScript bạn đã biết chưa?.

Bây giờ chúng ta thử sử dụng method

next()

của object Generator.


let result = gen.next(); console.log(result);


Kết quả:


Dừng lại lần 1 {value: 'hamburger - 🍔', done: false}


Chúng ta có thể thấy, object Generator thực thi phần thân của nó, sau đó hiển thị thông báo

'Dừng lại lần 1'

ở dòng 1 và trả về giá trị

'hamburger - 🍔'

ở dòng 2.

Câu lệnh yield trả về

'hamburger - 🍔'

và tạm dừng generator ở dòng 2.

Tương tự, chúng ta sẽ gọi method

next()

của Generator lần thứ hai:


result = gen.next(); console.log(result);


Kết quả:


Dừng lại lần 2 {value: 'meat - 🥩', done: false}


Lần này Generator tiếp tục thực thi từ dòng 3 và hiển thị thông báo

'Dừng lại lần 2'

và trả về

'meat - 🥩'

.

Ở lần gọi thứ 3, ta sẽ nhận được kết quả:


{value: undefined, done: true}


Vì generator là iterable, chúng ta có thể sử dụng vòng lặp

for ... of

:


for (const element of gen) { console.log(element); }


Kết quả chúng ta nhận được:


Dừng lại lần 1 hamburger - 🍔 Dừng lại lần 2 meat - 🥩


Một ví dụ khác sử dụng generator:


function* infinite() { let index = 0; while (true) { yield index++; } } const generator = infinite(); console.log(generator.next().value); // 0 console.log(generator.next().value); // 1 console.log(generator.next().value); // 2


Ở ví dụ này, mỗi khi chúng ta gọi method

next()

, nó sẽ trả về số tiếp theo. Chi tiết về vòng lặp while bạn đọc tại: Vòng lặp while trong JavaScript.

Ví dụ

Nói thì dông dài, ví dụ sau sẽ dễ hiểu hơn. Hàm sau có tác dụng tạo ra ID tăng dần, mỗi khi hàm next được gọi.


function* id_maker() { var index = 0; while (index < 3) yield index++; } var gen = id_maker(); console.log(gen.next().value); // 0 console.log(gen.next().value); // 1 console.log(gen.next().value); // 2 console.log(gen.next().value); // undefined



yield

sẽ được gọi 3 lần trong vòng lặp for, do đó khi gọi đến lần thứ 4 thì log sẽ trả về undefined.

Ở ví dụ trên,

gen.next()

sẽ trả về một object có 2 tham số là

value

và

done

. Kiểm tra có còn

next()

được nữa hay không thì chỉ cần kiểm tra giá trị

done



console.log(gen.next()); // { value: 0, done: false }



yield

chỉ có thể return về giá trị, để return về 1 hàm khác, ta sử dụng

yield*



function* anotherGenerator(i) { yield i + 1; yield i + 2; yield i + 3; } function* generator(i) { yield i; yield* anotherGenerator(i); yield i + 10; } var gen = generator(10); console.log(gen.next().value); // 10 console.log(gen.next().value); // 11 console.log(gen.next().value); // 12 console.log(gen.next().value); // 13 console.log(gen.next().value); // 20


Kết

Generator function là một trong những tính năng cực kì hữu ích trong ES6. Nodejs có module co và framework koa (được xem là next generator framework for nodejs) tận dụng rất tốt chức năng này.

yield còn dùng để khử callback phức tạp của Javascript, khử promise – hiện còn làm nhiều bạn lúng túng khi mới bắt đầu với nodejs. Tôi sẽ viết 1 bài hướng dẫn sau.
Từ bản nodejs 0.12 trở lên đã được hỗ trợ chức năng generator function,với node v0.12 phải có tham số

--harmony

để có thể sử dụng yield/function*, còn node 4.0 trở lên thì không cần.


node --harmony ./app.js


Tham khảo:

Cảm ơn bạn!

JavaScript generators là gì? Tìm hiểu thông qua ví dụ

Chào các bạn, hôm nay chúng ta lại tiếp tục với các bài viết về học JavaScript cơ bản nhé 😄. Ở bài viết trước chúng ta đã tìm hiểu về Iterators và Iterables trong JavaScript. Trong bài viết này, chúng ta sẽ học về generators trong JavaScript và làm thế nào để sử dụng chúng nhé!

Keywords searched by users: generator function là gì

Categories: Tóm tắt 15 Generator Function Là Gì

See more here: kientrucannam.vn

See more: https://kientrucannam.vn/vn/