// warning "==" behaves like JavaScript "===" at runtime int i = 2; assert i == 2; double d = i + 4; assert d == 6; String s = "string" + "0" + i; assert s == "string02"; boolean b = false; assert !b; 该==运营商的行为类似于JavaScript的严格等于运算符 ===，使其接近Java语义。同样，!=映射到!==。在将对象与null文字进行比较时，该行为有一个例外。在这种情况下，JSweet转换为松散的相等运算符，以便程序员看不到null和之间的区别undefined（这在JavaScript中是不同的，但它可能会让Java程序员感到困惑）。要控制JSweet是否生成严格或松散的运算符，可以使用以下辅助方法：jsweet.util.Lang.$strict和 jsweet.util.Lang.$loose。在这样的宏中包装比较运算符将强制JSweet生成严格或松散的运算符。例如：
import static jsweet.util.Lang.$loose; [...] int i = 2; assert i == 2; // generates i === 2 assert !((Object)"2" == i); assert $loose((Object)"2" == i); // generates "2" == i 允许的Java对象 默认情况下，JSweet通过使用内置宏将核心Java对象和方法映射到JavaScript。这意味着Java代码直接替换为实现类似行为的有效JavaScript代码。为大多数有用的核心Java类（java.lang，java.util）实现了默认映射。在可能的情况下（当它有意义时），为其他JDK类实现一些部分映射，例如输入和输出流，区域设置，日历，反射等。
import static jsweet.util.Lang.string; // str is a Java string, but is actually a JavaScript string at runtime String str = "This is a test string"; // str is exactly the same string object, but shown through the JS API def.js.String str2 = string(str); // valid: toLowerCase it defined both in Java and JavaScript str.toLowerCase(); // this method is not JS-compatible, so a macro generates the JS code str.equalsIgnoreCase("abc"); // direct call to the JS substr method on the JavaScript string string(str).substr(1); // or str2.substr(1); 注意：例如，对于JavaScript客户端和Java服务器之间的代码共享，最好只使用Java API并避免使用JavaScript API。JavaScript API将编译有效的Java字节码，但尝试在JVM上执行它们会引起不满意的链接错误。
// inner class
public class InnerClass {
public I aMethod(final int i) {
// anonymous class
return new C() {
@Override
public int m() {
// access to final variable i
return i;
}
}
}
}
public double x;
public double y;
@Optional
public double z = 0;
} 在从接口构造对象时，JSweet编译器将检查字段是否已正确初始化。
// no errors (z is optional) Point p1 = new Point() {{ x=1; y=1; }}; // JSweet reports a compile error since y is not optional Point p2 = new Point() {{ x=1; z=1; }}; 接口中的特殊JavaScript函数 在JavaScript中，对象可以具有属性和函数，但也可以（非排他地）用作构造函数和函数本身。这在Java中是不可能的，因此JSweet定义了用于处理这些情况的特殊函数。
public int a;
// error: public constructors are not allowed
public Globals() {
this.a = 3;
}
public static void test() {
// error: no instance is available
$delete("key");
}
} // error: Globals classes cannot be used as types Globals myVariable = null; 必须记住，Globals类和global包在运行时被擦除，以便可以直接访问它们的成员。例如mypackage.Globals.m()，在JSweet程序中，对应mypackage.m()于生成的代码中的函数以及运行时的JavaScript VM中的 函数。此外，mypackage.globals.Globals.m()对应于m（）。
为了擦除生成代码中的包，程序员也可以使用@Root注释，这将在第5节中解释 。
可选参数和重载 In JavaScript, parameters can be optional, in the sense that a parameter value does not need to be provided when calling a function. Except for varargs, which are fully supported in JSweet, the general concept of an optional parameter does not exist in Java. To simulate optional parameters, JSweet programmers can use method overloading, which is supported in Java. Here are some examples of supported overloads in JSweet:
String m(String s, double n) { return s + n; } // simple overloading (JSweet transpiles to optional parameter) String m(String s) { return m(s, 0); } // complex overloading (JSweet generates more complex code to mimic the Java behavior) String m(String s) { return s; } Bridging to external JavaScript elements It can be the case that programmers need to use existing libraries from JSweet. In most cases, one should look up in the available candies, a.k.a. bridges at http://www.jsweet.org/jsweet-... When the candy does not exist, or does not entirely cover what is needed, one can create new definitions in the program just by placing them in the def.libname package. Definitions only specify the types of external libraries, but no implementations. Definitions are similar to TypeScript’s .d.ts definition files (actually JSweet generates intermediate TypeScript definition files for compilation purposes). Definitions can also be seen as similar to .h C/C++ header files.
native public JQuery accordion();
native public void accordion(jsweet.util.StringTypes.destroy methodName);
native public void accordion(jsweet.util.StringTypes.disable methodName);
native public void accordion(jsweet.util.StringTypes.enable methodName);
native public void accordion(jsweet.util.StringTypes.refresh methodName);
...
native public def.jqueryui.JQuery menu();
...
// TypeScript: var c : C = ...; c.m({ index : 2 }); 显然，对象类型是一种使程序员很容易输入JavaScript程序的方法，这是TypeScript的主要目标之一。它使得JavaScript程序员的输入简洁，直观，直观。在Java / JSweet中，不存在类似的内联类型，Java程序员用于为这种情况定义类或接口。因此，在JSweet中，程序员必须定义用@ObjectType对象类型注释的辅助类。这可能看起来更复杂，但它有利于强制程序员命名所有类型，最终可以根据上下文导致更易读和可维护的代码。请注意，与接口类似，对象类型在运行时被擦除。另外@ObjectType 注解的类可以内部类，使他们在本地使用。
这是以前的TypeScript程序的JSweet版本。
public class C {
@ObjectType
public static class Indexed {
int index;
}
public void m(Indexed param) { ... }
} 使用对象类型与使用接口类似：
C c = ...; c.m(new Indexed() {{ index = 2; }}); 当对象类型是共享对象并表示可以在多个上下文中使用的键入实体时，建议使用 @Interface注释而不是@ObjectType。这是基于界面的版本。
@Interface public class Indexed {
int index;
}
public class C {
public m(Indexed param) { ... }
}
C c = ...; c.m(new Indexed {{ index = 2; }}); 字符串类型 在TypeScript中，字符串类型是一种根据字符串参数的值来模拟函数重载的方法。例如，这是DOM TypeScript定义文件的简化摘录：
@Erased
public interface abc {}
@StringType
public static final abc abc = null;
// This method takes a string type parameter
void m2(abc arg) {
}
public static void main(String[] args) {
new CustomStringTypes().m2(abc);
}
import static jsweet.util.Lang.union; import jsweet.util.union.Union; [...] Union u = ...; // u can be used as a String String s = union(u); // or a number Number n = union(u); // but nothing else Date d = union(u); // JSweet error 如果union需要，也可以使用其他方式将助手从常规类型切换回联合类型。
import static jsweet.util.Lang.union; import jsweet.util.union.Union3; [...] public void m(Union3> u) { ... } [...] // u can be a String, a Number or a Date m(union("a string")); // but nothing else m(union(new RegExp(".*"))); // compile error 注意：在键入函数参数时，优先使用Java函数重载而不是union类型。例如：
// with union types (discouraged) native public void m(Union3> u); // with overloading (preferred way) native public void m(String s); native public void m(Number n); native public void m(Date d); 交叉类型 TypeScript定义了类型交集的概念。当类型相交时，意味着结果类型是更大的类型，它是所有相交类型的总和。例如，在TypeScript中， A & B对应于定义两者A和B成员的类型。
private int n;
public static C instance;
public static void main(String[] args) {
instance = new C();
instance.n = 4;
}
public int getN() {
return n;
}
} // when the source file containing C has been evaluated: assert C.instance != null; assert C.instance.getN() == 4; 全局调用main方法的方式取决于程序的打包方式。有关详细信息，请参阅附录。
Promise delay(int millis) { return new Promise((Consumer resolve, Consumer
setTimeout(resolve, millis);
}); } 然后，您可以在履行承诺后链接同步和异步操作。
delay(1000) // chain with a synchronous action with "then". Here we just return a constant. .then(() -> {
System.out.println("wait complete");
return 42;
}) // chain with an asynchronous action with "thenAsync". Here it is implied that anotherAsyncAction(String) returns a Promise<...> .thenAsync((Integer result) -> {
// error: field name clashes with existing method name
public String a;
// error: method name clashes with existing field name
public void a() {
return a;
}
function m(s, n = 0) { return s + n; } 如果程序员尝试以不同方式使用重载，例如通过为同一方法名定义两个不同的实现，JSweet将回退复杂的重载，包括生成根实现（包含更多参数的方法）和一个辅助实现per overloading方法（用表示方法签名的后缀命名）。根实现是通用的，并通过测试给定参数的值和类型调度到其他实现。例如：
import static jsweet.util.Lang.typeof; import static jsweet.util.Lang.equalsStrict; [...] Number n1 = 2; Object n2 = 2; int n3 = 2; Object s = "test"; MyClass c = new MyClass();
assert n1 instanceof Number; // transpiles to a typeof assert n2 instanceof Number; // transpiles to a typeof assert n2 instanceof Integer; // transpiles to a typeof assert !(n2 instanceof String); // transpiles to a typeof assert s instanceof String; // transpiles to a typeof assert !(s instanceof Integer); // transpiles to a typeof assert c instanceof MyClass; assert typeof(n3) == "number"; 从JSweet版本1.1.0开始，instanceof接口上也允许运算符，因为JSweet会跟踪所有对象的所有实现接口。通过调用的对象中的附加隐藏属性来确保此接口跟踪，__interfaces并且包含对象实现的所有接口的名称（直接或通过在编译时确定的类继承树）。因此，如果instanceof 运算符的类型参数是接口，JSweet只是检查对象的 __interfaces字段是否存在并包含给定的接口。例如，当Point接口是这个代码在JSweet中完全有效：
Point p1 = new Point() {{ x=1; y=1; }}; [...] assert p1 instanceof Point Object.getClass() 和 X.class 在JSweet中，可以使用Object.getClass()on any实例。它实际上将返回类的构造函数。X.class如果X是类，using 也将返回构造函数。因此，以下断言将在JSweet中保留：
String s = "abc"; assert String.class == s.getClass() 在课堂上，您可以调用getSimpleName()或getName()函数。
就像在JavaScript中工作时一样，序列化对象必须与其实际类正确“复活”，以便 instanceof操作员可以再次工作。例如，通过创建的点对象Point p = (Point)JSON.parse("{x:1,y:1}")不会对instanceof运算符起作用。如果您遇到这样的用例，您可以联系我们获取一些有用的JSweet代码以正确恢复对象类型。
NodeList nodes = document.querySelectorAll(".control"); for (int i = 0; i < nodes.length; i++) {
HTMLElement element = (HTMLElement) nodes.$get(i); // final
element.addEventListener("keyup", (evt) -> {
// this element variable will not change here
element.classList.add("hit");
});
private int i = 8;
public Runnable getAction() {
return this::action;
}
public void action() {
console.log(this.i); // this.i is 8
}
public static void main(String[] args) {
Example instance = new Example();
instance.getAction().run();
}
