精华内容
下载资源
问答
  • free命令的用法

    2019-08-07 15:32:00
    首先我们介绍命令格式为 free [参数]。 介绍第一条命令"free"显示内存使用信息。默认按照M计数单位统计...Shared表示 多进程共享内存总额。 Buffers/cached表示 磁盘缓存大小。 第行(-/+buffers/ca...

    首先我们介绍命令的格式为 free [参数]。

    介绍第一条命令"free"显示内存的使用信息。默认按照M的计数单位统计。

    显示各个参数说明:

    total表示 总计物理内存的大小。

    used表示 已使用多少。

    free表示 可用内存多少。

    Shared表示 多个进程共享的内存总额。

    Buffers/cached表示 磁盘缓存的大小。

    第三行(-/+ buffers/cached)解释

    used:已使用多大。

    free:可用有多少。

    第四行是交换分区SWAP的,也就是我们通常所说的虚拟内存。

    我们按照系统应用程序来说:系统可用内存= 系统free+buffers+cached。

    • 2

      下一条命令"free -g",按照g的计数方式来显示内存信息。

    • 3

      下一条命令"free -m",按照M的计数方式来显示内存信息。

    • 4

      下一条命令"free -k",按照K的计数方式来显示内存信息。

    • 5

      下一条命令"free -t",按照总和的形式显示内存的使用信息。

    • 6

      下一条命令"free -s 2 -c 4"。表示为周期性展示统计内存信息。本篇实例为每隔2秒统计一次,统计4次。

    • 7

      下一条命令"free -s 5",表示周期性展示内存使用情况,意思为每隔5秒统计展示,直到我们按下ctrl +c 键取消统计为止。

    • 8

      如果需要查看版本信息,我们执行命令"free -V",进行查看。

      END

    转载于:https://www.cnblogs.com/qingqing1/p/11315607.html

    展开全文
  • 英语中冠词有三个,分别是不定冠词a, an和定冠词the。有时名词前不用冠词称为零冠词。不定冠词就是a和an了。a用于辅音音素或半元音音素开头单词前,an用于元音音素开头单词前。The indefinite articles A/AN are...

    d1c1ea54a4e86fc984663853cf531a37.png

    1f72d1f044aaff130d63d8662ed7547d.gif

    冠词是虚词,是名词的一种标志,它不能脱离名词独立存在,也不能单独作句子成分。英语中冠词有三个,分别是不定冠词a, an和定冠词the。有时名词前不用冠词称为零冠词。

    742816706b84d0f77efc49bced5a8b57.png

    不定冠词就是a和an了。

    a用于辅音音素或半元音音素开头的单词前,

    an用于元音音素开头的单词前。

    b94a15e8a4bdd72d71570f934f2d9821.png

    The indefinite articles A/AN are used when talking about a general or non-specific noun.

    不定冠词A/AN指的是一般名词或非特定名词。

    Where is a teacher?/A book is on the table./Did you bring a cake?

    老师在哪里?/桌子上有一本书。/你带蛋糕了吗?

    But unlike the definite article, A/AN can only be used with singular countable nouns. We can’t say a teachers, a books, a cakes.

    但与定冠词不同,A/AN只能用于单数可数名词。我们不能说是a teachers, a books, a cakes。

    Instead we use the definite article: the teachers, the books, the cakes.

    取而代之的是定冠词:the teachers, the books, the cakes。

    Where are the teachers?/The books are on the table./Did you bring the cakes?

    老师们在哪里?/书在桌子上。/你把蛋糕带来了吗?

    In English, we use an with any noun that starts with a vowel sound, NOT with a noun that starts with a vowel. This is very important because many nouns that start with a vowel don’t have a vowel sound such as university, we say a university NOT an university. Also, many vowel sounding words don’t start with a vowel for example hour, we say an hour.

    在英语中,我们使用以元音开头的任何名词,而不是以元音开头的名词。这一点非常重要,因为许多以元音开头的名词没有元音,比如大学,我们说的大学不是大学。而且,许多听起来像元音的单词都不是以元音开头的,比如小时,我们说一小时。

    Below is a list of nouns you can use ‘an’ with:

    下面是可以与“an”一起使用的名词列表:

    an oven/an apple/an honour/an octopus/an auntie/an injury/an umbrella/an egg

    烤箱/苹果/荣誉/章鱼/阿姨/受伤/雨伞/鸡蛋

    Here is a list of nouns used with A:

    下面是与a一起使用的名词列表:

    a table/a pillow/a university/a cake/a bed/a utopia

    桌子/枕头/大学/蛋糕/床/乌托邦

    Here is a list of nouns used with An:

    下面是与一个An连用的名词列表:

    an oven/an orange/an honour/an invention/an hour/an evening

    烤箱/桔子/荣誉/发明/一小时/一晚

    Here are examples of how we use A and An in a sentence:

    下面是我们如何在句子中使用A和An的例子:

    There is a university close to here./The movie starts in an hour./There is an octopus in the water./The new house doesn’t have an oven but it has a washing machine./I need an umbrella, it’s raining outside.

    附近有一所大学。/电影一小时后开始。/水里有一只章鱼。/新房子没有烤箱,但有洗衣机。/我需要一把伞,外面在下雨。

    THE is called a definite article, we use the with all nouns and for specific nouns, like a certain person or a particular thing.

    The被称为定冠词,我们使用与所有名词和特定名词,如某个人或某事物。

    9a34f8602771a5e8b127576030974fbf.png

    Where is the teacher?/The book is on the table/Did you bring the cake?

    老师在哪里?/书在桌子上/你带蛋糕了吗?

    The examples above are talking about specific things or people. In the first example, they are looking for a specific teacher, maybe a biology teacher or an English teacher. They are not looking for any teacher, they want to know where that particular teacher is.

    上面的例子是谈论特定的事物或人。在第一个例子中,他们正在寻找一个特定的老师,也许是一个生物老师或者一个英语老师。他们不找老师,他们想知道那个老师在哪里。

    The other two examples have a similar concept, example two is talking about a specific book on a specific table. And the third example is talking about a particular cake, maybe a birthday cake or a wedding cake.

    另外两个例子有一个相似的概念,例子二是在一个特定的桌子上谈论一本特定的书。第三个例子是一个特别的蛋糕,可能是生日蛋糕或者婚礼蛋糕。

    5b4ba368fa11b72fadaf5ddbcccfbcb5.png
    (转发下面任一海报即可)惊喜多多,活动真实有效,详情咨询河南环球雅思。

    8124c47d7e30d01cb854f38bce86adab.png
    ↓ ↓ ↓ 下面这些课程福利,正是小编精心为你准备的~

    d9eeb0d7e4c5a0e81e53a3412aff65bc.png

    83ad52b56e0a2a8f8331236a3537ac11.png

    28e15c528d2503affcf5128e400518ae.png

    f9ff104c92b7ea4d7e6d80c7ee42d4cc.gif

    c203849982873969e439bea8e2c10c15.png

    c6ff33a398f2ffb0b31463498b032eee.png

    2966a9d0dcbd063c54e4e749c59afd0b.png
    小编精心分享,很需要你的支持呀~~
    展开全文
  • header() is used to ...//在每重定向之后都必须加上“exit”,避免发生错误后,继续执行。?>复制代码 代码如下:<?phpheader(“refresh:2;url=https://www.jb51.net”);echo “正在加载,请稍等… 秒后自
  • 要想学习一个知识点,肯定是从三个方面出发,what、why、how。下面就跟着我一步步学习吧~二 什么是Promise首先是what。那么什么是Promise呢?以下是MDN对Promise定义The Promise object is used for asynchronous ...

    一 前言

    本文主要对ES6的Promise进行一些入门级的介绍。要想学习一个知识点,肯定是从三个方面出发,what、why、how。下面就跟着我一步步学习吧~

    二 什么是Promise

    首先是what。那么什么是Promise呢?

    以下是MDN对Promise的定义

    The Promise object is used for asynchronous computations. A Promise represents a single asynchronous operation that hasn't completed yet, but is expected in the future.

    译文:Promise对象用于异步操作,它表示一个尚未完成且预计在未来完成的异步操作。

    那么什么是异步操作?在学习promise之前需要把这个概念搞明白,下面将抽离一章专门介绍。

    2.1 同步与异步

    我们知道,JavaScript的执行环境是「单线程」。

    所谓单线程,是指JS引擎中负责解释和执行JavaScript代码的线程只有一个,也就是一次只能完成一项任务,这个任务执行完后才能执行下一个,它会「阻塞」其他任务。这个任务可称为主线程。

    但实际上还有其他线程,如事件触发线程、ajax请求线程等。

    这也就引发了同步和异步的问题。

    2.1.1 同步

    同步模式,即上述所说的单线程模式,一次只能执行一个任务,函数调用后需等到函数执行结束,返回执行的结果,才能进行下一个任务。如果这个任务执行的时间较长,就会导致「线程阻塞」。

    1 /*例2.1*/

    2 var x = true;3 while(x);4 console.log("don't carry out"); //不会执行

    上面的例子即同步模式,其中的while是一个死循环,它会阻塞进程,因此第三句console不会执行。

    同步模式比较简单,也较容易编写。但问题也显而易见,如果请求的时间较长,而阻塞了后面代码的执行,体验是很不好的。因此对于一些耗时的操作,异步模式则是更好的选择。

    2.1.2 异步

    下面就来看看异步模式。

    异步模式,即与同步模式相反,可以一起执行多个任务,函数调用后不会立即返回执行的结果,如果任务A需要等待,可先执行任务B,等到任务A结果返回后再继续回调。

    最常见的异步模式就数定时器了,我们来看看以下的例子。

    1 /*例2.2*/

    2 setTimeout(function() {3 console.log('taskA, asynchronous');4 }, 0);5 console.log('taskB, synchronize');6 //while(true);

    7

    8 -------ouput-------

    9 taskB, synchronize10 taskA, asynchronous

    我们可以看到,定时器延时的时间明明为0,但taskA还是晚于taskB执行。这是为什么呢?由于定时器是异步的,异步任务会在当前脚本的所有同步任务执行完才会执行。如果同步代码中含有死循环,即将上例的注释去掉,那么这个异步任务就不会执行,因为同步任务阻塞了进程。

    2.1.3 回调函数

    提起异步,就不得不谈谈回调函数了。上例中,setTimeout里的function便是回调函数。可以简单理解为:(执行完)回(来)调(用)的函数。

    以下是WikiPedia对于callback的定义。

    In computer programming, a callback is a piece of executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at some convenient time.

    可以看出,回调函数是一段可执行的代码段,它以「参数」的形式传递给其他代码,在其合适的时间执行这段(回调函数)的代码。

    WikiPedia同时提到

    The invocation may be immediate as in a synchronous callback, or it might happen at a later time as in an asynchronous callback.

    也就是说,回调函数不仅可以用于异步调用,一般同步的场景也可以用回调。在同步调用下,回调函数一般是最后执行的。而异步调用下,可能一段时间后执行或不执行(未达到执行的条件)。

    1 /*例2.3*/

    2 /******************同步回调******************/

    3 var fun1 = function(callback) {4 //do something

    5 console.log("before callback");6 (callback && typeof(callback) === 'function') &&callback();7 console.log("after callback");8 }9 var fun2 = function(param) {10 //do something

    11 var start = newDate();12 while((new Date() - start) < 3000) { //delay 3s

    13 }14 console.log("I'm callback");15 }16 fun1(fun2);17

    18 -------output--------

    19 before callback20 //after 3s

    21 I’m callback22 after callback

    由于是同步回调,会阻塞后面的代码,如果fun2是个死循环,后面的代码就不执行了。

    上一小节中setTimeout就是常见的异步回调,另外常见的异步回调即ajax请求。

    1 /*例2.4*/

    2 /******************异步回调******************/

    3 functionrequest(url, param, successFun, errorFun) {4 $.ajax({5 type: 'GET',6 url: url,7 param: param,8 async: true, //默认为true,即异步请求;false为同步请求

    9 success: successFun,10 error: errorFun11 });12 }13 request('test.html', '', function(data) {14 //请求成功后的回调函数,通常是对请求回来的数据进行处理

    15 console.log('请求成功啦, 这是返回的数据:', data);16 },function(error) {17 console.log('sorry, 请求失败了, 这是失败信息:', error);18 });

    2.2 为什么使用Promise

    说完了以上基本概念,我们就可以继续学习Promise了。

    上面提到,Promise对象是用于异步操作的。既然我们可以使用异步回调来进行异步操作,为什么还要引入一个Promise新概念,还要花时间学习它呢?不要着急,下面就来谈谈Promise的过人之处。

    我们先看看下面的demo,利用Promise改写例2.4的异步回调。

    1 /*例2.5*/

    2 functionsendRequest(url, param) {3 return new Promise(function(resolve, reject) {4 request(url, param, resolve, reject);5 });6 }7

    8 sendRequest('test.html', '').then(function(data) {9 //异步操作成功后的回调

    10 console.log('请求成功啦, 这是返回的数据:', data);11 }, function(error) {12 //异步操作失败后的回调

    13 console.log('sorry, 请求失败了, 这是失败信息:', error);14 });

    这么一看,并没有什么区别,还比上面的异步回调复杂,得先新建Promise再定义其回调。其实,Promise的真正强大之处在于它的多重链式调用,可以避免层层嵌套回调。如果我们在第一次ajax请求后,还要用它返回的结果再次请求呢?

    1 /*例2.6*/

    2 request('test1.html', '', function(data1) {3 console.log('第一次请求成功, 这是返回的数据:', data1);4 request('test2.html', data1, function(data2) {5 console.log('第二次请求成功, 这是返回的数据:', data2);6 request('test3.html', data2, function(data3) {7 console.log('第三次请求成功, 这是返回的数据:', data3);8 //request... 继续请求

    9 }, function(error3) {10 console.log('第三次请求失败, 这是失败信息:', error3);11 });12 }, function(error2) {13 console.log('第二次请求失败, 这是失败信息:', error2);14 });15 }, function(error1) {16 console.log('第一次请求失败, 这是失败信息:', error1);17 });

    以上出现了多层回调嵌套,有种晕头转向的感觉。这也就是我们常说的厄运回调金字塔(Pyramid of Doom),编程体验十分不好。而使用Promise,我们就可以利用then进行「链式回调」,将异步操作以同步操作的流程表示出来。

    1 /*例2.7*/

    2 sendRequest('test1.html', '').then(function(data1) {3 console.log('第一次请求成功, 这是返回的数据:', data1);4 }).then(function(data2) {5 console.log('第二次请求成功, 这是返回的数据:', data2);6 }).then(function(data3) {7 console.log('第三次请求成功, 这是返回的数据:', data3);8 }).catch(function(error) {9 //用catch捕捉前面的错误

    10 console.log('sorry, 请求失败了, 这是失败信息:', error);11 });

    是不是明显清晰很多?孰优孰略也无需多说了吧~下面就让我们真正进入Promise的学习。

    三 Promise的基本用法

    3.1 基本用法

    上一小节我们认识了promise长什么样,但对它用到的resolve、reject、then、catch想必还不理解。下面我们一步步学习。

    Promise对象代表一个未完成、但预计将来会完成的操作。

    它有以下三种状态:

    pending:初始值,不是fulfilled,也不是rejected

    fulfilled:代表操作成功

    rejected:代表操作失败

    Promise有两种状态改变的方式,既可以从pending转变为fulfilled,也可以从pending转变为rejected。一旦状态改变,就「凝固」了,会一直保持这个状态,不会再发生变化。当状态发生变化,promise.then绑定的函数就会被调用。

    注意:Promise一旦新建就会「立即执行」,无法取消。这也是它的缺点之一。

    下面就通过例子进一步讲解。

    1 /*例3.1*/

    2 //构建Promise

    3 var promise = new Promise(function(resolve, reject) {4 if (/*异步操作成功*/) {5 resolve(data);6 } else{7 /*异步操作失败*/

    8 reject(error);9 }10 });

    类似构建对象,我们使用new来构建一个Promise。Promise接受一个「函数」作为参数,该函数的两个参数分别是resolve和reject。这两个函数就是就是「回调函数」,由JavaScript引擎提供。

    resolve函数的作用:在异步操作成功时调用,并将异步操作的结果,作为参数传递出去;

    reject函数的作用:在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。

    Promise实例生成以后,可以用then方法指定resolved状态和reject状态的回调函数。

    1 /*接例3.1*/

    2 promise.then(onFulfilled, onRejected);3

    4 promise.then(function(data) {5 //do something when success

    6 }, function(error) {7 //do something when failure

    8 });

    then方法会返回一个Promise。它有两个参数,分别为Promise从pending变为fulfilled和rejected时的回调函数(第二个参数非必选)。这两个函数都接受Promise对象传出的值作为参数。

    简单来说,then就是定义resolve和reject函数的,其resolve参数相当于:

    1 functionresolveFun(data) {2 //data为promise传出的值

    3 }

    而新建Promise中的'resolve(data)',则相当于执行resolveFun函数。

    Promise新建后就会立即执行。而then方法中指定的回调函数,将在当前脚本所有同步任务执行完才会执行。如下例:

    1 /*例3.2*/

    2 var promise = new Promise(function(resolve, reject) {3 console.log('before resolved');4 resolve();5 console.log('after resolved');6 });7

    8 promise.then(function() {9 console.log('resolved');10 });11

    12 console.log('outer');13

    14 -------output-------

    15 before resolved16 after resolved17 outer18 resolved

    由于resolve指定的是异步操作成功后的回调函数,它需要等所有同步代码执行后才会执行,因此最后打印'resolved',这个和例2.2是一样的道理。

    3.2 基本API

    .then()

    语法:Promise.prototype.then(onFulfilled, onRejected)

    对promise添加onFulfilled和onRejected回调,并返回的是一个新的Promise实例(不是原来那个Promise实例),且返回值将作为参数传入这个新Promise的resolve函数。

    因此,我们可以使用链式写法,如上文的例2.7。由于前一个回调函数,返回的还是一个Promise对象(即有异步操作),这时后一个回调函数,就会等待该Promise对象的状态发生变化,才会被调用。

    .catch()

    语法:Promise.prototype.catch(onRejected)

    该方法是.then(undefined, onRejected)的别名,用于指定发生错误时的回调函数。

    1 /*例3.3*/

    2 promise.then(function(data) {3 console.log('success');4 }).catch(function(error) {5 console.log('error', error);6 });7

    8 /*******等同于*******/

    9 promise.then(function(data) {10 console.log('success');11 }).then(undefined, function(error) {12 console.log('error', error);13 });

    1 /*例3.4*/

    2 var promise = new Promise(function(resolve, reject) {3 throw new Error('test');4 });5 /*******等同于*******/

    6 var promise = new Promise(function(resolve, reject) {7 reject(new Error('test'));8 });9

    10 //用catch捕获

    11 promise.catch(function(error) {12 console.log(error);13 });14 -------output-------

    15 Error: test

    从上例可以看出,reject方法的作用,等同于抛错。

    promise对象的错误,会一直向后传递,直到被捕获。即错误总会被下一个catch所捕获。then方法指定的回调函数,若抛出错误,也会被下一个catch捕获。catch中也能抛错,则需要后面的catch来捕获。

    1 /*例3.5*/

    2 sendRequest('test.html').then(function(data1) {3 //do something

    4 }).then(function(data2) {5 //do something

    6 }).catch(function(error) {7 //处理前面三个Promise产生的错误

    8 });

    上文提到过,promise状态一旦改变就会凝固,不会再改变。因此promise一旦fulfilled了,再抛错,也不会变为rejected,就不会被catch了。

    1 /*例3.6*/

    2 var promise = new Promise(function(resolve, reject) {3 resolve();4 throw 'error';5 });6

    7 promise.catch(function(e) {8 console.log(e); //This is never called

    9 });

    如果没有使用catch方法指定处理错误的回调函数,Promise对象抛出的错误不会传递到外层代码,即不会有任何反应(Chrome会抛错),这是Promise的另一个缺点。

    1 /*例3.7*/

    2 var promise = new Promise(function(resolve, reject) {3 resolve(x);4 });5 promise.then(function(data) {6 console.log(data);7 });

    5b6385708a5dec5c0cde96f48504d3f7.png

    fd550365db8383f2394a71804b3e5d85.png

    d214a20f255057f5075d5713df6549e1.png

    如图所示,只有Chrome会抛错,且promise状态变为rejected,Firefox和Safari中错误不会被捕获,也不会传递到外层代码,最后没有任何输出,promise状态也变为rejected。

    .all()

    语法:Promise.all(iterable)

    该方法用于将多个Promise实例,包装成一个新的Promise实例。

    var p = Promise.all([p1, p2, p3]);

    Promise.all方法接受一个数组(或具有Iterator接口)作参数,数组中的对象(p1、p2、p3)均为promise实例(如果不是一个promise,该项会被用Promise.resolve转换为一个promise)。它的状态由这三个promise实例决定。

    当p1, p2, p3状态都变为fulfilled,p的状态才会变为fulfilled,并将三个promise返回的结果,按参数的顺序(而不是 resolved的顺序)存入数组,传给p的回调函数,如例3.8。

    当p1, p2, p3其中之一状态变为rejected,p的状态也会变为rejected,并把第一个被reject的promise的返回值,传给p的回调函数,如例3.9。

    1 /*例3.8*/

    2 var p1 = new Promise(function(resolve, reject) {3 setTimeout(resolve, 3000, "first");4 });5 var p2 = new Promise(function(resolve, reject) {6 resolve('second');7 });8 var p3 = new Promise((resolve, reject) =>{9 setTimeout(resolve, 1000, "third");10 });11

    12 Promise.all([p1, p2, p3]).then(function(values) {13 console.log(values);14 });15

    16 -------output-------

    17 //约 3s 后

    18 ["first", "second", "third"]

    1 /*例3.9*/

    2 var p1 = new Promise((resolve, reject) =>{3 setTimeout(resolve, 1000, "one");4 });5 var p2 = new Promise((resolve, reject) =>{6 setTimeout(reject, 2000, "two");7 });8 var p3 = new Promise((resolve, reject) =>{9 reject("three");10 });11

    12 Promise.all([p1, p2, p3]).then(function(value) {13 console.log('resolve', value);14 }, function(error) {15 console.log('reject', error); //=> reject three

    16 });17

    18 -------output-------

    19 reject three

    这多个 promise 是同时开始、并行执行的,而不是顺序执行。从下面例子可以看出。如果一个个执行,那至少需要 1+32+64+128

    1 /*例3.10*/

    2 functiontimerPromisefy(delay) {3 return new Promise(function(resolve) {4 setTimeout(function() {5 resolve(delay);6 }, delay);7 });8 }9 var startDate =Date.now();10

    11 Promise.all([12 timerPromisefy(1),13 timerPromisefy(32),14 timerPromisefy(64),15 timerPromisefy(128)16 ]).then(function(values) {17 console.log(Date.now() - startDate + 'ms');18 console.log(values);19 });20 -------output-------

    21 133ms //不一定,但大于128ms

    22 [1,32,64,128]

    .race()

    语法:Promise.race(iterable)

    该方法同样是将多个Promise实例,包装成一个新的Promise实例。

    var p = Promise.race([p1, p2, p3]);

    Promise.race方法同样接受一个数组(或具有Iterator接口)作参数。当p1, p2, p3中有一个实例的状态发生改变(变为fulfilled或rejected),p的状态就跟着改变。并把第一个改变状态的promise的返回值,传给p的回调函数。

    1 /*例3.11*/

    2 var p1 = new Promise(function(resolve, reject) {3 setTimeout(reject, 500, "one");4 });5 var p2 = new Promise(function(resolve, reject) {6 setTimeout(resolve, 100, "two");7 });8

    9 Promise.race([p1, p2]).then(function(value) {10 console.log('resolve', value);11 }, function(error) {12 //not called

    13 console.log('reject', error);14 });15 -------output-------

    16 resolve two17

    18 var p3 = new Promise(function(resolve, reject) {19 setTimeout(resolve, 500, "three");20 });21 var p4 = new Promise(function(resolve, reject) {22 setTimeout(reject, 100, "four");23 });24

    25 Promise.race([p3, p4]).then(function(value) {26 //not called

    27 console.log('resolve', value);28 }, function(error) {29 console.log('reject', error);30 });31 -------output-------

    32 reject four

    在第一个promise对象变为resolve后,并不会取消其他promise对象的执行,如下例

    1 /*例3.12*/

    2 var fastPromise = new Promise(function(resolve) {3 setTimeout(function() {4 console.log('fastPromise');5 resolve('resolve fastPromise');6 }, 100);7 });8 var slowPromise = new Promise(function(resolve) {9 setTimeout(function() {10 console.log('slowPromise');11 resolve('resolve slowPromise');12 }, 1000);13 });14 //第一个promise变为resolve后程序停止

    15 Promise.race([fastPromise, slowPromise]).then(function(value) {16 console.log(value); //=> resolve fastPromise

    17 });18 -------output-------

    19 fastPromise20 resolve fastPromise21 slowPromise //仍会执行

    .resolve()

    语法:

    Promise.resolve(value);

    Promise.resolve(promise);

    Promise.resolve(thenable);

    它可以看做new Promise()的快捷方式。

    1 Promise.resolve('Success');2

    3 /*******等同于*******/

    4 new Promise(function(resolve) {5 resolve('Success');6 });

    这段代码会让这个Promise对象立即进入resolved状态,并将结果success传递给then指定的onFulfilled回调函数。由于Promise.resolve()也是返回Promise对象,因此可以用.then()处理其返回值。

    /*例3.13*/Promise.resolve('success').then(function(value) {

    console.log(value);

    });-------output-------Success

    /*例3.14*/

    //Resolving an array

    Promise.resolve([1,2,3]).then(function(value) {

    console.log(value[0]); //=> 1

    });//Resolving a Promise

    var p1 = Promise.resolve('this is p1');var p2 =Promise.resolve(p1);

    p2.then(function(value) {

    console.log(value);//=> this is p1

    });

    Promise.resolve()的另一个作用就是将thenable对象(即带有then方法的对象)转换为promise对象。

    1 /*例3.15*/

    2 var p1 =Promise.resolve({3 then: function(resolve, reject) {4 resolve("this is an thenable object!");5 }6 });7 console.log(p1 instanceof Promise); //=> true

    8

    9 p1.then(function(value) {10 console.log(value); //=> this is an thenable object!

    11 }, function(e) {12 //not called

    13 });

    再看下面两个例子,无论是在什么时候抛异常,只要promise状态变成resolved或rejected,状态不会再改变,这和新建promise是一样的。

    1 /*例3.16*/

    2 //在回调函数前抛异常

    3 var p1 ={4 then: function(resolve) {5 throw new Error("error");6 resolve("Resolved");7 }8 };9

    10 var p2 =Promise.resolve(p1);11 p2.then(function(value) {12 //not called

    13 }, function(error) {14 console.log(error); //=> Error: error

    15 });16

    17 //在回调函数后抛异常

    18 var p3 ={19 then: function(resolve) {20 resolve("Resolved");21 throw new Error("error");22 }23 };24

    25 var p4 =Promise.resolve(p3);26 p4.then(function(value) {27 console.log(value); //=> Resolved

    28 }, function(error) {29 //not called

    30 });

    .reject()

    语法:Promise.reject(reason)

    这个方法和上述的Promise.resolve()类似,它也是new Promise()的快捷方式。

    1 Promise.reject(new Error('error'));2

    3 /*******等同于*******/

    4 new Promise(function(resolve, reject) {5 reject(new Error('error'));6 });

    这段代码会让这个Promise对象立即进入rejected状态,并将错误对象传递给then指定的onRejected回调函数。

    四 Promise常见问题

    经过上一章的学习,相信大家已经学会使用Promise。

    总结一下创建promise的流程:

    使用new Promise(fn)或者它的快捷方式Promise.resolve()、Promise.reject(),返回一个promise对象

    在fn中指定异步的处理

    处理结果正常,调用resolve

    处理结果错误,调用reject

    如果使用ES6的箭头函数,将会使写法更加简单清晰。

    这一章节,将会用例子的形式,以说明promise使用过程中的注意点及容易犯的错误。

    情景1:reject 和 catch 的区别

    promise.then(onFulfilled, onRejected)

    在onFulfilled中发生异常的话,在onRejected中是捕获不到这个异常的。

    promise.then(onFulfilled).catch(onRejected)

    .then中产生的异常能在.catch中捕获

    一般情况,还是建议使用第二种,因为能捕获之前的所有异常。当然了,第二种的.catch()也可以使用.then()表示,它们本质上是没有区别的,.catch === .then(null, onRejected)

    情景2:如果在then中抛错,而没有对错误进行处理(即catch),那么会一直保持reject状态,直到catch了错误

    1 /*例4.1*/

    2 functiontaskA() {3 console.log(x);4 console.log("Task A");5 }6 functiontaskB() {7 console.log("Task B");8 }9 functiononRejected(error) {10 console.log("Catch Error: A or B", error);11 }12 functionfinalTask() {13 console.log("Final Task");14 }15 var promise =Promise.resolve();16 promise17 .then(taskA)18 .then(taskB)19 .catch(onRejected)20 .then(finalTask);21

    22 -------output-------

    23 Catch Error: A or B,ReferenceError: x is not defined24 Final Task

    65d411538b709ff07add74da5374f2fc.png

    根据例4.1的输出结果及流程图,可以看出,A抛错时,会按照 taskA → onRejected → finalTask这个流程来处理。A抛错后,若没有对它进行处理,如例3.7,状态就会维持rejected,taskB不会执行,直到catch了错误。

    1 /*例4.2*/

    2 functiontaskA() {3 console.log(x);4 console.log("Task A");5 }6 functiontaskB() {7 console.log("Task B");8 }9 functiononRejectedA(error) {10 console.log("Catch Error: A", error);11 }12 functiononRejectedB(error) {13 console.log("Catch Error: B", error);14 }15 functionfinalTask() {16 console.log("Final Task");17 }18 var promise =Promise.resolve();19 promise20 .then(taskA)21 .catch(onRejectedA)22 .then(taskB)23 .catch(onRejectedB)24 .then(finalTask);25

    26 -------output-------

    27 Catch Error: A ReferenceError: x is not defined28 Task B29 Final Task

    将例4.2与4.1对比,在taskA后多了对A的处理,因此,A抛错时,会按照A会按照 taskA → onRejectedA → taskB → finalTask这个流程来处理,此时taskB是正常执行的。

    情景3:每次调用then都会返回一个新创建的promise对象,而then内部只是返回的数据

    1 /*例4.3*/

    2 //方法1:对同一个promise对象同时调用 then 方法

    3 var p1 = new Promise(function(resolve) {4 resolve(100);5 });6 p1.then(function(value) {7 return value * 2;8 });9 p1.then(function(value) {10 return value * 2;11 });12 p1.then(function(value) {13 console.log("finally: " +value);14 });15 -------output-------

    16 finally: 100

    17

    18 //方法2:对 then 进行 promise chain 方式进行调用

    19 var p2 = new Promise(function(resolve) {20 resolve(100);21 });22 p2.then(function(value) {23 return value * 2;24 }).then(function(value) {25 return value * 2;26 }).then(function(value) {27 console.log("finally: " +value);28 });29 -------output-------

    30 finally: 400

    第一种方法中,then的调用几乎是同时开始执行的,且传给每个then的value都是100,这种方法应当避免。方法二才是正确的链式调用。

    因此容易出现下面的错误写法:

    1 /*例4.4*/

    2 functionbadAsyncCall(data) {3 var promise =Promise.resolve(data);4 promise.then(function(value) {5 //do something

    6 return value + 1;7 });8 returnpromise;9 }10 badAsyncCall(10).then(function(value) {11 console.log(value); //想要得到11,实际输出10

    12 });13 -------output-------

    14 10

    正确的写法应该是:

    1 /*改写例4.4*/

    2 functiongoodAsyncCall(data) {3 var promise =Promise.resolve(data);4 return promise.then(function(value) {5 //do something

    6 return value + 1;7 });8 }9 goodAsyncCall(10).then(function(value) {10 console.log(value);11 });12 -------output-------

    13 11

    情景4:在异步回调中抛错,不会被catch到

    1 //Errors thrown inside asynchronous functions will act like uncaught errors

    2 var promise = new Promise(function(resolve, reject) {3 setTimeout(function() {4 throw 'Uncaught Exception!';5 }, 1000);6 });7

    8 promise.catch(function(e) {9 console.log(e); //This is never called

    10 });

    情景5: promise状态变为resove或reject,就凝固了,不会再改变

    console.log(1);new Promise(function(resolve, reject){

    reject();

    setTimeout(function(){

    resolve();//not called

    }, 0);

    }).then(function(){

    console.log(2);

    },function(){

    console.log(3);

    });

    console.log(4);-------output-------

    1

    4

    3

    五 结语

    关于promise就先介绍到这边了,比较基础,有不足的地方欢迎指出,有更好的也欢迎补充~

    展开全文
  • 下面分成三个部分讲解used to 的用法,让你彻底理解掌握。1. used to 单独做谓语动词表示过去经常,为谓语动词——一般过去时态(常态)示例如下:He used to go to our school. 他曾在我们学校就读。We used to ...

    6235d751f5081787e7b083a87bad6b9d.png

    下面分成三个部分讲解used to 的用法,让你彻底理解掌握。

    1.

    used to 单独做谓语动词表示过去经常,为谓语动词——一般过去时态(常态)

    示例如下:

    He used to go to our school.

    他曾在我们学校就读。

    We used to sashay after supper.

    过去我们总是在晚饭后去散步。

    I used to get up early in the morning.

    我过去通常起到很早。

    2.

    used to 是形容词,而不是谓语动词,真正的谓语动词为Be动词, 如:

    am/is/are used to 现在习惯于

    was/were used to 过去习惯于

    will/would be used to 将习惯于

    示例:

    I am used to the hot weather.

    我习惯于热天气

    She is used to living in the country.

    她习惯于住在乡下。

    She was used to living a hard life.

    她习惯于做艰苦的工作了。

    She will be used to getting up early.

    她将会习惯于早起。

    句子中已经有了谓语动词be,且used to 这里已经不是动词,所以to无需当成动词不定式符号了,所以to 后面可以接名词或者接动词ing形式。

    注:如果把be used to理解成被动的话,也是成立的,则以上示例中的used to都是被动时态的主动词。

    3.

    used to 作为被动,意思为被用来

    A data queue object is used to send data from one program to another.

    一个数据队列对象用于将数据从一个程序发送到另一个程序。

    Some bread, cheese, carrot slices and pickled gherkin were used to create this locomotive.

    这个火车头是用面包、奶酪、胡萝卜片、腌嫩黄瓜做的。

    英语思维:《英语思维:解密英语语法的原理》电子版“结构最清晰、框架最完整、逻辑最严密、高度系统完善”的语法教程

    英语思维:《英语思维:解密英语语法的原理》图书及《英语思维:10课建立完美语法体系》视频课程学习点评

    展开全文
  •  本次设计是一校园二手交易平台(C2C),C2C指个人与个人之间电子商务,买家可以查看所有卖家发布商品,并且根据分类进行商品过滤,也可以根据站内搜索引擎进行商品查询,并且与卖家联系,达成交易意向...
  • ES6之Promise用法详解

    2019-02-18 22:54:00
    要想学习一个知识点,肯定是从三个方面出发,what、why、how。下面就跟着我一步步学习吧~ 二 什么是Promise 首先是what。那么什么是Promise呢?以下是MDN对Promise定义 The Promise object is used for ...
  • 在使用Android图片加载框架时,经常会提到级缓存,其中主要是内存缓存和文件缓存。 两缓存都是用到了LruCache算法,在Android分别对应:LruCache和DiskLruCache。 LRU算法 操作系统中进行内存管理中时采用一些...
  • <div><p>3.2.1: <p>When Western texts are ...三点省略号指三个 U+002E 还是一个没有被 locl 提升到文字中间那么高西文风格 U+2026?</p><p>该提问来源于开源项目:w3c/clreq</p></div>
  • 这是一包含多有用函数库,我发现我多次使用它。 通过将它们放入单独文件中,很容易仅包含所需那些模块 目前有套功能 KSP_Log一组简单日志记录方法 KSP_ColorPicker提供供mod使用颜色选择器。 带有5...
  • ◆ 有时候STL算法并不好用,经常是为了第三个参数需要自己写一个专用琐碎小函数。 虽然可以用stdbind或者boostlambda,但是对于某些嵌套情况,用起来非常麻烦,这个库提供了下面一些解决方式: ...
  • destoon系统中get&lowbar;maincat的用法及解释get_maincat函数... 第一个参数代表parentid 第二个参数代表所有分类 第三个参数 代表 ...oracle-表空间满了一.查看 "sum MB", (a.bytes "used MB",b.bytes "fre...
  • LINGO软件学习

    2009-08-08 22:36:50
    LINGO生成了三个父集所有组合共八组作为allowed集成员。列表如下: 编号 成员 1 (A,M,1) 2 (A,M,2) 3 (A,N,1) 4 (A,N,2) 5 (B,M,1) 6 (B,M,2) 7 (B,N,1) 8 (B,N,2) 成员列表被忽略时,派生集成员由父集...
  •  2 a / an 的用法  3 a / an 省略  4 a / an 和 one  5 a little / a few 和 little / few  6 the (定冠词)  7 the (定冠词)省略  8 the (定冠词)在 home 等之前省略  9 this / ...
  • SQL基础知识(二)

    2016-08-18 15:44:00
    、基本语法今天记录 SQL Select, Distinct, Where, And & Or, Order by, Insert Into, Update, Delete, Injection, Select Top 这十关键字或者命令的用法和解释。1、Select The SELECT statement is used to ...
  • Java-PHP-C#

    2012-11-27 15:13:36
    ' 分别和一下三个范围标注是一样,"{0,}", "{1,}", 和 "{0,1}"。 现在把一定数量字符放到小括号里,比如: "a(bc)*": 匹配 a 后面跟0个或者一个"bc"; "a(bc){1,5}": 一个到5个 "bc." 还有一个字符 '│'...
  • C++MFC教程

    热门讨论 2013-05-21 13:37:15
    下面伪代码演示了消息循环的用法: while(1) { id=getMessage(...); if(id == quit) break; translateMessage(...); } 当该程序没有消息通知时getMessage就不会返回,也就不会占用系统CPU时间。 下图为...
  • 支持有碎片文件仿真,最多 8 片段。占用 11Kb - 13Kb 内存(由是否加载光驱确定)。 3.支持 WinXP 系统短文件名小写。根据短文件名偏移 0x0c 处:位 3=1 表示文件名小写,位 4=1 表示文件扩展名小写。 4....
  • 2009 达内Unix学习笔记

    2010-02-10 19:45:32
    第5~7是属组,系统管理员分配同组或几个人,用g表示 第8~10是其他人,除属组外人,用o表示 所有人,包括属主、属组及其他人,用a表示 chmod 更改权限; 用法 chmod [-fR] <绝对模式> 文件 ... ...
  • 具体分为三个阶段:静态代理,动态代理,还有CGLIB代理。 以动态代理来说,测试动态代理加强类时,创建main方法直接测试即可: /** * 测试 * @param args */ public static void main(String[] args) { ...
  • java面试宝典

    2013-02-28 16:04:01
    21、当一对象被当作参数传递到一方法后,此方法可改变这对象属性,并可返回变化后结果,那么这里到底是值传递还是引用传递? 10 22、我们在web 应用开发过程中经常遇到输出某种编码字符,如iso8859-1等,...
  • 千方百计笔试题大全

    2011-11-30 21:58:33
    21、当一对象被当作参数传递到一方法后,此方法可改变这对象属性,并可返回变化后结果,那么这里到底是值传递还是引用传递? 10 22、我们在web 应用开发过程中经常遇到输出某种编码字符,如iso8859-1等,...
  • detour 2.1

    热门讨论 2010-07-16 17:36:41
    ---- Detours定义了三个概念: ---- (1) Target函数:要拦截函数,通常为WindowsAPI。 ---- (2) Trampoline函数:Target函数复制品。因为Detours将会改写Target函数,所以先把Target函数复制保存好,一方面...
  • jQuery完全实例.rar

    2011-06-16 12:48:41
    函数最基本的用法就是向它传递一表达式(通常由 CSS 选择器组成),然后根据这表达式来查找所有匹配元素。 默认情况下, 如果没有指定context参数,$()将在当前 HTML 文档中查找 DOM 元素;如果指定了 ...
  • jieba.cut 以及 jieba.cut_for_search 返回结构都是一可迭代 generator,可以使用 for 循环来获得分词后得到每一词语(unicode),或者用 jieba.lcut 以及 jieba.lcut_for_search 直接返回 list jieba....
  • 功能很强,可以对第方App进行测试,获取屏幕上任意一APP任意一控件属性,并对其进行任意操作,但有两缺点:1. 测试脚本只能使用Java语言 2. 测试脚本要打包成jar或者apk包上传到设备上才能运行。 我们希望...
  • 用法: Jieba::loadUserDict(file_name) # file_name 為自定義詞典絕對路徑 詞典格式和 dict.txt 一樣,一詞佔一行;每一行分為部分,一部分為詞語,一部分為詞頻,一部分為詞性,用空格隔開 範例: ...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

used的三个用法