WEEX H5 Render哲学原理 解读(7)之promise类续

by admin on 2018年12月18日

上节大家早就t经阅读了promise.js的代码,通晓了weex对promise基本的包裹。明日我们来读书下,weex是怎支撑promise写法的。遵照昨之觊觎,找到源码。

前言


初学C语言的童鞋,平日以拟了函数和指针的知识后,已经是萌萌哒,学习及了函数指针(请留心勿是函数和指针),更是所有人都不佳了,这篇著作的目标,就是扶持我之童鞋们理解函数指针。�


函数指针概述


先是大家得回顾一下函数的用意:完成有同一定效用的代码块。
再来回顾一下指针的图:一种非常之变量,用来保存地址值,某项目标指针指于某个型的地方。
脚定义了一个告少独数最好酷价值的函数:

int maxValue (int a, int b) {
    return a > b ? a : b;
}     

若就段代码编译后生成的CPU指令存储于代码区,而这段代码其实是足以赢得其地址之,而这地址便是函数曰,我们好利用指针存储这一个函数的地点——函数指针。
函数指针其实就是是千篇一律种独特之指针——指向一个函数的指针。在不少高级语言中,它的牵挂是十分要紧之,尤其是它们的“回调函数”,所以领悟它是非常有必不可少之。

此文件的代码有硌长,我们先行押一下总体代码,然后自己以一点一点分析

函数指针定义及祭


另外变量定义都富含三组成部分: 变量类型 + 变量名 =
初值,那么定义一个函数指针,首先我们要通晓要定义一个争的函数指针(指针类型),那么问题来了,函数的色又是呀吧?大家累分析这段代码:

int maxValue (int a, int b) {
    return a > b ? a : b;
}    

此函数的型是生少只整型参数,返回值是只整型。对应的函数指针类型:

int (*) (int a, int b);  

对应之函数指针定义:

int (*p)(int x, int  y);    

参数称为好去丢,并且普通都是错开丢的。这样指针p就可以保存函数类型为寡单整型参数,再次回到值是整型的函数地址了。

int (*p)(int, int);

透过函数指针调用函数:

int (*p)(int, int) = NULL;
p = maxValue;
p(20, 45);
'use strict';
var immediate = require('immediate');

/* istanbul ignore next */
function INTERNAL() {}

var handlers = {};

var REJECTED = ['REJECTED'];
var FULFILLED = ['FULFILLED'];
var PENDING = ['PENDING'];
/* istanbul ignore else */
if (!process.browser) {
  // in which we actually take advantage of JS scoping
  var UNHANDLED = ['UNHANDLED'];
}

module.exports = Promise;

function Promise(resolver) {
  if (typeof resolver !== 'function') {
    throw new TypeError('resolver must be a function');
  }
  this.state = PENDING;
  this.queue = [];
  this.outcome = void 0;
  /* istanbul ignore else */
  if (!process.browser) {
    this.handled = UNHANDLED;
  }
  if (resolver !== INTERNAL) {
    safelyResolveThenable(this, resolver);
  }
}

Promise.prototype.catch = function (onRejected) {
  return this.then(null, onRejected);
};
Promise.prototype.then = function (onFulfilled, onRejected) {
  if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
    typeof onRejected !== 'function' && this.state === REJECTED) {
    return this;
  }
  var promise = new this.constructor(INTERNAL);
  /* istanbul ignore else */
  if (!process.browser) {
    if (this.handled === UNHANDLED) {
      this.handled = null;
    }
  }
  if (this.state !== PENDING) {
    var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
    unwrap(promise, resolver, this.outcome);
  } else {
    this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
  }

  return promise;
};
function QueueItem(promise, onFulfilled, onRejected) {
  this.promise = promise;
  if (typeof onFulfilled === 'function') {
    this.onFulfilled = onFulfilled;
    this.callFulfilled = this.otherCallFulfilled;
  }
  if (typeof onRejected === 'function') {
    this.onRejected = onRejected;
    this.callRejected = this.otherCallRejected;
  }
}
QueueItem.prototype.callFulfilled = function (value) {
  handlers.resolve(this.promise, value);
};
QueueItem.prototype.otherCallFulfilled = function (value) {
  unwrap(this.promise, this.onFulfilled, value);
};
QueueItem.prototype.callRejected = function (value) {
  handlers.reject(this.promise, value);
};
QueueItem.prototype.otherCallRejected = function (value) {
  unwrap(this.promise, this.onRejected, value);
};

