JavaScript Programming Labs

Your Task: Use generator functions to build sequences and define custom iterables using Symbol.iterator.

Detailed Requirements:

1. Create a generator function with function* that yields a few values and then returns.
function* idGenerator() { yield 1; yield 2; yield 3; return 4; // not iterated by for...of } const g = idGenerator(); console.log(g.next()); // { value: 1, done: false } console.log(g.next()); // { value: 2, done: false }
2. Iterate a generator with for...of and via manual next() calls.
for (const n of idGenerator()) { console.log(n); // 1, 2, 3 } const it = idGenerator(); console.log(it.next().value); // 1
3. Create a custom iterable object that implements [Symbol.iterator]() and returns an iterator with next(). const range = (start, end) => ({ start, end, [Symbol.iterator]() { let cur = this.start; return { next: () => ({ value: cur, done: cur++ > end }) }; } }); console.log([...range(1, 5)]); // [1,2,3,4,5]
4. Delegate iteration with yield* to compose generators.
function* letters() { yield* ['A', 'B', 'C']; } for (const ch of letters()) console.log(ch); // A B C
5. Early close a generator using return() and observe done: true. const gen = idGenerator(); console.log(gen.return('stop')); // { value: 'stop', done: true }
6. Spread generator results into an array: [...generator].

Your Task: Stream asynchronous data using async function*, consume with for await...of, and implement Symbol.asyncIterator.

Detailed Requirements:

1. Create an async generator with async function* that awaits between yields. const delay = (ms) => new Promise(r => setTimeout(r, ms)); async function* asyncCounter(max) { for (let i = 1; i <= max; i++) { await delay(100); yield i; } }
2. Consume with for await...of to handle the yielded Promises. (async () => { for await (const n of asyncCounter(3)) { console.log('n =', n); } })();
3. Manual async iteration by calling next() and await its result. (async () => { const it = asyncCounter(2); console.log(await it.next()); // { value: 1, done: false } })();
4. Create a custom async iterable using [Symbol.asyncIterator](). const asyncRange = (start, end, step = 1) => ({ start, end, step, async *[Symbol.asyncIterator]() { for (let v = this.start; v <= this.end; v += this.step) { await delay(50); yield v; } } });
5. Handle errors in an async generator with try/catch. async function* risky() { try { yield 1; throw new Error('boom'); } catch (e) { yield 'handled:' + e.message; } }
6. Use for await with custom async iterable: for await (const v of asyncRange(...)).

Your Task: Intercept operations on objects and functions using Proxy and use Reflect to forward operations safely.

Detailed Requirements:

1. Create a Proxy around an object to log reads/writes. const target = { role: 'user' }; const handler = { get(target, prop, receiver) { console.log('get', prop); return Reflect.get(target, prop, receiver); }, set(target, prop, value, receiver) { console.log('set', prop, value); return Reflect.set(target, prop, value, receiver); } }; const user = new Proxy(target, handler); user.name = 'Alice'; console.log(user.name);
2. Validate writes in set (e.g., ensure age is a number) and block invalid data. const validator = { set(obj, prop, value) { if (prop === 'age' && typeof value !== 'number') throw new TypeError('age must be number'); return Reflect.set(obj, prop, value); } }; const safeUser = new Proxy({}, validator); // safeUser.age = 'x' // throws
3. Intercept "in" checks with has trap and delete with deleteProperty. const audit = { has(t, p) { console.log('has', p); return Reflect.has(t, p); }, deleteProperty(t, p) { console.log('delete', p); return Reflect.deleteProperty(t, p); } }; const audited = new Proxy({ a: 1 }, audit); console.log('a' in audited); delete audited.a;
4. Proxy a function (use apply) or a constructor (construct). function sum(a, b) { return a + b; } const fnProxy = new Proxy(sum, { apply(target, thisArg, args) { console.log('apply', args); return Reflect.apply(target, thisArg, args); } }); console.log(fnProxy(2, 3)); // 5
5. Use Proxy.revocable() and show that operations fail after revoke(). const { proxy, revoke } = Proxy.revocable({ x: 1 }, {}); console.log(proxy.x); // 1 revoke(); try { console.log(proxy.x); } catch (e) { console.log('revoked'); }
6. Use Reflect methods (get, set, has, deleteProperty) inside traps.