함수*, 수익률 및 수익률*이란 무엇입니까?

Brief

A Linked List

Iterator Logic

yield*

Reverse the data

Did the child become a parent?

Let's Apply it and Test

Repl

Recap

Destructuring parameters from next via yield

짧았어
목록을 반복해서 훑어보았을 때, 대부분의 사람들이 지금 그것을 직관적으로 사용할 수 있을 것이다. Array.map()그러나 우리 중 많은 사람들이 데이터가 아니라 응용 프로그램 논리로 정의된 숫자에 따라 목록을 만드는 것을 좋아한다.보통, 나는 가져오거나 범위 도움말을 만들 것이다.피보나치 같은 특정 서열은?이곳에서 우리는 거대하고 무한대할 수 있는 목록의 힘을 이용할 수 있다.통상적으로 lodash.range에서 목록이 특히 크면 큰 목록은 성능에 영향을 미친다.
본질적으로, 우리는 로드 지연 시퀀스를 만들고 있습니다.
오늘날의 많은 라이브러리에서, 우리는 데이터 목록을 처리하는 데 자주 사용하는 방법으로, 이러한 데이터의 길이나 모든 요소의 크기가 매우 클 수 있다.그림 갤러리.
많은 조수를 작성하거나 라이브러리를 가져오거나 번거로운 유형 관련을 템플릿 파일로 만들지 않아도 내장 생성기를 볼 수 있습니다.
현재, 우리가 응용 프로그램 시퀀스, 심지어 사용할 수 있는 json을 정의할 때, 우리는 데이터 흐름의 수도꼭지를 즉시 닫을 수 있다.필요할 때만 그것을 열어 다시 사용할 수 있도록 하고, 다시 시작할 때 완전히 버릴 수 있도록 합니다.

체인 테이블
데이터 목록을 지정하여 다음과 같이 시작할 수 있습니다.

const familyTree = [
    ["Adam", "Jane", "Doe"],
    ["Jane", "Peter", "Mary"],
    ["Mary", "Liam", "Olivia"],
    ["William", "Ava", "Lucas"]
]

여기에 우리는'정렬'목록이 하나 있는데 O(n)부터 시작해서 최초의 세대이고 마지막 색인이 가장 오래된 것이다.
첫 번째는'아이', 다른 두 번째는 친부모라고 가정해 보자.

반복자 논리
창설 familyTree[0] 교체기 논리부터 시작합시다.

function* genList(p1, p2) {
    const genealogy = [...familyTree].reverse();
}

우리의 데이터를 고려하여 나는 한 세대부터 역작업을 시작하고 확장 연산자를 사용하여 돌연변이를 방지하기로 했다.
이 데이터들 중, 우리 가족 트리는 목록의 맨 앞이나 맨 앞에 최신 세대를 포함하고 있다.그래서 우리는 시작하기 전에 명세서를 거꾸로 할 수 있다.

굴복*
우리는 familyTree 모든 요소의 맵을 쉽게 만들어서 주어진 데이터를 간단하게 '교체' 하고 yield* 의 모든 그룹을 제시할 수 있지만, 그 즐거움은 어디에 있는가.우리의 생성기는 논리가 있어야 하고 familyTree는 조건이 있어야 한다!yield genealogy[i]의 작용을 밝히기 위해서*:

function* genList() {
   yield* [...familyTree].reverse();
}

let i = genList();
console.log(i.next().value); //  [ 'William', 'Ava', 'Lucas' ] 
console.log(i.next().value); //  [ 'Mary', 'Liam', 'Olivia' ] 

누구yield*나 누구를 찾고 있는지 검색해 봅시다.

'올비아'라고 상상해 봅시다.

["William", "Ava", "Lucas"]는 우리가 반전한 첫 번째이기 때문에 우리는 그것을 뛰어넘을 수 있다

데이터 반전

function* genList(p1, p2) {
    const genealogy = [...familyTree].reverse();
    let start = 0, end = genealogy.length - 1;
    for (const i in genealogy) {
        if (genealogy[i].includes(p2)) {
            start = +i // coerce typeof i to number from string
        }
        if (genealogy[i].includes(p1)) {
            // Exercise: what would go here, and why?
            // leave a comment below 😉
        }
    }

이제 우리는 여기에 없는 이름을 배제할 수 있다.
모든 가족의 수조에 있는 링크를 찾아서 앞의 수조에 대한 간단한 목록을 순환합니다.

또는'혈연'관계

참고: 체인표

아이가 부모가 되었습니까?
매인.js

function* genList(p1, p2) {
    [...]


    // |-> Read along
    // Iterator Logic
    for (let i = start; i <= end; i++) {
        // yield will send over the first family
        let link = yield genealogy[i]
        // with .next(Child) we can pass over a name 
        // from the above: yield genealogy[i]
        // to the above: link
        if (link && (i + 1) <= end) {
            let [_, ...parents] = genealogy[i + 1]
            // Did that child became a parent?                      
            // Let's see if parents include the link
            if (parents.includes(link)) {
                yield genealogy[i]
            }
        } else {
            // but if there's no subsequent links...
            break;
        }
    }
}

적용하고 테스트하도록 하겠습니다.
매인.js

/**
 * 
 * @param p1 Child
 * @param p2 Relative
 */
const isGenerational = (p1, p2) => {
    let link;

    // generate genealogy with lower and upper bounds
    const ancestry = genList(p1, p2)
    // get Child from each family and yield links 
    for (const [ancestor] of ancestry) {
        (ancestor === p1)
            // if p1 is found, we can throw the list away
            ? link = ancestry.return(true)
            // if linked list continues
            : link = ancestry.next(ancestor)

    }
    return (link.done && link.value)
}

(async () => {
    console.log(
        (isGenerational("Adam", "Olivia") === true),
        (isGenerational("Adam", "Lucas") === false),
        (isGenerational("Jane", "Liam") === true),
        (isGenerational("Mary", "Ava") === false),
    )
})();

회신

let link = yield genealogy[i]

let whatAboutThis = yield context[i]
if (whatAboutThis) {
    // perform check, updates, hydrate, whatever
    await updateContext(whatAboutThis)
    yield context["imaginary"]
}

const iterator = contextSequence(); // generates sequence of "context"
let water = iterator.next("hydrate"); // <- gets passed to `whatAboutThis` 
water.value // -> value stored of context["imaginary"]