function unwrap(promise, func, value) {
  immediate(function () {
    var returnValue;
    try {
      returnValue = func(value);
    } catch (e) {
      return handlers.reject(promise, e);
    }
    if (returnValue === promise) {
      handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
    } else {
      handlers.resolve(promise, returnValue);
    }
  });
}

handlers.resolve = function (self, value) {
  var result = tryCatch(getThen, value);
  if (result.status === 'error') {
    return handlers.reject(self, result.value);
  }
  var thenable = result.value;

  if (thenable) {
    safelyResolveThenable(self, thenable);
  } else {
    self.state = FULFILLED;
    self.outcome = value;
    var i = -1;
    var len = self.queue.length;
    while (++i < len) {
      self.queue[i].callFulfilled(value);
    }
  }
  return self;
};
handlers.reject = function (self, error) {
  self.state = REJECTED;
  self.outcome = error;
  /* istanbul ignore else */
  if (!process.browser) {
    if (self.handled === UNHANDLED) {
      immediate(function () {
        if (self.handled === UNHANDLED) {
          process.emit('unhandledRejection', error, self);
        }
      });
    }
  }
  var i = -1;
  var len = self.queue.length;
  while (++i < len) {
    self.queue[i].callRejected(error);
  }
  return self;
};

function getThen(obj) {
  // Make sure we only access the accessor once as required by the spec
  var then = obj && obj.then;
  if (obj && typeof obj === 'object' && typeof then === 'function') {
    return function appyThen() {
      then.apply(obj, arguments);
    };
  }
}

function safelyResolveThenable(self, thenable) {
  // Either fulfill, reject or reject with error
  var called = false;
  function onError(value) {
    if (called) {
      return;
    }
    called = true;
    handlers.reject(self, value);
  }

  function onSuccess(value) {
    if (called) {
      return;
    }
    called = true;
    handlers.resolve(self, value);
  }

  function tryToUnwrap() {
    thenable(onSuccess, onError);
  }

  var result = tryCatch(tryToUnwrap);
  if (result.status === 'error') {
    onError(result.value);
  }
}

function tryCatch(func, value) {
  var out = {};
  try {
    out.value = func(value);
    out.status = 'success';
  } catch (e) {
    out.status = 'error';
    out.value = e;
  }
  return out;
}

Promise.resolve = resolve;
function resolve(value) {
  if (value instanceof this) {
    return value;
  }
  return handlers.resolve(new this(INTERNAL), value);
}

Promise.reject = reject;
function reject(reason) {
  var promise = new this(INTERNAL);
  return handlers.reject(promise, reason);
}

Promise.all = all;
function all(iterable) {
  var self = this;
  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
    return this.reject(new TypeError('must be an array'));
  }

  var len = iterable.length;
  var called = false;
  if (!len) {
    return this.resolve([]);
  }

  var values = new Array(len);
  var resolved = 0;
  var i = -1;
  var promise = new this(INTERNAL);

  while (++i < len) {
    allResolver(iterable[i], i);
  }
  return promise;
  function allResolver(value, i) {
    self.resolve(value).then(resolveFromAll, function (error) {
      if (!called) {
        called = true;
        handlers.reject(promise, error);
      }
    });
    function resolveFromAll(outValue) {
      values[i] = outValue;
      if (++resolved === len && !called) {
        called = true;
        handlers.resolve(promise, values);
      }
    }
  }
}

Promise.race = race;
function race(iterable) {
  var self = this;
  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
    return this.reject(new TypeError('must be an array'));
  }

  var len = iterable.length;
  var called = false;
  if (!len) {
    return this.resolve([]);
  }

  var i = -1;
  var promise = new this(INTERNAL);

  while (++i < len) {
    resolver(iterable[i]);
  }
  return promise;
  function resolver(value) {
    self.resolve(value).then(function (response) {
      if (!called) {
        called = true;
        handlers.resolve(promise, response);
      }
    }, function (error) {
      if (!called) {
        called = true;
        handlers.reject(promise, error);
      }
    });
  }
}



/** WEBPACK FOOTER **
 ** ./~/lie/lib/index.js
 **/

扭动调函数


