co

Author: Aa2212002

co/1.txt

@@ -0,0 +1 @@
+11111

co/2.txt

@@ -0,0 +1 @@
+22222

co/index.js

@@ -0,0 +1,156 @@
+const slice = Array.prototype.slice;
+function isObject(val) {
+    return Object === val.constructor;
+}
+
+function isPromise(obj) {
+    return typeof obj.then === "function";
+}
+
+function isGenertor(obj) {
+    return typeof obj.next === "function" && typeof obj.return === "function" && typeof obj.throw === "function";
+}
+
+function isGenertorFunction(fn) {
+    try {
+        const constructor = fn.constructor;
+        if (!constructor) {
+            return false;
+        }
+        if (constructor.name === "GeneratorFunction") {
+            return true;
+        }
+        return isGenertor(constructor.prototype);
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * @param {*} thunk -> 将参数与回调函数分离 fn(p1, p2, cb) -> thunk(p1, p2)(cb)
+ */
+function thunkToPromise(thunk) {
+    const ctx = this;
+    return new Promise((resolve, reject) => {
+        thunk.call(ctx, (err, res) => {
+            if (err) return reject(err);
+            if (arguments.length > 2) {
+                res = slice.call(arguments, 1);
+            }
+            resolve(res);
+        })
+    })
+}
+
+function objectToPromise(obj) {
+    const results = new obj.constructor();
+    const keys = Reflect.ownKeys(obj);
+    const promises = [];
+    for(let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const promise = toPromise.call(this, obj[key]);
+        if(promise && isPromise(promise)) {
+            defer(promise, key)
+        } else {
+            results[key] = obj[key]
+        }
+    }
+    return Promise.all(promises).then(() => results);
+    function defer(promise, key) {
+        results[key] = undefined;
+        promises.push(promise.then(res => {
+            results[key] = res;
+        }))
+    }
+}
+
+function arrayToPromise(arr) {
+    return Promise.all(arr.map(toPromise, this))
+}
+
+function toPromise(obj) {
+    if(!obj) return obj;
+    if(isPromise(obj)) return obj;
+    if(isGenertor(obj) || isGenertorFunction(obj)) return co.call(this, obj);
+    if(typeof obj === "function") return thunkToPromise.call(this, obj);
+    if(Array.isArray(obj)) return arrayToPromise.call(this, obj);
+    if(isObject(obj)) return objectToPromise.call(this, obj);
+    return obj;
+}
+
+function co(gen) {
+    const ctx = this;
+    const args = slice.call(arguments, 1);
+    let it;
+    return new Promise((resolve, reject) => {
+        if(typeof gen === "function") {
+            it =  gen.apply(ctx, args);
+        }
+        if(!it || !isGenertor(it)) {
+            return resolve(it)
+        }
+        onFulfilled();
+        function onFulfilled(res) {
+            let ret;
+            try {
+                ret = it.next(res)
+            } catch(e) {
+                return reject(e)
+            }
+            next(ret)
+        }
+        function onRejected(err) {
+            let ret;
+            try {
+                ret = it.throw(err)
+            } catch (e) {
+                return reject(e)
+            }
+            next(ret)
+        }
+        function next(ret) {
+            if(ret.done) return resolve(ret.value);
+            const value = toPromise.call(ctx, ret.value);
+            if(value && isPromise(value)) {
+                return value.then(onFulfilled, onRejected)
+            }
+            return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, ' +
+                'but the following object was passed: "' + String(ret.value) + '"'));
+        }
+    })
+}
+co.wrap = function (fn) {
+    createPromise.__generatorFunction__ = fn;
+    return createPromise;
+    function createPromise() {
+        return co.call(this, fn.apply(this, arguments));
+    }
+};
+const fs = require("fs");
+const path = require('path');
+const readFile = function (filePath) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(filePath, "utf-8", (err, data) => {
+            if (!err) {
+                resolve(data);
+            } else {
+                reject(err)
+            }
+        })
+    })
+};
+
+function* generator() {
+    const file1 = yield readFile(path.join(__dirname, '1.txt'));
+    console.log(file1);
+    const file2 = yield readFile(path.join(__dirname, '2.txt'));
+    console.log(file2);
+    const file3 = yield readFile(path.join(__dirname, '1.txt'));
+    console.log(file3);
+    const file4 = yield readFile(path.join(__dirname, '2.txt'));
+    console.log(file4);
+    const file5 = yield readFile(path.join(__dirname, '1.txt'));
+    console.log(file5);
+    return 666;
+}
+co(generator);

promise.js

@@ -37,4 +37,13 @@ function runGen(gen) {
     };
     next();
 };
-runGen(generator)
+runGen(generator);
+
+
+function* gen() {
+    const a = yield 4;
+    console.log(a);
+}
+const it = gen();
+console.log(it.next());
+it.next(3)

simple.js

@@ -45,7 +45,21 @@ run(generator)
 //     });
 // });
 
-
+function thunk(fn) {
+    return function() {
+        const args = Array.prototype.slice.call(arguments);
+        const ctx = this;
+        return function(cb) {
+            let called = false;
+            args.push(function() {
+                if(called) return;
+                called = true;
+                cb.apply(ctx, arguments)
+            });
+            return fn.apply(ctx, args);
+        }
+    }
+} 
 
 
 const Thunk = function (fn) {
@@ -67,3 +81,10 @@ function test(name, age, callback) {
 };
 const testThunk = Thunk(test);
 testThunk(1,2)((a, b) => console.log(a, b))
+var obj = {
+    a: [1, 2, 3]
+};
+var c = obj.a;
+const v = {};
+v.c = c;
+console.log(obj.a === v.c)