如果您对JavaScript中的Deferred，Promise和Future之间有什么区别？感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于JavaScript中的Defe
如果您对JavaScript中的Deferred，Promise和Future之间有什么区别？感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于JavaScript中的Deferred，Promise和Future之间有什么区别？的详细内容，我们还将为您解答promise和future的关系的相关问题，并且为您提供关于Java 9中CompletableFuture和Future之间的区别是什么？、Java 中的 public，protected，package-private 和 private 之间有什么区别？、JavaScript promises和async await有什么区别？、JavaScript promise和async await有什么区别？的有价值信息。
本文目录一览：- JavaScript中的Deferred，Promise和Future之间有什么区别？（promise和future的关系）
- Java 9中CompletableFuture和Future之间的区别是什么？
- Java 中的 public，protected，package-private 和 private 之间有什么区别？
- JavaScript promises和async await有什么区别？
- JavaScript promise和async await有什么区别？
JavaScript中的Deferred，Promise和Future之间有什么区别？（promise和future的关系）
Deferred，Promise和Future之间有什么区别？
这三者之间是否有公认的理论？
答案1
小编典典考虑到我对尝试回答OP的问题的明显不满。字面上的答案是，诺言是与其他对象共享的东西，而延期则应保持私有。首先，延期（通常扩展为Promise）可以解决自己，而Promise可能无法解决。
如果您对细节有兴趣，请检查Promises / A +。
据我所知，总体目的是提高清晰度，并通过标准化接口放松耦合：
使用promise而不是直接将回调传递给函数（可以导致接口紧密耦合），而是使用promise可以将对同步或异步代码的关注分开。
就个人而言，我发现在处理例如由异步请求填充的模板，加载具有依赖性网络的脚本以及以非阻塞方式提供用户反馈以形成数据时，推迟特别有用。
确实，比较以异步方式在JS模式下加载CodeMirror后做某事的纯回调形式（抱歉，我已经有一段 时间 没有使用jQuery了）：
/* assume getScript has signature like: function (path, callback, context) and listens to onload && onreadystatechange */$(function () { getScript(''path/to/CodeMirror'', getJSMode); // onreadystate is not reliable for callback args. function getJSMode() { getScript(''path/to/CodeMirror/mode/javascript/javascript.js'', ourAwesomeScript); }; function ourAwesomeScript() { console.log("CodeMirror is awesome, but I''m too impatient."); };});对于promise制定的版本（再次抱歉，我在jQuery上不是最新的）：
/* Assume getScript returns a promise object */$(function () { $.when( getScript(''path/to/CodeMirror''), getScript(''path/to/CodeMirror/mode/javascript/javascript.js'') ).then(function () { console.log("CodeMirror is awesome, but I''m too impatient."); });});对半伪代码表示歉意，但我希望它可以使核心思想更加清晰。基本上，通过返回标准化的承诺，您可以传递承诺，从而可以进行更清晰的分组。
Java 9中CompletableFuture和Future之间的区别是什么？
completablefuture
语法
<strong>public class CompletableFuture<T> extends Object implements Future<T>, CompletionStage<T></strong>
Example
翻译成中文为：示例
import java.util.function.Supplier;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class CompletableFutureTest {
public static void main(String args[]) throws ExecutionException, InterruptedException {
Calculator calc = new Calculator(4, 7);
<strong>CompletableFuture<Integer></strong> future = CompletableFuture.<strong>supplyAsync</strong>(calc);
future.<strong>thenAccept</strong>(result -> {
System.out.println(result);
});
System.out.println("CompletableFutureTest End.... ");
Thread.sleep(10000);
}
}
<strong>// Calculator class</strong>
class Calculator implements <strong>Supplier<Integer></strong> {
private int x, y;
public Calculator(int x, int y) {
this.x = x;
this.y = y;
}
<strong>@Override</strong>
public Integer get() {
try {
Thread.sleep(3000);
} catch(InterruptedException e) {
e.printStackTrace();
}
return x + y;
}
}输出
<strong>CompletableFutureTest End.... 11</strong>
以上就是Java 9中CompletableFuture和Future之间的区别是什么？的详细内容，更多请关注php中文网其它相关文章！
Java 中的 public，protected，package-private 和 private 之间有什么区别？
在 Java 中，关于何时使用每个访问修饰符（即默认（程序包私有）， public ， protected 和 private ）的明确规则，同时使 class 和 interface 以及继承都可以使用？
#1 楼
它实际上比简单的网格显示要复杂一些。 网格会告诉您是否允许访问，但是究竟是什么构成访问？ 此外，访问级别以复杂的方式与嵌套类和继承进行交互。
“默认” 访问权限（由缺少关键字指定）也称为 package-private 。 例外：在接口中，没有修饰符表示公共访问； 禁止使用除 public 之外的修饰符。 枚举常量始终是公共的。
摘要
是否允许使用此访问说明符访问成员？
- 成员是
private：仅当成员与调用代码在同一类中定义时。 - 成员是包私有的：仅当调用代码在成员的紧随其后的包中时。
- 成员
protected：同一包，或者如果成员在包含调用代码的类的超类中定义，则为protected成员。 - 成员是
public：是的。
什么是访问说明符
局部变量和形式参数不能使用访问说明符。 由于根据范围规则，它们本质上是外部无法访问的，因此它们实际上是私有的。
对于顶级范围的类，仅允许使用 public 和 package-private。 这种设计选择大概是因为 protected 和 private 在程序包级别是多余的（没有程序包的继承）。
所有访问说明符都可用于类成员（构造函数，方法和静态成员函数，嵌套类）。
相关： Java 类可访问性
订购
访问说明符可以严格订购
公共 > 受保护 > 包私有 > 私有
意味着 public 提供最多的访问权限， private 提供最少的访问权限。 对于包私有成员，任何对私有成员的引用都有效。 对包专用成员的任何引用在受保护成员上均有效，依此类推。 （在同一软件包中将受保护的成员授予其他类的访问权限被认为是错误的。）
笔记
- 类的方法可以访问同一类的其他对象的私有成员。 更准确地说，类 C 的方法可以访问 C 的任何子类的对象上 C 的私有成员。Java 不支持仅按类限制实例的访问。 （与 Scala 比较，后者确实使用
private[this]支持它。） - 您需要访问构造函数才能构造对象。 因此，如果所有构造函数都是私有的，则只能通过该类中的代码（通常是静态工厂方法或静态变量初始化器）来构造该类。 对于包私有或受保护的构造函数也是如此。
- 仅具有私有构造函数也意味着该类不能在外部进行子类化，因为 Java 要求子类的构造函数隐式或显式调用超类构造函数。 （但是，它可以包含一个嵌套的类来对其进行子类化。）
内部班
您还必须考虑嵌套作用域，例如内部类。 复杂性的一个示例是内部类具有成员，这些成员本身可以使用访问修饰符。 因此，您可以与公共成员一起拥有私人内部类； 可以访问该成员吗？ （请参见下文。）一般规则是查看范围并进行递归思考，以查看是否可以访问每个级别。
但是，这非常复杂，有关详细信息， 请查阅 Java Language Specification 。 （是的，过去有编译器错误。）
要了解这些交互的方式，请考虑以下示例。 可以 “泄漏” 私有内部类； 这通常是警告：
class Test {
public static void main(final String ... args) {
System.out.println(Example.leakPrivateClass()); // OK
Example.leakPrivateClass().secretMethod(); // error
}
}
class Example {
private static class NestedClass {
public void secretMethod() {
System.out.println("Hello");
}
}
public static NestedClass leakPrivateClass() {
return new NestedClass();
}
}
编译器输出：
Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
Example.leakPrivateClass().secretMethod(); // error
^
1 error
一些相关的问题：
- Java - 包私有类内部的方法可访问性？
#2 楼
在很短的时间内
-
public：从任何地方均可访问。 -
protected：可以由同一软件包的类以及任何软件包中的子类访问。 - 默认值（未指定修饰符）：同一包的类可以访问。
-
private：只能在同一个类中访问。
#3 楼
根据经验：
-
private：类范围。 -
default（或package-private）：包范围。 -
protected：package scope + child（类似于包，但是我们可以从不同的包中将其子类化）。 protected 修饰符始终保持 “父子” 关系。 -
public：无处不在。
结果，如果我们将访问权限分为三个权限：
- （D）irect （从相同类内的方法调用，或通过 “this” 语法调用）。
- （R）引用（使用对类的引用或通过 “点” 语法调用方法）。
- （I）继承 （通过子类化）。
那么我们有这个简单的表：
+—-———————————————+————————————+———————————+
| | Same | Different |
| | Package | Packages |
+—————————————————+————————————+———————————+
| private | D | |
+—————————————————+————————————+———————————+
| package-private | | |
| (no modifier) | D R I | |
+—————————————————+————————————+———————————+
| protected | D R I | I |
+—————————————————+————————————+———————————+
| public | D R I | R I |
+—————————————————+————————————+———————————+
#4 楼
| highest precedence <---------> lowest precedence
*———————————————+———————————————+———————————+———————————————+———————
\ xCanBeSeenBy | this | any class | this subclass | any
\__________ | class | in same | in another | class
\ | nonsubbed | package | package |
Modifier of x \ | | | |
————————————————*———————————————+———————————+———————————————+———————
public | ✔ | ✔ | ✔ | ✔
————————————————+———————————————+———————————+———————————————+———————
protected | ✔ | ✔ | ✔ | ✘
————————————————+———————————————+———————————+———————————————+———————
package-private | | | |
(no modifier) | ✔ | ✔ | ✘ | ✘
————————————————+———————————————+———————————+———————————————+———————
private | ✔ | ✘ | ✘ | ✘
____________________________________________________________________
#5 楼
Java 中最容易理解的访问修饰符 protected 。 我们知道它类似于默认修饰符，但有一个例外，子类可以看到它。 但是如何？ 这是一个示例，希望可以澄清这种混淆：
假设我们有 2 个班级；
Father和Son，每个人都有自己的包装：package fatherpackage; public class Father { } ------------------------------------------- package sonpackage; public class Son extends Father { }让我们向
Father添加一个受保护的方法foo()。package fatherpackage; public class Father { protected void foo(){} }可以在 4 个上下文中调用
foo()方法：在一个类中，该类位于定义
foo()的同一包中（fatherpackage）：package fatherpackage; public class SomeClass { public void someMethod(Father f, Son s) { f.foo(); s.foo(); } }在子类内部，通过
this或super在当前实例上：package sonpackage; public class Son extends Father { public void sonMethod() { this.foo(); super.foo(); } }在类型相同的引用上：
package fatherpackage; public class Father { public void fatherMethod(Father f) { f.foo(); // valid even if foo() is private } } ------------------------------------------- package sonpackage; public class Son extends Father { public void sonMethod(Son s) { s.foo(); } }上的参考，其类型是父类，它是里面 ，其中包装
foo()被定义（fatherpackage）[这可以没有包括上下文内。 1]：package fatherpackage; public class Son extends Father { public void sonMethod(Father f) { f.foo(); } }
以下情况无效。
在类型为父类且位于定义
foo()的包之外的引用（fatherpackage）上：package sonpackage; public class Son extends Father { public void sonMethod(Father f) { f.foo(); // compilation error } }子类包中的非子类（子类从其父类继承受保护的成员，并使它们对非子类私有）：
package sonpackage; public class SomeClass { public void someMethod(Son s) throws Exception { s.foo(); // compilation error } }
JavaScript promises和async await有什么区别？
我已经在移动应用程序和Web应用程序中使用了ECMAScript
6和ECMAScript 7功能（由于Babel）。
第一步显然是达到ECMAScript
6级别。我学习了许多异步模式，promise（确实是很有希望的），生成器（不确定为什么使用*符号）等。其中，promise非常适合我的目的。而且我已经在我的应用程序中使用它们很多次了。
这是我如何实现基本诺言的示例/伪代码-
var myPromise = new Promise( function (resolve,reject) { var x = MyDataStore(myObj); resolve(x); });myPromise.then( function (x) { init(x);});随着时间的流逝，我遇到了ECMAScript
7功能，其中之一是ASYNC和AWAIT关键字/功能。这些结合在一起创造了很大的奇迹。我已经开始用代替我的一些诺言async &await。它们似乎为编程风格增加了巨大的价值。
同样，这是我的async，await函数的伪代码，如下所示：
async function myAsyncFunction (myObj) { var x = new MyDataStore(myObj); return await x.init();}var returnVal = await myAsyncFunction(obj);撇开语法错误（如果有的话），我感觉都是一样。我几乎可以用异步唤醒来代替我的大部分诺言。
为什么诺言做类似的工作时需要异步等待？
异步等待解决更大的问题吗？还是只是针对回调地狱的另一种解决方案？
如前所述，我能够使用promise和async，等待解决相同的问题。异步等待解决了什么具体问题？
补充笔记：
我已经在我的React项目和Node.js模块中广泛使用异步，唤醒和承诺。React特别是早起的鸟儿，并采用了许多ECMAScript
6和ECMAScript 7功能。
答案1
小编典典为什么Promises做类似的工作时需要异步等待？异步等待解决更大的问题吗？
async/await只是给您异步代码的同步感觉。这是一种非常优雅的语法糖。
对于简单的查询和数据操作，Promises可能很简单，但是如果您遇到了复杂的数据操作和不涉及任何内容的场景，那么如果代码 看起来
好像是同步的，则更容易理解正在发生的情况（换句话说，语法本身就是一种“偶然的复杂性”，async/await可以绕开。
如果您想知道，可以使用类似co（与生成器一起）的库来提供相同的感觉。已经开发了类似的方法来解决async/await最终解决的问题（本机）。
JavaScript promise和async await有什么区别？
我已经在移动应用程序和Web应用程序中使用过ECMAScript
6和ECMAScript 7功能（由于Babel）。
第一步显然是达到ECMAScript
6级别。我学习了许多异步模式，promise（确实是很有希望的），生成器（不确定为什么使用*符号）等。其中，promise非常适合我的目的。而且我已经在我的应用程序中使用它们很多次了。
这是我如何实现基本诺言的示例/伪代码-
var myPromise = new Promise(
function (resolve,reject) {
var x = MyDataStore(myObj);
resolve(x);
});
myPromise.then(
function (x) {
init(x);
});
随着时间的流逝，我遇到了ECMAScript
7功能，其中之一是ASYNC和AWAIT关键字/功能。这些结合在一起创造了很大的奇迹。我已经开始用代替我的一些诺言async &
await。它们似乎为编程风格增加了巨大的价值。
同样，这是我的async，await函数的伪代码，如下所示：
async function myAsyncFunction (myObj) {
var x = new MyDataStore(myObj);
return await x.init();
}
var returnVal = await myAsyncFunction(obj);
撇开语法错误（如果有的话），他们俩做的事情完全一样，这就是我的感受。我几乎可以用异步替换掉我的大部分诺言。
为什么诺言做类似的工作时需要异步等待？
异步等待解决更大的问题吗？还是只是针对回调地狱的另一种解决方案？
如前所述，我能够使用promise和async，等待解决相同的问题。异步等待解决了什么具体问题？
补充笔记：
我已经在我的React项目和Node.js模块中广泛使用异步，唤醒和承诺。React特别是早起的鸟儿，并采用了许多ECMAScript
6和ECMAScript 7功能。
关于JavaScript中的Deferred，Promise和Future之间有什么区别？和promise和future的关系的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Java 9中CompletableFuture和Future之间的区别是什么？、Java 中的 public，protected，package-private 和 private 之间有什么区别？、JavaScript promises和async await有什么区别？、JavaScript promise和async await有什么区别？等相关内容，可以在本站寻找。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