上述情节是函数指针的底蕴因而法,但是大家美观得出来,直接利用函数maxValue岂不是双重有益于?没错,其实函数指针更重要的意思在于函数回调,而上述情节仅是一个选配。
推个例:
前几日大家发出这么一个需要:实现一个函数,将一个整形数组中相比50很之打印在控制台,我们或这样实现:

void compareNumberFunction(int *numberArray, int count, int compareNumber) {
    for (int i = 0; i < count; i++) {
        if (*(numberArray + i) > compareNumber) {
            printf("%d\n", *(numberArray + i));
        }
    }
}
int main() {

    int numberArray[5] = {15, 34, 44, 56, 64};
    int compareNumber = 50;
    compareNumberFunction(numberArray, 5, compareNumber);

    return 0;
}   

这般实现是未曾问题的,但是现在我们以来诸如此类一个需求:实现一个函数,将一个整形数组中比50略之打印在控制台。”What
the fuck!”对于领取需求者,你可能这的心气是这么:

</img>
而是回到现实,这种需求是不可避免的,你可能想过复制粘贴,更改一下论断标准,然则当开发者,大家倘若准备,要考虑到未来或许助长更多类似之需求,那么你拿会起雅量的再一次代码,使您的色转移得臃肿,所以那上我们要冷静下来思考,其实这半独需要很多代码都是千篇一律之,只要反一下论断标准即可,而判断标准大家怎么样更换得尤为灵敏也?这时候我们固然就此到回调函数的知识了,大家得以定义一个函数,这多少个函数需要少单int型参数,函数内部贯彻代码是用点滴只整形数字开比,将较结实的bool值作为函数的归值再次回到下,以超被比较数字的情呢例:

BOOL compareGreater(int number, int compareNumber) {
    return number > compareNumber;
}   

同理,小于被于的数字函数定义如下:

BOOL compareLess(int number, int compareNumber) {
    return number < compareNumber;
}

对接下去,我们得以拿此函数作为compareNumberFunction的一个参数举办传递(没错,函数可以用作参数),那么我们就待一个函数指针获取函数的地方,从而在compareNumberFunction内部举行对函数的调用,于是,compareNumberFunction函数的定义成了这样:

void compareNumberFunction(int *numberArray, int count, int compareNumber, BOOL (*p)(int, int)) {
    for (int i = 0; i < count; i++) {
        if (p(*(numberArray + i), compareNumber)) {
            printf("%d\n", *(numberArray + i));
        }
    }
}

切切实实运用期也之类:

int main() {

    int numberArray[5] = {15, 34, 44, 56, 64};
    int compareNumber = 50;
    // 大于被比较数字情况:
    compareNumberFunction(numberArray, 5, compareNumber, compareGreater);
    // 小于被比较数字情况:
    compareNumberFunction(numberArray, 5, compareNumber, compareLess);

    return 0;
}

依据上述案例,大家好得出结论:函数回调本质也函数指针作为函数参数,函数调用时传入函数地址,这要我们的代码变得更加灵活,可复用性更强。

是代码里要出Promise,QueueItem,handler这三单类似。

动态排序


点的案例一经你早已了解的言辞这动态排序其实乃早就知晓了。首先我们应精晓动态是词,我之精通就是是见仁见智随时,不同景观,暴发不同之事,这就是是动态。话不多说,直接上案例。
需: 有30独学生用排序
随成排
按部就班年排

这种不能测度的求变动,就是咱上文说之动态场景,那么解决方案便是函数回调:

typedef struct student{
    char name[20];
    int age;
    float score;
}Student;

//比较两个学生的年龄
BOOL compareByAge(Student stu1, Student stu2) {
    return stu1.age > stu2.age ? YES : NO;
}
//比较两个学生的成绩
BOOL compareByScore(Student stu1, Student stu2) {
    return stu1.score > stu2.score ? YES : NO;
}
void sortStudents(Student *array, int n, BOOL(*p)(Student, Student)) {
    Student temp;
    int flag = 0;
    for (int i = 0; i < n - 1 && flag == 0; i++) {
        flag = 1;
        for (int j = 0; j < n - i - 1; j++) {
            if (p(array[j], array[j + 1])) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                flag = 0;
            }
        }
    }
}
int main() {

    Student stu1 = {"小明", 19, 98};
    Student stu2 = {"小红", 20, 78};
    Student stu3 = {"小白", 21, 88};
    Student stuArray[3] = {stu1, stu2, stu3};
    sortStudents(stuArray, 3, compareByScore);

    return 0;
}

