// 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();
}
