如果您对等待Promise.all和和多次等待之间有什么区别？感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解等待Promise.all的各种细节，并对和多次等待之间有什么区别？进行深入的分析，

如果您对等待 Promise.all和和多次等待之间有什么区别？感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解等待 Promise.all的各种细节，并对和多次等待之间有什么区别？进行深入的分析，此外还有关于ArrayList.clear（）和ArrayList.removeAll（）有什么区别？、bool（）和operator.truth（）之间有什么区别？、globals（），locals（）和vars（）之间有什么区别？、Java 8中的map（）和flatMap（）方法之间有什么区别？的实用技巧。

• 等待 Promise.all（）和多次等待之间有什么区别？（等待多时是什么意思）
• ArrayList.clear（）和ArrayList.removeAll（）有什么区别？
• bool（）和operator.truth（）之间有什么区别？
• globals（），locals（）和vars（）之间有什么区别？
• Java 8中的map（）和flatMap（）方法之间有什么区别？

等待 Promise.all（）和多次等待之间有什么区别？（等待多时是什么意思）

之间有什么区别：

const [result1, result2] = await Promise.all([task1(), task2()]);

和

const t1 = task1();const t2 = task2();const result1 = await t1;const result2 = await t2;

和

const [t1, t2] = [task1(), task2()];const [result1, result2] = [await t1, await t2];

答案1

注意事项：

这个答案仅涵盖了await系列和系列之间的时序差异Promise.all。请务必阅读@mikep的综合答案，其中也涵盖了错误处理方面更重要的区别。

出于此答案的目的，我将使用一些示例方法：

res(ms) 是一个函数，它需要一个整数毫秒，并返回一个承诺，该承诺将在该毫秒后解析。
rej(ms) 是一个函数，它需要一个整数毫秒，并返回一个承诺，该承诺将在该毫秒后被拒绝。
调用会res启动计时器。Promise.all在所有延迟完成后，可以使用等待一些延迟来解决，但请记住它们是同时执行的：

例子1

const data = await Promise.all([res(3000), res(2000), res(1000)])//                              ^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^//                               delay 1    delay 2    delay 3//// ms ------1---------2---------3// =============================O delay 1// ===================O           delay 2// =========O                     delay 3//// =============================O Promise.all

这意味着Promise.all将在3秒后使用内部承诺中的数据进行解析。

但是，Promise.all具有“快速失败”的行为：

范例＃2

const data = await Promise.all([res(3000), res(2000), rej(1000)])//                              ^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^//                               delay 1    delay 2    delay 3//// ms ------1---------2---------3// =============================O delay 1// ===================O           delay 2// =========X                     delay 3//// =========X                     Promise.all

如果async-await改为使用，则必须等待每个promise依次解决，这可能没有那么有效：

例子＃3

const delay1 = res(3000)const delay2 = res(2000)const delay3 = rej(1000)const data1 = await delay1const data2 = await delay2const data3 = await delay3// ms ------1---------2---------3// =============================O delay 1// ===================O           delay 2// =========X                     delay 3//// =============================X await

ArrayList.clear（）和ArrayList.removeAll（）有什么区别？

bool（）和operator.truth（）之间有什么区别？

bool()和operator.truth()两个测试值是否
truthy 或 falsy ，他们似乎从文档颇为相似，它甚至说，在truth()文档是：

这等效于使用bool构造函数。

但是，truth()速度bool()是简单测试的两倍（显示了Python 3.6的计时，但2.7相似）：

from timeit import timeitprint(timeit(''bool(1)'', number=10000000))# 2.180289956042543print(timeit(''truth(1)'', setup=''from operator import truth'', number=10000000))# 0.7202018899843097

那有什么区别呢？我应该使用truth()代替bool()吗？

答案1

虽然bool()并operator.truth() 输出 为主要用途的情况下相同的结果他们的 实现
实际上是相当不同的。bool()是一个类或类型的构造函数，同时truth()是一个狭窄的优化正则函数。

实际上，还有两个区别：1）bool()在不带参数的情况下调用returns
Falsewhiletruth()需要一个参数。2）bool()接受x关键字参数，例如bool(x=1)，而truth()没有关键字参数。bool()对于常规用例，这两者都会增加开销。

关键字的实现很奇怪，因为可能没有人需要它，而且名称x几乎没有描述性。Issue29695涵盖了这一点，实际上，该问题不仅影响到bool()其他类，例如int()或list()。但是，从Python
3.7开始，这些关键字参数将被删除，并且速度应会提高。尽管如此，我还是在最新的Python
3.8分支上测试了时序，并且bool()比以前更快，但仍比以前快两倍truth()，这可能是由于的实现更为通用bool()。

因此，如果您的任务非常重视速度，那么我建议您在需要函数的情况下使用truth()over
bool()（例如，解析为的键sorted()）。但是，正如khelwood所指出的那样，bool()有时还是会更快filter(bool,iterable)，所以最好将您的用例确定为最佳选择。

当然，如果您不需要功能，而只想测试值是 真 还是 假 ，则应使用惯用语if或ifnot语句，如khelwood和ser2357112所评论的那样，这是最快的。

globals（），locals（）和vars（）之间有什么区别？

import inspect

def f():
    x = 1
    l = locals()
    print(l)
    locals()
    print(l)
    x = 2
    print(x, l[''x''])
    l[''x''] = 3
    print(x, l[''x''])
    inspect.currentframe().f_locals
    print(x, l[''x''])

f()

{''x'': 1}
{''x'': 1, ''l'': {...}}
2 1
2 3
2 2

class Test(object):
    a = ''one''
    b = ''two''
    huh = locals()
    c = ''three''
    huh[''d''] = ''four''
    print huh

{
  ''a'': ''one'',
  ''b'': ''two'',
  ''c'': ''three'',
  ''d'': ''four'',
  ''huh'': {...},
  ''__module__'': ''__main__'',
}

class Test(object):
    a = ''one''
    b = ''two''
    def frobber(self):
        print self.c
t = test()
huh = vars(t)
huh[''c''] = ''three''
t.frobber()

three

def f(outer):
    if outer:
        f(False)
        print(''Outer call locals:'', locals())
        print(''f.__dict__:'', f.__dict__)
    else:
        print(''Inner call locals:'', locals())
        print(''f.__dict__:'', f.__dict__)

f.x = 3

f(True)

Inner call locals: {''outer'': False}
f.__dict__: {''x'': 3}
Outer call locals: {''outer'': True}
f.__dict__: {''x'': 3}