对,动态排序虽是这样简单!

  • Promise类型定义

函数指针作为函数再次来到值

毋庸置疑,既然函数指针可以当参数,自然吧得以用作重临值。再跟着上案例。
求:定义一个函数,通过传播功效的名目获取到对应之函数。

理一下发型,然后我们分析下需要,当前我们要定义一个叫做findFunction的函数,这么些函数传入一个字符串之后会回一个
int (*)(int,
int)类型的函数指针,那么大家以此函数的扬言是匪是好形容成这么也?

int (*)(int, int) findFunction(char *);   

就看起很适合大家的知,可是,这并无得法,编译器不能辨认六个完全并行的涵盖形参的括号(int,
int)和(char *),真正的款式其实是如此:

int (*findFunction(char *))(int, int);  

这种评释起外观及看又如是颜面滚键盘出来的结果,现在叫咱来日趋的分析一下此宣称的咬合步骤:

  1. findFunction是一个标识符
  • findFunction()是一个函数
  • findFunction(char *)函数接受一个门类也char *的参数
  • *findFunction(char *)函数再次回到一个指南针
  • (*findFunction(char*))()那一个指针指向一个函数
  • (*findFunction(char*))(int, int)指针指向的函数接受七个整形参数
  • int (*findFunction(char *))(int, int)指针指向的函数再次回到一个整形

现在大家的辨析都完结了,编译器可以经了,现在程序员疯了,这对我们的话就是如鲱鱼罐头一样难下咽,那么大家是未是有再度好的书写道呢?(老司机友情指示:typedef)

最终代码衍生和变化成为了如此:

// 重定义函数指针类型
typedef int (*FUNC)(int, int);

// 求最大值函数
int maxValue(int a, int b) {
    return a > b ? a : b;
}

// 求最小值函数
int minValue(int a, int b) {
    return a < b ? a : b;
}
// findFunction函数定义
FUNC findFunction(char *name) {
    if (0 == strcmp(name, "max")) {
        return maxValue;
    } else if (0 == strcmp(name, "min")) {
        return minValue;
    }

    printf("Function name error");
    return NULL;
}   

int main() {

    int (*p)(int, int) = findFunction("max");
    printf("%d\n", p(3, 5));

    int (*p1)(int, int) = findFunction("min");
    printf("min = %d\n", p1(3, 5));

    return 0;
}

暨了此处,函数指针的基础内容早已收了,有的同学还有可能困惑,为啥自己若因为函数去获取函数呢,直接利用maxValue和minValue不就好了么,其实以之后的编程过程被,很有或maxValue和minValue被打包了四起,类的标是匪可以间接用的,那么大家即使需这种办法,假若你上了Objective-C你汇合发觉,所有的不二法门调用的实现原理都是这么。

函数指针数组


今大家应当明了表达式“char * (*pf)(char *
p)”定义的凡一个函数指针pf。既然pf
是一个指南针,这就是得储存在一个数组里。把上式修改一下:
char * (*pf[3])(char * p);
这是概念一个函数指针数组。它是一个屡屡组,数组名吧pf,数组内储存了3
只因为函数的指针。这一个指针指向一些回到值类型为负为字符的指针、参数为一个对准字符的指针的函数。这念起来如不怎么生硬。不过没什么,关键是公驾驭就是一个指针数组,是数组。

函数指针数组怎么下呢?给一个分外简单的事例,只要真的主宰了下办法,再繁杂的问题且可回答。如下:

char * fun1(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun2(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun3(char * p)
{
   printf("%s\n",p);
   return p;
}
int main(){
   char * (*pf[3])(char * p);
   pf[0] = fun1; // 可以直接用函数名
   pf[1] = &fun2; // 可以用函数名加上取地址符
   pf[2] = &fun3;
   pf[0]("fun1");
   pf[0]("fun2");
   pf[0]("fun3");
   return 0;
}

是休是发方面的事例太简单,不够刺激?好,这便来点刺激的。

function Promise(resolver) { if (typeof resolver !== 'function') { throw new TypeError('resolver must be a function'); } this.state = PENDING; this.queue = []; this.outcome = void 0; /* istanbul ignore else */ if (!process.browser) { this.handled = UNHANDLED; } if (resolver !== INTERNAL) { safelyResolveThenable(this, resolver); }}

函数指针数组的指针

扣押正在此题目没发狂吧?函数指针就充分一般初家折腾了,函数指针数组就逾劳苦,现在底函数指针数组指针就更麻烦了然了。

其实,没这样复杂。前边详细探讨了数组指针的题目,这里的函数指针数组指针不就是一个指南针嘛。只不过这么些指针指向一个勤组,这一个数组里面存的都是凭借为函数的指针。仅此而已。

下面就是定义一个粗略的函数指针数组指针:
char * (*(*pf)[3])(char * p);
瞩目,那里的pf 和下边的pf 就全盘是两码事了。上同样节约的pf
并非指针,而是一个数组称为;这里的pf
确实是不容置疑的指针。这么些指针指向一个包含了3
只元素的数组;这一个数字里面存的凡依为函数的指针;这个指针指向一些重临值类型为借助为字符的指针、参数为一个对准字符的指针的函数。那比面的函数指针数组更拗口。其实你不用管这么多,了解这是一个指南针就ok
了。其用法及前方说的数组指针没有区别。下边列一个简便的例子:

char * fun1(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun2(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun3(char * p)
{
   printf("%s\n",p);
   return p;
}
int main(){
   char * (*a[3])(char * p);
   char * (*(*pf)[3])(char * p);
   pf = &a;
   a[0] = fun1;
   a[1] = &fun2;
   a[2] = &fun3;
   pf[0][0]("fun1");
   pf[0][1]("fun2");
   pf[0][2]("fun3");
   return 0;
}

吓了,到了此地C语言已经远非呀可以阻碍你了。

咱俩可见见在实例化promise类时,需要传进一个参数resolver,那多少个价是函数类型。

  • Promise原型扩充定义
    代码中负有<code>Promise.prototype.XXX</code>的代码所定义之法,让我们在每个实例中都得调用catch,then
    的计。例如:

var resoler=function (resolve, reject) {
      setTimeout(function(){
          return resolve(20);
      },20);
}
var dd=new Promise(resoler);
dd.then(function(data){
    console.log(data);
},function(data){
    console.log(data);
});
  • Promise静态方法扩充。名叫可能略问题
    代码中有<code>Promise.XXX</code>中的办法是得静态调用的。例如:

        var fun=function(param){
            if(param ==true){
                return Promise.resolve(true);
            }else{
                return Promise.reject(false);
            }
        };
        fun(true).then(function(data){
            console.log(data);
        },function(data){
            console.log(data);
        });
  • QueueItem内部类,哪儿为其中类为?就是您于另外文件不可能访问到之js类

function QueueItem(promise, onFulfilled, onRejected) {
  this.promise = promise;
  if (typeof onFulfilled === 'function') {
    this.onFulfilled = onFulfilled;
    this.callFulfilled = this.otherCallFulfilled;
  }
  if (typeof onRejected === 'function') {
    this.onRejected = onRejected;
    this.callRejected = this.otherCallRejected;
  }
}
QueueItem.prototype.callFulfilled = function (value) { 
    handlers.resolve(this.promise, value);
};
QueueItem.prototype.otherCallFulfilled = function (value) {
     unwrap(this.promise, this.onFulfilled, value);
};
QueueItem.prototype.callRejected = function (value) { 
    handlers.reject(this.promise, value);
};
QueueItem.prototype.otherCallRejected = function (value) { 
    unwrap(this.promise, this.onRejected, value);
};

事实上QueueItem就是一个promise执行单元,用于连接weex运行时和大家写的promise函数中的then函数。以《在weex原了解读》中深深教工作逻辑代码和weex运行时总是的

  • handler控制器方法

handlers.resolve = function (self, value) { var result = tryCatch(getThen, value); if (result.status === 'error') { return handlers.reject(self, result.value); } var thenable = result.value; if (thenable) { safelyResolveThenable(self, thenable); } else { self.state = FULFILLED; self.outcome = value; var i = -1; var len = self.queue.length; while (++i < len) { self.queue[i].callFulfilled(value); } } return self;};handlers.reject = function (self, error) { self.state = REJECTED; self.outcome = error; /* istanbul ignore else */ if (!process.browser) { if (self.handled === UNHANDLED) { immediate(function () { if (self.handled === UNHANDLED) { process.emit('unhandledRejection', error, self); } }); } } var i = -1; var len = self.queue.length; while (++i < len) { self.queue[i].callRejected(error); } return self;};

handler的点子重如果用来控制时之施行状态,用以控制该实施promise的哪位函数。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图