diff --git a/en/application-dev/quick-start/introduction-to-arkts.md b/en/application-dev/quick-start/introduction-to-arkts.md
index 88a0cb306220caf5f5ebcb0fea8eaf0c9db6f674..b3bbd6671524a508d881c3d5245d0a1958d59c63 100644
--- a/en/application-dev/quick-start/introduction-to-arkts.md
+++ b/en/application-dev/quick-start/introduction-to-arkts.md
@@ -48,12 +48,17 @@ applications in ArkTS.
## Declarations
-Declarations in ArkTS introduce variables, constants, functions and types.
+Declarations in ArkTS introduce:
+
+- variables,
+- constants,
+- functions, and
+- types.
### Variable Declaration
-Declaration started with keyword `let` introduces a variable which can have different values
-during program execution.
+A declaration starting with the keyword `let` introduces a variable which
+can have different values during program execution.
```typescript
let hi: string = "hello"
@@ -62,18 +67,19 @@ hi = "hello, world"
### Constant Declaration
-Declaration started with keyword `const` introduces a read-only constant that can be assigned only once.
+A declaration starting with the keyword `const` introduces a read-only
+constant that can be assigned only once.
```typescript
const hello: string = "hello"
```
-Assigning a new value to a constant is a compile-time error.
+A compile-time error occurs if a new value is assigned to a constant.
### Automatic Type Inference
As ArkTS is a statically typed language, the types of all entities, like
-variables and constants have to be known at compile time.
+variables and constants, have to be known at compile time.
However, developers do not need to explicitly specify the type of a declared
entity if a variable or a constant declaration contains an initial value.
@@ -90,8 +96,8 @@ let hi2 = "hello, world"
## Types
-`Class`, `interface`, `function`, `enum`, `union` types and type `aliases` are
-described in the corresponding sections.
+`Class`, `interface`, `function`, `enum`, `union` types, and type
+`aliases` are described in the corresponding sections.
### Numeric Types
@@ -104,9 +110,9 @@ with the decimal base.
Integer literals include the following:
* decimal integers that consist of a sequence of digits. For example: `0`, `117`, `-345`;
-* hexadecimal integers that start with 0x (or 0X) and can contain digits (0-9) and letters a-f or A-F. For example: `0x1123`, `0x00111`, `-0xF1A7`;
+* hexadecimal integers that start with 0x (or 0X), and can contain digits (0-9) and letters a-f or A-F. For example: `0x1123`, `0x00111`, `-0xF1A7`;
* octal integers that start with 0o (or 0O) and can only contain digits (0-7). For example: `0o777`;
-* binary integers that start with 0b (or 0B) and can only contain the digits 0 and 1. For example: `0b11`, `0b0011`, `-0b11`.
+* binary integers that start with 0b (or 0B), and can only contain the digits 0 and 1. For example: `0b11`, `0b0011`, `-0b11`.
A floating-point literal includes the following:
@@ -150,13 +156,12 @@ if (isDone) {
### `String`
-A `string` is a sequence of characters; some characters can be set using
-escape-sequences.
+A `string` is a sequence of characters; some characters can be set by using
+escape sequences.
-A `string` literal consists of zero or more characters
-enclosed between single (’) or
-double quotes (“). The special form of a string literals are template literals
-enclosed in backtick quotes (\`).
+A `string` literal consists of zero or more characters enclosed in single
+(’) or double quotes (“). The special form of string literals are template
+literals enclosed in backtick quotes (\`).
```typescript
let s1 = "Hello, world!\n"
@@ -168,9 +173,8 @@ let s3 = `The result is ${a}`
### `Void` Type
The `void` type is used to specify that a function does not return a value.
-This type has the only one value,
-which is also `void`. As `void` is reference type, it can be used as type
-argument for generic types.
+This type has the only one value which is also `void`. As `void` is
+a reference type, it can be used as type argument for generic types.
```typescript
class Class<T> {
@@ -181,19 +185,18 @@ let instance: Class <void>
### `Object` Type
-An `Object` class type is a base type for all reference types. Any value, including
-values of primitive types (they will be automatically boxed), can be directly assigned
-to variables of type `Object`.
+An `Object` class type is a base type for all reference types. Any value,
+including values of primitive types (they will be automatically boxed), can
+be directly assigned to variables of the type `Object`.
### `Array` Type
An `array` is an object comprised of elements of data types assignable to
the element type specified in the array declaration.
-A value of an `array` is set using *array composite literal*, that is a list
-of zero or more expressions
-enclosed in square brackets ([]). Each expression represents an element of the
-`array`. The length of the `array` is set by the number of expressions. Index of
-the first array element is 0.
+A value of an `array` is set by using *array composite literal*, that is a
+list of zero or more expressions enclosed in square brackets ([]). Each
+expression represents an element of the `array`. The length of the `array`
+is set by the number of expressions. Index of the first array element is 0.
The following example creates the `array` with three elements:
@@ -205,15 +208,16 @@ let names: string[] = ["Alice", "Bob", "Carol"]
An `enum` type is a value type with a defined set of named values called
enum constants.
-To be used, an `enum` constant must be prefixed with an enum `type` name.
+In order to be used, an `enum` constant must be prefixed with an enum
+`type` name.
```typescript
enum Color { Red, Green, Blue }
let c: Color = Color.Red
```
-A constant expression can be
-used to explicitly set the value of an enum constant.
+A constant expression can be used to explicitly set the value of an `enum`
+constant.
```typescript
enum Color { White = 0xFF, Grey = 0x7F, Black = 0x00 }
@@ -222,8 +226,9 @@ let c: Color = Color.Black
### `Union` Type
-An `union` type is a reference type which is created as a combination of other types. Values of the union types
-can be valid values of all types union was created from.
+A `union` type is a reference type which is created as a combination
+of other types. Values of union types can be valid values of all types
+a union was created from.
```typescript
class Cat {
@@ -244,7 +249,8 @@ animal = 42
// One may assign the variable of the union type with any valid value
```
-There are different mechanisms how to get a value of the particular type from the union.
+There are different mechanisms to get a value of a particular type from a union.
+
For example
```typescript
@@ -267,8 +273,8 @@ animal.sleep () // Any animal can sleep
### Type `Aliases`
-Type `aliases` provide names for anonymous types (array, function, object literal or union
-types) or alternative names for existing types.
+Type `aliases` provide names for anonymous types (array, function, object
+literal or union types) or alternative names for existing types.
```typescript
type Matrix = number[][]
@@ -284,7 +290,7 @@ type NullableObject = Object | null
Simple assignment operator ‘=’ is used as in “x = yâ€.
Compound assignment operators combine an assignment with an operator, where
-`x op = y` equals to `x = x op y`.
+`x op = y` equals `x = x op y`.
Compound assignment operators are as follows: `+=`, `-=`, `*=`, `/=`,
`%=`, `<<=`, `>>=`, `>>>=`, `&=`, `|=`, `^=`.
@@ -299,10 +305,9 @@ Compound assignment operators are as follows: `+=`, `-=`, `*=`, `/=`,
| `>=` | returns true if the left operand is greater than or equal to the right |
| `<` | returns true if the left operand is less then the right |
| `<=` | returns true if the left operand is less than or equal to the right |
-
### Arithmetic Operators
-Unary operators are `-`, `+`, `--`, `++`.
+Unary operators are `-`, `+`, `--` and `++`.
Binary operators are as follows:
@@ -313,7 +318,6 @@ Binary operators are as follows:
| `*` | multiplication |
| `/` | division |
| `%` | remainder after division |
-
### Bitwise Operators
| Operator | Description |
@@ -325,7 +329,6 @@ Binary operators are as follows:
| `a << b` | Shift left: shifts the binary representation of *a* to the left by *b* bits. |
| `a >> b` | Arithmetic right shift: shifts the binary representation of *a* to the right by *b* bits with sign-extension. |
| `a >>> b` | Logical right shift: shifts the binary representation of *a* to the right by *b* bits with zero-extension. |
-
### Logical Operators
| Operator | Description |
@@ -333,16 +336,15 @@ Binary operators are as follows:
| `a && b` | logical AND |
| `a \|\| b` | logical OR |
| `! a` | logical NOT |
-
## Control Flow
### `If` Statements
-Use `if` statement to execute a sequence of statements when a logical
-condition is true, or another set of statements (if provided) otherwise.
-`else` part may contain more `if` statements as well.
+An `if` statement is used to execute a sequence of statements when a logical
+condition is `true`, or another set of statements (if provided) otherwise.
+The `else` part can also contain more `if` statements.
-The `if` statement looks as follows:
+An `if` statement looks as follows:
```typescript
if (condition1) {
@@ -354,7 +356,7 @@ if (condition1) {
}
```
-All conditional expressions should be of the type `boolean` or other types
+All conditional expressions must be of the type `boolean` or other types
(`string`, `number`, etc.). For types other than `boolean`, implicit
conversion rules apply:
@@ -372,10 +374,10 @@ if (s2.length != 0) {
### `Switch` Statements
-Use `switch` statement to execute a sequence of statements that match the
-value of the switch expression.
+A `switch` statement is used to execute a sequence of statements that match
+the value of a switch expression.
-The `switch` statement looks as follows:
+A `switch` statement looks as follows:
```typescript
switch (expression) {
@@ -396,7 +398,7 @@ default:
```
The `switch` expression type must be of `number`, `enum` or `string`
-type.
+types.
Each label must be either a constant expression or the name of an enum constant.
@@ -409,14 +411,15 @@ default statements are executed.
An optional `break` statement allows to break out of the `switch` and
continue executing the statement that follows the `switch`.
-If there is no break, then the next statements in the `switch` is executed.
+If there is no `break`, then the next statements in the `switch` is
+executed.
### Conditional Expressions
-The conditional expression `?` : uses the `boolean` value of the first
+The conditional expression `? :` uses the `boolean` value of the first
expression to decide which of two other expressions to evaluate.
-It looks as follows:
+A conditional expression looks as follows:
```typescript
condition ? expression1 : expression2
@@ -435,8 +438,10 @@ let message = isValid ? 'Valid' : 'Failed'
### `For` Statements
-A `for` statement is executed repeatedly until the specified loop exit condition
-is `false`. A `for` statement looks as follows:
+A `for` statement is executed repeatedly until the specified loop exit
+condition is `false`.
+
+A `for` statement looks as follows:
```typescript
for ([init]; [condition]; [update]) {
@@ -446,10 +451,15 @@ for ([init]; [condition]; [update]) {
When a `for` statement is executed, the following process takes place:
-1. An `init` expression is executed, if any. This expression usually initializes one or more loop counters.
-2. The condition is evaluated. If the value of condition is `true`, or if the conditional expression is omitted, then the statements in the for body are to be executed. If the value of condition is `false`, the `for` loop terminates.
+1. An `init` expression is executed, if any. This expression usually
+ initializes one or more loop counters.
+2. The condition is evaluated. If the value of condition is `true`, or
+ if the conditional expression is omitted, then the statements in the
+ `for` body are to be executed. If the value of condition is `false`,
+ then the `for` loop terminates.
3. The statements of the `for` body are executed.
-4. If there is an `update` expression, the `update` expression is executed.
+4. If there is an `update` expression, then the `update` expression
+ is executed.
5. Go back to step 2.
Example:
@@ -463,8 +473,9 @@ for (let i = 0; i < 10; i += 2) {
### `For-of` Statements
-Use `for-of` statements to iterate over an array or string. A `for-of`
-statement looks as follows:
+`for-of` statements are used to iterate over an array or string.
+
+A `for-of` statement looks as follows:
```typescript
for (forVar of expression) {
@@ -480,8 +491,10 @@ for (let ch of "a string object") { /* process ch */ }
### `While` Statements
-A `while` statement has its body statements executed as long as the specified condition
-evaluates to `true`. It looks as follows:
+A `while` statement has its body statements executed as long as the
+specified condition evaluates to `true`.
+
+A `while` statement looks as follows:
```typescript
while (condition) {
@@ -504,8 +517,10 @@ while (n < 3) {
### `Do-while` Statements
-The `do-while` statements are executed repetitively until the specified
-condition evaluates to false. It looks as follows:
+`do-while` statements are executed repetitively until a specified
+condition evaluates to false.
+
+A `do-while` statement looks as follows:
```typescript
do {
@@ -526,7 +541,7 @@ do {
### `Break` Statements
-Use a `break` statement to terminate any `loop` statement or `switch`.
+A `break` statement is used to terminate any `loop` statement or `switch`.
Example:
@@ -558,8 +573,8 @@ label: while (true) {
### `Continue` Statements
-A `continue` statement stops the execution of the current loop iteration and
-passes control to the next iteration.
+A `continue` statement stops the execution of the current loop iteration
+and passes control to the next iteration.
Example:
@@ -575,13 +590,13 @@ for (let x = 0; x < 100; x++) {
### `Throw` and `Try` Statements
-A `throw` statement is used to throw an exception or error:
+A `throw` statement is used to throw an exception or an error:
```typescript
throw new Error("this error")
```
-A `try` statement is used to catch and handle an exception or error:
+A `try` statement is used to catch and handle an exception or an error:
```typescript
try {
@@ -672,7 +687,7 @@ function hello(name?: string) {
Another form contains an expression that specifies a default value.
If the corresponding argument to such parameter is omitted in a function call,
-then this parameter has the default value.
+then this parameter’s value is default.
```typescript
function multiply(n: number, coeff: number = 2): number {
@@ -701,7 +716,8 @@ sum(1, 2, 3) // returns 6
## Return Types
-If function return type can be inferred from its body content then it can be omitted from the function declaration.
+If function return type can be inferred from its body content, then it can
+be omitted from the function declaration.
```typescript
// Explicit return type
@@ -711,7 +727,9 @@ function foo(): string { return "foo" }
function goo() { return "goo" }
```
-The return type of a function that does not need to return a value may be explicitly specified as `void` or omitted altogether. No return statement is needed for such functions.
+The return type of a function that does not need to return a value can be
+explicitly specified as `void` or omitted altogether. No return statement
+is needed for such functions.
Both notations below are valid:
@@ -722,13 +740,16 @@ function hi2(): void { console.log("hi") }
## Function Scope
-Variables and other entities defined in a function are local to the function and cannot be accessed outside.
+Variables and other entities defined in a function are local to the function
+and cannot be accessed from the outside.
-If the name of a variable defined in the function is equal to the name of an entity in the outer scope, then the local definition shadows outer entity.
+If the name of a variable defined in the function is equal to the name of an
+entity in the outer scope, then the local definition shadows the outer entity.
## Function Calls
-Calling a function actually leads to its body execution while arguments of the call are assigned to function parameters.
+Calling a function actually leads to the execution of its body, while
+the arguments of the call are assigned to the function parameters.
If the function is defined as follows:
@@ -770,9 +791,11 @@ let sum = (x: number, y: number): number => {
}
```
-An arrow function return type may be omitted; in this case it is inferred from the function body.
+An arrow function return type can be omitted; in such case, it is inferred
+from the function body.
-An expression can be specified as an arrow function, making notation shorter, so the following two notations are equivalent:
+An expression can be specified as an arrow function to make the notation
+shorter, i.e., the following two notations are equivalent:
```typescript
let sum1 = (x: number, y: number) => { return x + y }
@@ -781,10 +804,12 @@ let sum2 = (x: number, y: number) => x + y
## Closure
-An arrow function is usually defined inside another function. As an inner function, it can access all variables and functions defined in the outer functions.
+An arrow function is usually defined inside another function. As an inner
+function, it can access all variables and functions defined in the outer
+functions.
To capture the context, an inner function forms a closure of its environment.
-The closure allows accessing such inner function outside its own environment.
+The closure allows accessing such an inner function outside its own environment.
```typescript
function f(): () => number {
@@ -801,7 +826,10 @@ In the sample above, the arrow function closure captures the `count` variable.
## Function Overload Signatures
-A function can be specified to be called in different ways by writing overload signatures. To do so, several functions headers are written that they have the same name but different signatures, immediately followed by the single implementing function.
+A function can be specified to be called in different ways by writing
+overload signatures. To do so, several functions’ headers that have the
+same name but different signatures are written and immediately followed
+by the single implementation function.
```typescript
function foo(): void; /* 1st signature */
@@ -814,13 +842,15 @@ foo() // ok, 1st signature is used
foo("aa") // ok, 2nd signature is used
```
-It is an error if two overload signatures have identical parameter lists.
+An error occurs if two overload signatures have identical parameter lists.
# Classes
-A class declaration introduces a new type and defines its fields, methods and constructors.
+A class declaration introduces a new type and defines its fields, methods
+and constructors.
-In the following example, class `Person` is defined, which has fields ‘name’ and ‘surname’, constructor and a method `fullName`:
+In the following example, class `Person` is defined, which has fields
+‘name’ and ‘surname’, constructor, and a method `fullName`:
```typescript
class Person {
@@ -836,21 +866,22 @@ class Person {
}
```
-After the class is defined, its instances can be created using the keyword `new`:
+After the class is defined, its instances can be created by using
+the keyword `new`:
```typescript
let p = new Person("John", "Smith")
console.log(p.fullName())
```
-Or an instance can be created using object literals:
+or an instance can be created by using object literals:
```typescript
class Point {
x: number = 0
y: number = 0
}
-let p: Point = {42 ,42}
+let p: Point = {x: 42, y: 42}
```
## Fields
@@ -877,7 +908,7 @@ let p1 = new Person("Alice", 25)
let p2 = new Person("Bob", 28)
```
-To access an instance field, use an instance of the class:
+An instance of the class is used to access an instance field:
```typescript
p1.name
@@ -886,10 +917,11 @@ this.name
### Static Fields
-Use the keyword `static` to declare a field as static. Static fields belong
-to the class itself, and all instances of the class share one static field.
+The keyword `static` is used to declare a field as static. Static fields
+belong to the class itself, and all instances of the class share one static
+field.
-To access a static field, use the class name:
+The class name is used to access a static field:
```typescript
class Person {
@@ -906,9 +938,11 @@ console.log(Person.numberOfPersons)
### Getters and Setters
-Setters and getters can be used to provide controlled access to object properties.
+Setters and getters can be used to provide controlled access to object
+properties.
-In the following example, a setter is used to forbid setting invalid values of the ‘age’ property:
+In the following example, a setter is used to forbid setting invalid
+values of the ‘age’ property:
```typescript
class Person {
@@ -928,19 +962,22 @@ console.log (p.age) // 0 will be printed out
p.age = -42 // Error will be thrown as an attempt to set incorrect age
```
-A class may define a getter, a setter or both.
+A class can define a getter, a setter or both.
## Methods
A method is a function that belongs to a class.
A class can define instance methods, static methods or both.
-A static method belongs to the class itself, and can have access to static fields only.
-While instance method has access to both static (class) fields and instance fields including private ones of its class.
+A static method belongs to the class itself, and can have access to static
+fields only.
+A `while` instance method has access to both static (class) fields and
+instance fields including private ones of its class.
### Instance Methods
-Example below illustrates how instanced methods work.
-The `calculateArea` method calculates the area of a rectangle by multiplying the height by the width:
+The example below illustrates how instanced methods work.
+The `calculateArea` method calculates the area of a rectangle by
+multiplying the height by the width:
```typescript
class Rectangle {
@@ -955,20 +992,21 @@ class Rectangle {
}
```
-To use an instance method, call it on an instance of the class:
+To use an instance method, it must be called on an instance of the class:
```typescript
-let r = new Rectangle(10, 10)
+let square = new Rectangle(10, 10)
console.log(square.calculateArea()) // output: 100
```
### Static Methods
-Use the keyword `static` to declare a method as static. Static methods belong to the class itself and have access to static fields only.
+The keyword `static` is used to declare a method as static. Static methods
+belong to the class itself and have access to static fields only.
A static method defines a common behavior of the class as a whole.
All instances have access to static methods.
-To call a static method, use the class name:
+The class name is used to call a static method:
```typescript
class Cl {
@@ -981,7 +1019,8 @@ console.log(Cl.staticMethod())
### Inheritance
-A class can extend another class (called base class) and implement several interfaces using the following syntax:
+A class can extend another class (called base class) and implement several
+interfaces by using the following syntax:
```typescript
class [extends BaseClassName] [implements listOfInterfaces] {
@@ -989,9 +1028,12 @@ class [extends BaseClassName] [implements listOfInterfaces] {
}
```
-The extended class inherits fields and methods from the base class, but not constructors, and can add its own fields and methods as well as override methods defined by the base class.
+The extended class inherits fields and methods from the base class, but
+not constructors, and can add its own fields and methods as well as override
+methods defined by the base class.
-The base class is also called ‘parent class’ or ‘superclass’. The extended class also called ‘derived class’ or ‘subclass’.
+The base class is also called ‘parent class’ or ‘superclass’.
+The extended class also called ‘derived class’ or ‘subclass’.
Example:
@@ -1011,7 +1053,9 @@ class Employee extends Person {
}
```
-A class containing the `implements` clause must implement all methods defined in all listed interfaces, except the methods defined with default implementation.
+A class containing the `implements` clause must implement all methods
+defined in all listed interfaces, except the methods defined with default
+implementation.
```typescript
interface DateInterface {
@@ -1027,9 +1071,11 @@ class MyDate implements DateInterface {
### Access to Super
-The keyword `super` can be used to access instance fields, instance methods and constructors from the super class.
+The keyword `super` can be used to access instance fields, instance methods
+and constructors from the super class.
-It is often used to extend basic functionality of subclass with the required behavior taken from the super class:
+It is often used to extend basic functionality of subclass with the required
+behavior taken from the super class:
```typescript
class Rectangle {
@@ -1062,9 +1108,11 @@ class FilledRectangle extends Rectangle {
### Override Methods
-A subclass may override implementation of a method defined in its superclass.
-An overridden method may be marked with the keyword `override`, to improve readability.
-An overridden method must have the same types of parameters and same or derived return type as the original method.
+A subclass can override implementation of a method defined in its superclass.
+An overridden method can be marked with the keyword `override` to improve
+readability.
+An overridden method must have the same types of parameters, and same or
+derived return type as the original method.
```typescript
class Rectangle {
@@ -1084,7 +1132,10 @@ class Square extends Rectangle {
### Method Overload Signatures
-A method can be specified to can be called in different ways by writing overload signatures. To do so, several method headers are written that have the same name but different signatures, immediately followed by the single implementation method.
+A method can be specified to be called in different ways by writing overload
+signatures. To do so, several method headers that have the same name but
+different signatures are written and immediately followed by the single
+implementation method.
```typescript
class C {
@@ -1099,13 +1150,15 @@ c.foo() // ok, 1st signature is used
c.foo("aa") // ok, 2nd signature is used
```
-It is an error if two overload signatures have the same name and identical parameter lists.
+An error occurs if two overload signatures have the same name and identical
+parameter lists.
## Constructors
-A class declaration may contain a constructor that is used to initialize object state.
+A class declaration may contain a constructor that is used to initialize
+object state.
-Constructor is defined as follows:
+A constructor is defined as follows:
```typescript
constructor ([parameters]) {
@@ -1113,7 +1166,8 @@ constructor ([parameters]) {
}
```
-If no constructor is defined, then a default constructor with an empty parameter list is created automatically, for example:
+If no constructor is defined, then a default constructor with an empty
+parameter list is created automatically, for example:
```typescript
class Point {
@@ -1123,11 +1177,13 @@ class Point {
let p = new Point()
```
-In this case the default constructor fills the instance fields with default values for the field types.
+In this case the default constructor fills the instance fields with
+default values for the field types.
### Constructors in Derived Class
-The first statement of a constructor body can use the keyword `super` to explicitly call a constructor of the direct superclass.
+The first statement of a constructor body can use the keyword `super`
+to explicitly call a constructor of the direct superclass.
```typescript
class Rectangle {
@@ -1142,11 +1198,16 @@ class Square extends Rectangle {
}
```
-If a constructor body does not begin with such an explicit call of a superclass constructor, then the constructor body implicitly begins with a superclass constructor call `super()`.
+If a constructor body does not begin with such an explicit call of a
+superclass constructor, then the constructor body implicitly begins
+with a superclass constructor call `super()`.
### Constructor Overload Signatures
-A constructor can be specified to can be called in different ways by writing overload signatures. To do so, several constructor headers are written that have the same name but different signatures, immediately followed by the single implementation constructor.
+A constructor can be specified to be called in different ways by writing
+overload signatures. To do so, several constructor headers that have the
+same name but different signatures are written and immediately followed
+by the single implementation constructor.
```typescript
class C {
@@ -1160,23 +1221,33 @@ let c1 = new C() // ok, 1st signature is used
let c2 = new C("abc") // ok, 2nd signature is used
```
-It is an error if two overload signatures have the same name and identical parameter lists.
+An error occurs if two overload signatures have the same name and
+identical parameter lists.
## Visibility Modifiers
Both methods and properties of a class can have visibility modifiers.
-There are several visibility modifiers: `private`, `protected`,
-`public`, and `internal`. The default visibility is `public`.
-`internal` allows to limit visibility within the current package.
+There are several visibility modifiers:
+
+- `private`,
+- `protected`,
+- `public`, and
+- `internal`.
+
+The default visibility is `public`.
+The modifier `internal` allows to limit visibility within
+the current package.
### Public Visibility
-The `public` members (fields, methods, constructors) of a class are visible in any part of the program, where their class is visible.
+The `public` members (fields, methods, constructors) of a class are
+visible in any part of the program, where their class is visible.
### Private Visibility
-A `private` member cannot be accessed outside the class in which it is declared, for example:
+A `private` member cannot be accessed outside the class it is declared in,
+for example:
```typescript
class C {
@@ -1193,8 +1264,8 @@ c.y = "b" // compile-time error: 'y' is not visible
### Protected Visibility
-The `protected` modifier acts much like the `private` modifier, but
-`protected` members are also accessible in derived classes, for example:
+The modifier `protected` acts much like the modifier `private`, but
+the `protected` members are also accessible in derived classes, for example:
```typescript
class Base {
@@ -1211,9 +1282,12 @@ class Derived extends Base {
## Object Literals
-An object literal is an expression that can be used to create a class instance and provide some initial values. It can be used instead of `new` expression as it is more convenient in some cases.
+An object literal is an expression that can be used to create a class instance
+and provide some initial values. It can be used instead of the expression
+`new` as it is more convenient in some cases.
-A class composite is written as a comma-separated list of name-value pairs enclosed in ‘{’ and ‘}’.
+A class composite is written as a comma-separated list of name-value pairs
+enclosed in ‘{’ and ‘}’.
```typescript
class C {
@@ -1224,7 +1298,9 @@ class C {
let c: C = {n: 42, s: "foo"}
```
-Due to static typing of the ArkTS the object literals can be used in context where the class or interface type of the object literal can be inferred as in the example above. Other valid cases:
+Due to the static typing of the ArkTS, object literals can be used in a
+context where the class or interface type of the object literal can be
+inferred as in the example above. Other valid cases are illustrated below:
```typescript
class C {
@@ -1244,7 +1320,7 @@ function bar(): C {
}
```
-Type of an array element or a type of a class field also can be used:
+The type of an array element or of a class field can also be used:
```typescript
class C {
@@ -1254,10 +1330,12 @@ class C {
let cc: C[] = [{n: 1, s: "a"}, {n: 2, s: "b"}]
```
-### Object Literals of the Record Type
+### Object Literals of Record Type
+
+The generic Record<K, V> type is used to map the properties of a type
+(Key type) to another type (Value type).
-The generic Record<K, V> type is used to map the properties of a type (Key type) to another type (Value type).
-A special form of an object literal is used to initialize the value of such type:
+A special form of object literal is used to initialize the value of such type:
```typescript
let map: Record<string, number> = {
@@ -1283,9 +1361,11 @@ let map: Record<string, PersonInfo> = {
# Interfaces
-An interface declaration introduces a new type. Interfaces are a common way of defining contracts between various part of codes.
+An interface declaration introduces a new type. Interfaces are a common way
+of defining contracts between various part of codes.
-Interfaces are used to write polymorphic code, which can be applied to any class instances that implement a particular interface.
+Interfaces are used to write polymorphic code, which can be applied to any
+class instances that implement a particular interface.
An interface usually contains properties and method headers.
@@ -1326,9 +1406,11 @@ class Rectangle implements Area {
## Interface Properties
-An interface property can be in a form of field, getter, setter or both getter and setter.
+An interface property can be in a form of field, getter, setter, or both
+getter and setter.
-A property field is just a shortcut notation of a getter/setter pair, and the following notations are equal:
+A property field is just a shortcut notation of a getter/setter pair, and
+the following notations are equal:
```typescript
interface Style {
@@ -1381,28 +1463,31 @@ interface ExtendedStyle extends Style {
}
```
-An extended interface contains all properties and methods of the interface it extends and may also add its own properties and methods.
+An extended interface contains all properties and methods of the
+interface it extends, and can also add its own properties and methods.
## Interface Visibility Modifiers
Properties and methods are `public`.
-Only methods with default implementation may be defined as `private`.
+Only methods with default implementation can be defined as `private`.
# Generic Types and Functions
-Generic types and functions allow creating the code capable to work over a variety of types rather than a single one.
+Generic types and functions allow creating the code capable to work over a
+variety of types rather than a single type.
## Generic Classes and Interfaces
-A class and an interface can be defined as generics, adding parameters to the type definition, like the type parameter `Element` in the following example:
+A class and an interface can be defined as generics, adding parameters to the
+type definition, like the type parameter `Element` in the following example:
```typescript
class Stack<Element> {
public pop(): Element {
// ...
}
- public push(e: Element) {
+ public push(e: Element): void {
// ...
}
}
@@ -1415,7 +1500,8 @@ let s = new Stack<string>
s.push("hello")
```
-Compiler ensures type safety while working with generic types and functions. See below
+Compiler ensures type safety while working with generic types and functions.
+See below:
```typescript
let s = new Stack<string>
@@ -1424,7 +1510,9 @@ s.push(55) // That will be a compile-time error
## Generic Constraints
-Type parameters of generic types can be bounded. For example, the `Key` type parameter in the `HashMap<Key, Value>` container must have a hash method, i.e., it should be hashable.
+Type parameters of generic types can be bounded. For example, the `Key`
+type parameter in the `HashMap<Key, Value>` container must have a hash
+method, i.e., it must be hashable.
```typescript
interface Hashable {
@@ -1438,11 +1526,13 @@ class HasMap<Key extends Hashable, Value> {
}
```
-In the above example, the `Key` type extends `Hashable`, and all methods of `Hashable` interface can be called for keys.
+In the above example, the `Key` type extends `Hashable`, and all methods
+of `Hashable` interface can be called for keys.
## Generic Functions
-Use a generic function to create a more universal code. Consider a function that returns the last element of the array:
+Use a generic function to create a more universal code. Consider a function
+that returns the last element of the array:
```typescript
function last(x: number[]): number {
@@ -1451,7 +1541,8 @@ function last(x: number[]): number {
console.log(last([1, 2, 3])) // output: 3
```
-If the same function needs to be defined for any array, define it as generic with a type parameter:
+If the same function needs to be defined for any array, then define it as
+a generic with a type parameter:
```typescript
function last<T>(x: T[]): T {
@@ -1461,7 +1552,7 @@ function last<T>(x: T[]): T {
Now, the function can be used with any array.
-In a function call, type argument may be set explicitly or implicitly:
+In a function call, type argument can be set explicitly or implicitly:
```typescript
// Explicit type argument
@@ -1476,7 +1567,8 @@ console.log(last([1, 2, 3]))
## Generic Defaults
Type parameters of generic types can have defaults.
-It allows not specifying the actual type arguments but using just the generic type name.
+It allows using just the generic type name instead of specifying the actual
+type arguments.
Example below illustrates this for both classes and functions.
```typescript
@@ -1497,9 +1589,10 @@ foo<number>()
# Null Safety
-All types in ArkTS by default are non-nullable, so the value of a type cannot be null.
+All types in ArkTS by default are non-nullable, so the value of a type
+cannot be null.
It is similar to TypeScript behavior in strict null checking mode
-(`strictNullChecks`), but the rules are stricter, and the there is no `undefined` type in ArkTS.
+(`strictNullChecks`), but the rules are stricter.
In the example below, all lines cause a compile-time error:
@@ -1522,7 +1615,8 @@ if (x != null) { /* do something */ }
A postfix operator `!` can be used to assert that its operand is non-null.
-If applied to a null value, the operator throws an error. Otherwise, the type of the value is changed from `T | null` to `T`:
+If applied to a null value, the operator throws an error. Otherwise, the
+type of the value is changed from `T | null` to `T`:
```typescript
let x: number | null = 1
@@ -1533,12 +1627,15 @@ y = x! + 1 // ok
## Null-Coalescing Operator
-The null-coalescing binary operator `??` checks whether the evaluation of the left-hand-side expression is equal to null.
-If it is, then the result of the expression is the right-hand-side expression; otherwise, it is the left-hand-side expression.
+The null-coalescing binary operator `??` checks whether the evaluation
+of the left-hand-side expression is equal to null.
+If it is, then the result of the expression is the right-hand-side expression;
+otherwise, it is the left-hand-side expression.
In other words, `a ?? b` equals the ternary operator `a != null ? a : b`.
-In the following example, the method `getNick` returns a nickname if it is set; otherwise, empty string is returned:
+In the following example, the method `getNick` returns a nickname if it is
+set; otherwise, an empty string is returned:
```typescript
class Person {
@@ -1552,46 +1649,72 @@ class Person {
## Optional Chaining
-Optional chaining operator `?.` allows writing code where the evaluation stops of an expression that is partially evaluated to `null`.
+Optional chaining operator `?.` allows writing code where the evaluation
+stops at an expression that is partially evaluated to `null` or `undefined`.
```typescript
class Person {
- // ...
- spouse: Person | null = null
- nick: string | null = null
- getSpouseNick(): string | null {
+ nick : string | null = null
+ spouse ?: Person
+
+ setSpouse(spouse: Person) : void {
+ this.spouse = spouse
+ }
+
+ getSpouseNick(): string | null | undefined {
return this.spouse?.nick
}
+
+ constructor(nick: string) {
+ this.nick = nick
+ this.spouse = undefined
+ }
}
```
-**Note**: that the return type of `getSpouseNick` must be `string | null`, as the method may return null.
+**Note**: the return type of `getSpouseNick` must be `string | null | undefined`, as
+the method can return null or undefined.
-An optional chain may be of any length and contain any number of `?.`
+An optional chain can be of any length and contain any number of `?.`
operators.
-In the following sample, the output is a person’s spouse nickname if the person has a spouse, and the spouse has a nickname.
+In the following sample, the output is a person’s spouse nickname if that
+person has a spouse, and the spouse has a nickname.
-Otherwise, the output is `null`:
+Otherwise, the output is `undefined`:
```typescript
-let p: Person = ...
-console.log(p?.spouse?.nick)
+class Person {
+ nick : string | null = null
+ spouse ?: Person
+
+ constructor(nick: string) {
+ this.nick = nick
+ this.spouse = undefined
+ }
+}
+
+let p: Person = new Person("Alice")
+console.log(p.spouse?.nick) // print: undefined
```
# Modules
Programs are organized as sets of compilation units or modules.
-Each module creates its own scope, i.e., any declarations (variables, functions, classes, etc.) declared in the module are not visible outside that module unless they are explicitly exported.
+Each module creates its own scope, i.e., any declarations (variables,
+functions, classes, etc.) declared in the module are not visible outside
+that module unless they are explicitly exported.
-Conversely, a variable, function, class, interface, etc. exported from another module must first be imported to a module.
+Conversely, a variable, function, class, interface, etc. exported from
+another module must first be imported to a module.
## Export
A top-level declaration can be exported by using the keyword `export`.
-A declared name that is not exported is considered private and can be used only in the module where it is declared.
+A declared name that is not exported is considered private and can be used
+only in the module where it is declared.
```typescript
export class Point {
@@ -1610,16 +1733,21 @@ export function Distance(p1: Point, p2: Point): number {
## Import
-Import declarations are used to import entities exported from other modules and provide their bindings in the current module. An import declaration consists of two parts:
+Import declarations are used to import entities exported from other modules
+and provide their bindings in the current module. An import declaration
+consists of two parts:
* Import path that determines the module to import from;
-* Import bindings that define the set of usable entities in the imported module and the form of use i.e., qualified or unqualified use.
+* Import bindings that define the set of usable entities in the imported
+ module, and the form of use (i.e., qualified or unqualified use).
Import bindings may have several forms.
Let’s assume a module has the path ‘./utils’ and export entities ‘X’ and ‘Y’.
-An import binding of the form `* as A` binds the name ‘A’, and all entities exported from the module defined by the import path can be accessed by using the qualified name `A.name`:
+An import binding of the form `* as A` binds the name ‘A’, and all entities
+exported from the module defined by the import path can be accessed by using
+the qualified name `A.name`:
```typescript
import * as Utils from "./utils"
@@ -1627,7 +1755,8 @@ Utils.X // denotes X from Utils
Utils.Y // denotes Y from Utils
```
-An import binding of the form `{ ident1, ..., identN }` binds an exported entity with a specified name, which can be used as a simple name:
+An import binding of the form `{ ident1, ..., identN }` binds an exported
+entity with a specified name, which can be used as a simple name:
```typescript
import { X, Y } from "./utils"
@@ -1635,7 +1764,8 @@ X // denotes X from Utils
Y // denotes Y from Utils
```
-If a list of identifiers contains aliasing of the form `ident as alias`, then entity `ident` is bound under the name `alias`:
+If a list of identifiers contains aliasing of the form `ident as alias`,
+then entity `ident` is bound under the name `alias`:
```typescript
import { X as Z, Y } from "./utils"
@@ -1648,12 +1778,17 @@ X // Compile-time error: 'X' is not visible
A module can contain any statements at the module level, except `return` ones.
-If a module contains a `main` function (program entry point) then top-level statements of the module are executed immediately before the body of this function.
-Otherwise, they are executed before execution of any other function of the module.
+If a module contains a `main` function (program entry point), then
+top-level statements of the module are executed immediately before
+the body of this function.
+Otherwise, they are executed before execution of any other function
+of the module.
## Program Entry Point
-An entry point of a program (application) is the top-level `main` function. The `main` function should have either an empty parameter list or a single parameter of `string[]` type.
+An entry point of a program (application) is the top-level `main` function.
+The `main` function must have either an empty parameter list or a single
+parameter of `string[]` type.
```typescript
function main() {
@@ -1664,16 +1799,16 @@ function main() {
# Support for ArkUI
This section demonstrates mechanisms that ArkTS provides for
-creating graphical user interface (GUI) programs. The section is based on the
-ArkUI declarative framework. ArkUI provides a set of extensions of the standard
-TypeScript to declaratively describe the GUI of the applications and the interaction
-between the GUI components.
+creating graphical user interface (GUI) programs. The section is based on
+the ArkUI declarative framework. ArkUI provides a set of extensions of
+the standard TypeScript to declaratively describe the GUI of the applications
+and the interaction between the GUI components.
## ArkUI Example
The following example provides a complete ArkUI-based application as an
-illustration of GUI programming capabilities. For more details about ArkUI
-features, please refer to the ArkUI
+illustration of GUI programming capabilities. For more details of the
+ArkUI features, refer to the ArkUI
[tutorial](arkts-get-started.md).
```typescript
diff --git a/en/application-dev/quick-start/typescript-to-arkts-migration-guide.md b/en/application-dev/quick-start/typescript-to-arkts-migration-guide.md
index 8239982de59eca3128a864092571f3af18657dfd..eb3a47adb6545ddb001689b8374b206703a0b9b3 100644
--- a/en/application-dev/quick-start/typescript-to-arkts-migration-guide.md
+++ b/en/application-dev/quick-start/typescript-to-arkts-migration-guide.md
@@ -12,22 +12,24 @@ categories:
2. **Partially supported features**: some minor code refactoring is needed.
Example: The keyword `let` must be used in place of `var` to declare
variables. Please note that your code will still remain a valid TypeScript code
- after rewriting according to our recipes.
+ after rewriting by our recipes.
3. **Unsupported features**: a greater code refactoring effort can be required.
Example: The type `any` is unsupported, and you are to introduce explicit
typing to your code everywhere `any` is used.
+PageBreak
+
# How to Use The Cookbook
The main goal of this cookbook is to provide recipes for all partially
supported features and explicitly list all unsupported features.
-The document is built on the feature-by-feature basis, and if you do not find
-some feature, you can safely consider it **supported**. Otherwise, a recipe
-will give you a suggestion on how to rewrite your code and work around an
-unsupported case.
+The document is built on the feature-by-feature basis, and if you do not
+find some feature, then you can safely consider it **supported**. Otherwise,
+a recipe will give you a suggestion on how to rewrite your code and work
+around an unsupported case.
-## Recipe explained
+## Recipe Explained
The original TypeScript code containing the keyword `var`:
@@ -38,7 +40,7 @@ function addTen(x: number): number {
}
```
-This code must be rewritten as follows:
+must be rewritten as follows:
```typescript
// Important! This is still valid TypeScript.
@@ -50,40 +52,40 @@ function addTen(x: number): number {
## Status of Unsupported Features
-Currently unsupported are mainly the features which
+Currently unsupported are mainly the features which:
- relate to dynamic typing that degrades runtime performance, or
- require extra support in the compiler, thus degrading project build time.
However, the ArkTS team reserves the right to reconsider the list and
-**shrink** it in the future releases based on the feedback from the developers
-and more real-world data experiments.
+**shrink** it in the future releases based on the feedback from the developers,
+and on more real-world data experiments.
+
+PageBreak
# Recipes Summarized
-This documents provides an informal summary of TypeScript features that ArkTS either
-does not support or supports with limitations. For the full list, with more
-detailed code examples and workaround suggestions, please see
-[this section](#recipes).
+This document provides an informal summary of TypeScript features that ArkTS either
+can support with limitations, or cannot support. See [Recipes](#recipes) for the
+full list with more detailed code examples and workaround suggestions.
-## Static typing is enforced
+## Static Typing is Enforced
-ArkTS was designed with following goals in mind:
+ArkTS was designed with the following goals in mind:
-- It should be easy for developers to read and understand ArkTS programs,
- because the code is read more often than written;
-- ArkTS should execute fast with as little power consumption as possible,
- which is critical for mobile devices which ArkTS targets.
+- ArkTS programs must be easy for developers to read and understand because
+ the code is read more often than written;
+- ArkTS must execute fast and consume as little power as possible because
+ it is particularly critical on mobile devices which ArkTS targets.
-Static typing is one of the most important features of ArkTS, which helps
-achieve both goals. Indeed, if your program is statically typed, i.e. all
-types are known at the compile time, it’s much easier to understand which data
-structures are used in the code. At the same time, since all types are known
-before the program actually runs, code correctness can be verified by the
-compiler, which eliminates many runtime type checks and improves the
-performance.
+One of the most important features of ArkTS that helps achieving both goals
+is static typing. Indeed, if a program is statically typed, i.e. all types
+are known at compile time, then it is much easier to understand what data
+structures are used in the code. That all types are known before the program
+actually runs results in the compiler to verify code correctness, thus
+eliminating many runtime type checks and improving performance.
-Therefore, it was decided to prohibit usage of the type `any`.
+Therefore, the usage of the type `any` in ArkTS is prohibited.
### Example
@@ -112,26 +114,27 @@ if (!res.succeeded()) {
}
```
-### Rationale and impact
+### Rationale and Impact
-Our research and experiments let us conclude that this feature is already
-not welcome in the modern TypeScript. According to our measurements, it is used
-in approximately 1% of TypeScript code bases. Moreover, code linters (e.g., ESLint)
-already include a set of rules that prohibit usage of `any`. Thus, although
-prohibiting `any` requires code refactoring, we consider it a low-effort
-change with the high impact result.
+Our research and experiments let us conclude that `any` is already not welcome
+in TypeScript. According to our measurements, `any` is used in approximately 1% of
+TypeScript codebases. Moreover, today’s code linters (e.g., ESLint) include a set
+of rules that prohibit the usage of `any`.
-## Changing object layout in runtime is prohibited
+Prohibiting `any` results in a strong positive impact on performance at the
+cost of low-effort code refactoring.
-To achieve maximum performance benefits, ArkTS requires that layout of objects
-does not change during program execution. In other words, it is prohibited to:
+## Changing Object Layout in Runtime Is Prohibited
-- add new properties or methods to the objects;
-- delete existing properties or methods from the objects;
+To achieve maximum performance benefits, ArkTS requires the layout of objects
+to not change during program execution. In other words, it is prohibited to:
+
+- add new properties or methods to objects;
+- delete existing properties or methods from objects;
- assign values of arbitrary types to object properties.
-It’s worth noticing that many such operations are already prohibited by the TypeScript
-compiler. However, it still can be “tricked†by e.g. `as any` casts, wchich
+It is noteworthy that many such operations are already prohibited by the TypeScript
+compiler. However, it still can be “trickedâ€, e.g., by `as any` casts that
ArkTS does not support (see the detailed example below).
### Example
@@ -193,29 +196,27 @@ let p6 = new Point(6.0, 6.0)
console.log("Distance between p5 and p6: " + distance(p5, p6))
```
-### Rationale and impact
+### Rationale and Impact
Unpredictable changing of object layout contradicts both good readability and
-good performance of the code. Indeed, having class definition at one place and
+good performance of code. Indeed, having class definition at one place and
modifying actual object layout elsewhere is confusing and error-prone from the
-developer’s point of view. Additionally, it requires extra runtime support,
-which brings undesired execution overhead. Moreover, it contradicts the idea of
-static typing. If we want to make typing as explicit as possible, why would we
-need to add or remove additional properties?
+developer’s point of view. It opposes the idea of static typing (why adding
+or removing additional properties if typing is to be as explicit as possible?)
+and requires extra runtime support that causes undesired execution overhead.
-At the same time, according to our observations and experiments, this feature
-is already not welcome in the modern TypeScript. It is used in the marginal number of
-cases in real-world projects and state of the art linters have rules to
-prohibit its usage.
+According to our observations and experiments, this feature is already not
+welcome in TypeScript: it is used in a marginal number of real-world projects,
+and state-of-the-art linters have rules to prohibit its usage.
-Thus, we conclude that prohibiting runtime changes to objects’ layout results
-in low-effort refactoring with the high positive impact on performance.
+We conclude that prohibiting runtime changes to object layouts results in a
+strong positive impact on performance at the cost of low-effort refactoring.
-## Semantics of operators is restricted
+## Semantics of Operators Is Restricted
To achieve better performance and encourage developers write clearer code,
-ArkTS restricts semantics of some operators. A couple of examples are given
-below, and the full list of restrictions is outlined [here](#recipes).
+ArkTS restricts the semantics of some operators. A couple of examples are
+given below, and the full list of restrictions is outlined in [Recipes](#recipes).
### Example
@@ -229,24 +230,23 @@ let c2 : C = new C()
console.log(c1 + c2) // Compile-time error
```
-### Rationale and impact
+### Rationale and Impact
-Overloading language operators with extra semantics complicates language
-specification and makes developers remember about all possible corner cases
-and their handling rules. Besides, in certain cases it incurs some runtime
-overhead, which is undesired.
+Loading language operators with extra semantics complicates the language
+specification, and forces developers to remember all possible corner cases with
+appropriate handling rules. Besides, in certain cases it causes some undesired
+runtime overhead.
At the same time, according to our observations and experiments, this feature
-is not popular in the modern TypeScript. It is used in less than 1% of real-world
-code bases. Besides, such cases are very easy to refactor.
+is not popular in TypeScript. It is used in less than 1% of real-world codebases,
+and such cases are easy to refactor.
-Thus, although restricting semantics of operators requires changing the code,
-this is a low-effort change which results in a clearer and more performant code.
+Restricting the operator semantics results in a clearer and more performant
+at the cost of low-effort changes in code.
-## Structural typing is not supported (yet)
+## Structural Typing Is Not Supported (Yet)
-Let’s consider a situation when two unrelated classes `T` and `U` have the
-same public API:
+Assuming that two unrelated classes `T` and `U` have the same public API:
```typescript
class T {
@@ -284,31 +284,34 @@ let t : T = new T()
greeter(t) // Is this allowed?
```
-Or, in other words, which approach will we take:
+In other words, which approach will we take:
- `T` and `U` are not related by inheritance or any common interface, but
- since they have the same public API, they are “somewhat equivalentâ€, so the
- answer to both questions above is “yesâ€;
+ they are “somewhat equivalent†since they have the same public API, and so
+ the answer to both questions above is “yesâ€;
- `T` and `U` are not related by inheritance or any common interface, and
- should always be considered as totally different types, so the
- answer to both questions above is “noâ€.
-
-Languages that take the first approach are said to support structural typing,
-while languages that take the second approach do not support it. Currently,
-TypeScript supports structural typing, and ArkTS does not.
-
-It is debatable if structural typing helps produce clear and
-understandable code, arguments can be found both for and against it.
-Moreover, structural typing does not harm program performance (at least in some
-cases). Why is it not supported then?
-
-The answer is that support for structural typing is a major feature which needs
-lots of consideration and careful implementation in language specification,
-compiler and runtime. Safe and efficient implementation requires that other
-aspects (static typing, restrictions on changing object layout) are also
-taken into account. That’s why support for this feature is postponed. The team
-will be ready to reconsider based on real-world scenarios and feedback. More
-cases and suggested workarounds can be found in [Recipes](#recipes).
+ always must be considered as totally different types, so that the answer to
+ both questions above is “noâ€.
+
+The languages that take the first approach are said to support structural
+typing, while the languages that take the second approach do not support it.
+Currently, TypeScript supports structural typing, and ArkTS does not.
+
+It is debatable whether or not structural typing helps to produce code that
+is clearer and more understandable, and both *pro* and *contra* arguments can
+be found. Moreover, structural typing does not harm program performance (at
+least in some cases). Why not support it then?
+
+The answer is that supporting structural typing is a major feature that needs
+a lot of consideration and careful implementation in language specification,
+compiler and runtime. As safe and efficient implementation requires taking
+other aspects (static typing, restrictions on changing object layout) into
+account, the support to this feature is postponed.
+
+The ArkTS team is ready to reconsider based on real-world scenarios and
+feedback. More cases and suggested workarounds can be found in [Recipes](#recipes).
+
+PageBreak
# Recipes
@@ -335,9 +338,9 @@ console.log(x[2])
```typescript
class X {
- public name: number
+ public name: number = 0
}
-let x = {name: 1}
+let x:X = {name: 1}
console.log(x.name)
let y = [1, 2, 3]
@@ -372,7 +375,7 @@ console.log(z.get(2))
TypeScript has `Symbol()` API, which can be used among other things to generate
unique property names at runtime. ArkTS does not support `Symbol()` API
because its most popular use cases make no sense in the statically typed
-environment. In particular, the object layout is defined at compile time
+environment. In particular, the object layout is defined at compile time,
and cannot be changed at runtime.
**TypeScript**
@@ -388,7 +391,7 @@ let o = {
```typescript
class SomeClass {
- public someProperty : string
+ public someProperty : string = ""
}
let o = new SomeClass()
```
@@ -410,15 +413,18 @@ let o = new SomeClass()
**Severity: error**
-ArkTS does not private identifiers started with `#` symbol, use `private`
-keyword instead.
+ArkTS does not use private identifiers starting with the symbol `#`. Use
+the keyword `private` instead.
**TypeScript**
```typescript
+/*
+ * Such notation for private fields is not supported:
class C {
#foo: number = 42
}
+*/
```
**ArkTS**
@@ -458,7 +464,7 @@ type T = number[] // X is not allowed here to avoid name collisions
**Severity: error**
-ArkTS does not support `var`, always use `let` instead.
+ArkTS does not support `var`. Use `let` instead.
**TypeScript**
@@ -507,59 +513,40 @@ scoped_var = 5
scoped_let = 5 // Compile-time error
```
-## Recipe: Use explicit types instead of `any`, `undefined`, `unknown`
+## Recipe: Use explicit types instead of `any`, `unknown`
-**Rule `arkts-no-any-undefined-unknown`**
+**Rule `arkts-no-any-unknown`**
**Severity: error**
-ArkTS does not support `any`, `undefined`, and `unknown` types.
-Specify types explicitly.
+ArkTS does not support the types `any` and `unknown`. Specify
+types explicitly.
**TypeScript**
```typescript
-var x
-console.log(x) // undefined
+let value1 : any
+value1 = true
+value1 = 42
-var y: any
-console.log(y) // undefined
+let value2 : unknown
+value2 = true
+value2 = 42
```
**ArkTS**
```typescript
-// All variables should have their types specified explicitly:
-let x: Object = {}
-console.log(x) // {}
+let value_b: boolean = true // OR: let value_b = true
+let value_n: number = 42 // OR: let value_n = 42
+let value_o1: Object = true
+let value_o2: Object = 42
```
**See also**
* Recipe: Use Object[] instead of tuples
-
-## Recipe: `bigint` is not a builtin type, suffix `n` for numeric literals is not supported
-
-**Rule `arkts-no-n-suffix`**
-
-**Severity: error**
-
-ArkTS supports `bigint` as a part of the standard library, not as a builtin
-type. `n` suffix for numeric literals is not supported, `BigInt` factory
-function can be used to produce values of `bigint` type.
-
-**TypeScript**
-
-```typescript
-let a: bigint = 1n
-```
-
-**ArkTS**
-
-```typescript
-let a = BigInt(1)
-let b: bigint = BigInt(2)
-```
+* Recipe: Strict type checking is enforced
## Recipe: Use `Object[]` instead of tuples
@@ -567,7 +554,7 @@ let b: bigint = BigInt(2)
**Severity: error**
-Currently, ArkTS does not support tuples. You can use arrays of `Object`
+Currently, ArkTS does not support tuples. Use arrays of `Object`
(`Object[]`) to emulate tuples.
**TypeScript**
@@ -679,8 +666,8 @@ function fn(s: string): SomeObject {
**Severity: error**
-ArkTS does not allow to have sevaral static block for class initialization,
-combine static blocks statements to the one static block.
+ArkTS does not allow having sevaral static blocks for class initialization.
+Combine static block statements into one static block.
**TypeScript**
@@ -716,7 +703,7 @@ class C {
**Severity: error**
-ArkTS does not allow indexed signatures, use arrays instead.
+ArkTS does not allow indexed signatures. Use arrays instead.
**TypeScript**
@@ -738,7 +725,7 @@ const secondItem = myArray[1]
```typescript
class X {
- public f: string[]
+ public f: string[] = []
}
let myArray: X = new X()
@@ -751,8 +738,8 @@ const secondItem = myArray.f[1]
**Severity: error**
-Currently, ArkTS does not support intersection types. You can use inheritance
-as a work-around.
+Currently, ArkTS does not support intersection types. Use inheritance
+as a workaround.
**TypeScript**
@@ -764,7 +751,7 @@ interface Identity {
interface Contact {
email: string
- phone: string
+ phoneNumber: string
}
type Employee = Identity & Contact
@@ -780,15 +767,15 @@ interface Identity {
interface Contact {
email: string
- phone: string
+ phoneNumber: string
}
interface Employee extends Identity, Contact {}
```
-## Recipe: Returning `this` type is not supported
+## Recipe: Type notation using `this` is not supported
-**Rule `arkts-no-this-as-return-type`**
+**Rule `arkts-no-typing-with-this`**
**Severity: error**
@@ -800,6 +787,14 @@ ArkTS does not support the returning `this` type. Use explicit type instead.
interface ListItem {
getHead(): this
}
+
+class C {
+ n: number = 0
+
+ m(c: this) {
+ console.log(c)
+ }
+}
```
**ArkTS**
@@ -808,6 +803,14 @@ interface ListItem {
interface ListItem {
getHead(): ListItem
}
+
+class C {
+ n: number = 0
+
+ m(c: C) {
+ console.log(c)
+ }
+}
```
## Recipe: Conditional types are not supported
@@ -817,8 +820,8 @@ interface ListItem {
**Severity: error**
ArkTS does not support conditional type aliases. Introduce a new type with
-constraints explicitly or rewrite logic with use of `Object`. `infer`
-keyword is not supported.
+constraints explicitly, or rewrite logic using `Object`. The keyword
+`infer` is not supported.
**TypeScript**
@@ -842,44 +845,6 @@ type X2<T> = Object
type YI<Item, T extends Array<Item>> = Item
```
-## Recipe: Optional parameters are not supported for primitive types
-
-**Rule `arkts-no-opt-params`**
-
-**Severity: error**
-
-ArkTS does not support optional parameters of primitive types.
-You can use default parameter values or reference types. For reference types,
-non-specified optional parameter is set to `null`.
-
-**TypeScript**
-
-```typescript
-// x is an optional parameter:
-function f(x?: number) {
- console.log(x) // log undefined or number
-}
-
-// x is a required parameter with the default value:
-function g(x: number = 1) {
- console.log(x)
-}
-```
-
-**ArkTS**
-
-```typescript
-// You can use reference type (will be set to null if missing):
-function f(x?: Number) {
- console.log(x) // log null or some number
-}
-
-// You can use a required parameter with the default value:
-function g(x: number = 1) {
- console.log(x)
-}
-```
-
## Recipe: Declaring fields in `constructor` is not supported
**Rule `arkts-no-ctor-prop-decls`**
@@ -887,7 +852,7 @@ function g(x: number = 1) {
**Severity: error**
ArkTS does not support declaring class fields in the `constructor`.
-You must declare them inside the `class` declaration instead.
+Declare class fields inside the `class` declaration instead.
**TypeScript**
@@ -929,7 +894,7 @@ class Person {
}
```
-## Recipe: Construct signatures not supported in interfaces
+## Recipe: Construct signatures are not supported in interfaces
**Rule `arkts-no-ctor-signatures-iface`**
@@ -1019,11 +984,11 @@ let x = p.x
**Severity: error**
Currently, ArkTS does not support structural identity, i.e., the compiler
-cannot compare two types’ public APIs and decide whether such types are
+cannot compare public APIs of two types and decide whether such types are
identical. Use other mechanisms (inheritance, interfaces or type aliases)
instead.
-For the examples below, types `X` and `Y` are equivalent (interchangeble)
+In the examples below, types `X` and `Y` are equivalent (interchangeble)
in TypeScript, while in ArkTS they are not.
**TypeScript**
@@ -1061,7 +1026,7 @@ type Y = X // Y is equal to X
**Severity: error**
Currently, ArkTS does not check structural equivalence for type inference,
-i.e., the compiler cannot compare two types’ public APIs and decide whether
+i.e., the compiler cannot compare public APIs of two types and decide whether
such types are identical. Use other mechanisms (inheritance or interfaces)
instead.
@@ -1135,8 +1100,8 @@ x = y // ok, X is the super class of Y
**Severity: error**
Currently, ArkTS does not check structural equivalence when checking if types
-are assignable to each other, i.e., the compiler cannot compare two types’
-public APIs and decide whether such types are identical. Use other mechanisms
+are assignable to each other, i.e., the compiler cannot compare public APIs of
+two types and decide whether such types are identical. Use other mechanisms
(inheritance or interfaces) instead.
**TypeScript**
@@ -1208,56 +1173,6 @@ x = y // ok, both are of the same type
* Recipe: Structural typing is not supported for subtyping / supertyping
* Recipe: Structural typing is not supported for type inference
-## Recipe: Optional properties are not supported for primitive types
-
-**Rule `arkts-no-opt-props`**
-
-**Severity: error**
-
-ArkTS does not support optional properties of primitive types. You can use
-properties with default values or reference types. For reference types,
-non-specified optional property is set to `null`. This rule applies both to
-classes and interfaces.
-
-**TypeScript**
-
-```typescript
-class CompilerOptions {
- strict?: boolean
- sourcePath?: string
- targetPath?: string
-}
-
-let options: CompilerOptions = {
- strict: true,
- sourcePath: "./src"
-}
-
-if (options.targetPath == undefined) {
- // Some logic
-}
-```
-
-**ArkTS**
-
-```typescript
-class CompilerOptions {
- strict: boolean = false
- sourcePath: string = ""
- targetPath?: string
-}
-
-let options: CompilerOptions = {
- strict: true,
- sourcePath: "./src"
- // targetPath is implicitly set to null
-}
-
-if (options.targetPath == null) {
- // Some logic
-}
-```
-
## Recipe: Type inference in case of generic function calls is limited
**Rule `arkts-no-inferred-generic-params`**
@@ -1265,8 +1180,8 @@ if (options.targetPath == null) {
**Severity: error**
ArkTS allows to omit generic type parameters if it is possible to infer
-the concrete types from the parameters passed to the function. Otherwise a
-compile-time error occurs. In particular, inference of generic type parameters
+the concrete types from the parameters passed to the function. A compile-time
+error occurs otherwise. In particular, inference of generic type parameters
based only on function return types is prohibited.
**TypeScript**
@@ -1282,7 +1197,7 @@ let y = choose("10", 20) // Compile-time error
function greet<T>(): T {
return "Hello" as T
}
-let z = greet() // Type of x is inferred as "unknown"
+let z = greet() // Type of T is inferred as "unknown"
```
**ArkTS**
@@ -1308,7 +1223,7 @@ let z = greet<string>()
**Severity: error**
Currently, ArkTS does not support structural typing, i.e., the compiler cannot
-compare two types’ public APIs and decide whether such types are identical.
+compare public APIs of two types and decide whether such types are identical.
Use inheritance and interfaces to specify the relation between the types
explicitly.
@@ -1402,8 +1317,8 @@ bar(new Y(2))
**Severity: error**
-Currently, ArkTS does not support RegExp literals. Use library call with string
-literals instead.
+Currently, ArkTS does not support RegExp literals. Use library call with
+string literals instead.
**TypeScript**
@@ -1424,9 +1339,9 @@ let regex: RegExp = new RegExp("/bc*d/")
**Severity: error**
ArkTS supports usage of object literals if the compiler can infer to what
-classes or interfaces such literals correspond to. Otherwise, a compile-time
-error occurs. Specifically, using literals to initialize classes and interfaces
-is not supported in following contexts:
+classes or interfaces such literals correspond to. A compile-time error
+occurs otherwise. Using literals to initialize classes and interfaces is
+specifically not supported in the following contexts:
* Initialization of anything that has `any`, `Object`, or `object` type
* Initialization of classes or interfaces with methods
@@ -1579,8 +1494,8 @@ type S = Set<{x: number, y: number}>
```typescript
class O {
- x: number
- y: number
+ x: number = 0
+ y: number = 0
}
let o: O = {x: 2, y: 3}
@@ -1600,8 +1515,8 @@ type S = Set<O>
**Severity: error**
Basically, ArkTS infers the type of an array literal as a union type of its
-contents. But if there is at least one element with a non-inferrable type
-(e.g. untyped object literal), a compile-time error occurs.
+contents. However, a compile-time error occurs if there is at least one
+element with a non-inferrable type (e.g. untyped object literal).
**TypeScript**
@@ -1638,7 +1553,8 @@ to be explicitly specified.
**TypeScript**
```typescript
-let f = (s) => { // type any is assumed
+// Compile-time error only with noImplicitAny:
+let f = (s /* type any is assumed */) => {
console.log(s)
}
```
@@ -1658,8 +1574,8 @@ let f = (s: string) => {
**Severity: error**
-ArkTS does not support function expressions, use arrow functions instead
-to be explicitly specified.
+ArkTS does not support function expressions. Use arrow functions instead
+to specify explicitly.
**TypeScript**
@@ -1710,19 +1626,19 @@ generic_func<String>("string")
**Severity: error**
-ArkTS does not support class literals. A new named class type must be
-introduced explicitly.
+ArkTS does not support class literals. Introduce new named class types
+explicitly.
**TypeScript**
```typescript
const Rectangle = class {
constructor(height: number, width: number) {
- this.heigth = height
+ this.height = height
this.width = width
}
- heigth
+ height
width
}
@@ -1734,11 +1650,11 @@ const rectangle = new Rectangle(0.0, 0.0)
```typescript
class Rectangle {
constructor(height: number, width: number) {
- this.heigth = height
+ this.height = height
this.width = width
}
- heigth: number
+ height: number
width: number
}
@@ -1770,7 +1686,7 @@ class C1 implements C {
```typescript
interface C {
- foo()
+ foo(): void
}
class C1 implements C {
@@ -1786,7 +1702,7 @@ class C1 implements C {
ArkTS supports accessing only those class properties that are either declared
in the class, or accessible via inheritance. Accessing any other properties is
-prohibited and causes compile-time errors. Use proper types to check property
+prohibited, and causes compile-time errors. Use proper types to check property
existence during compilation.
**TypeScript**
@@ -1796,7 +1712,7 @@ let person = {name: "Bob", isEmployee: true}
let n = person["name"]
let e = person["isEmployee"]
-let s = person["office"] // undefined
+let s = person["office"] // Compile-time error only with noImplicitAny
```
**ArkTS**
@@ -1835,10 +1751,13 @@ let s = person.office // Compile-time error
**Severity: error**
-ArkTS supports `as` keyword as the only syntax for type casts.
+ArkTS supports the keyword `as` as the only syntax for type casts.
Incorrect cast causes a compile-time error or runtime `ClassCastException`.
`<type>` syntax for type casts is not supported.
+Use the expression `new ...` instead of `as` if a **primitive** type
+(e.g., a `number` or a `boolean`) must be cast to the reference type.
+
**TypeScript**
```typescript
@@ -1858,6 +1777,14 @@ let c2 = createShape() as Circle
// nor during runtime if cast is wrong:
let c3 = createShape() as Square
console.log(c3.y) // undefined
+
+// Important corner case for casting primitives to the boxed counterparts:
+// The left operand is not properly boxed here in in runtime
+// because "as" has no runtime effect in TypeScript
+let e1 = (5.0 as Number) instanceof Number // false
+
+// Number object is created and instanceof works as expected:
+let e2 = (new Number(5.0)) instanceof Number // true
```
**ArkTS**
@@ -1875,6 +1802,9 @@ let c2 = createShape() as Circle
// ClassCastException during runtime is thrown:
let c3 = createShape() as Square
+
+// Number object is created and instanceof works as expected:
+let e2 = (new Number(5.0)) instanceof Number // true
```
## Recipe: JSX expressions are not supported
@@ -1899,45 +1829,14 @@ be done explicitly.
**TypeScript**
```typescript
-let a = +5 // 5 as number
-let b = +"5" // 5 as number
-let c = -5 // -5 as number
-let d = -"5" // -5 as number
-let e = ~5 // -6 as number
-let f = ~"5" // -6 as number
+let a = +5 // 5 as number
+let b = +"5" // 5 as number
+let c = -5 // -5 as number
+let d = -"5" // -5 as number
+let e = ~5 // -6 as number
+let f = ~"5" // -6 as number
let g = +"string" // NaN as number
-```
-
-**ArkTS**
-
-```typescript
-let a = +5 // 5 as number
-let b = +"5" // Compile-time error
-let c = -5 // -5 as number
-let d = -"5" // Compile-time error
-let e = ~5 // -6 as number
-let f = ~"5" // Compile-time error
-let g = +"string" // Compile-time error
-```
-
-**See also**
-
-* Recipe: Binary operators \*, /, %, -, <<, >>, >>>, &, ^ and | work only on numeric types
-* Recipe: Binary + operator supports implicit casts only for numbers and strings
-
-## Recipe: Unary `+` cannot be used for casting to `number`
-
-**Rule `arkts-no-unary-plus-cast`**
-
-**Severity: error**
-
-ArkTS does not support casting from any type to a numeric type
-by using the unary `+` operator, which can be applied only to
-numeric types.
-
-**TypeScript**
-```typescript
function returnTen(): string {
return "-10"
}
@@ -1946,13 +1845,21 @@ function returnString(): string {
return "string"
}
-let a = +returnTen() // -10 as number
-let b = +returnString() // NaN
+let x = +returnTen() // -10 as number
+let y = +returnString() // NaN
```
**ArkTS**
```typescript
+let a = +5 // 5 as number
+let b = +"5" // Compile-time error
+let c = -5 // -5 as number
+let d = -"5" // Compile-time error
+let e = ~5 // -6 as number
+let f = ~"5" // Compile-time error
+let g = +"string" // Compile-time error
+
function returnTen(): string {
return "-10"
}
@@ -1961,16 +1868,10 @@ function returnString(): string {
return "string"
}
-let a = +returnTen() // Compile-time error
-let b = +returnString() // Compile-time error
+let x = +returnTen() // Compile-time error
+let y = +returnString() // Compile-time error
```
-**See also**
-
-* Recipe: Unary operators +, - and ~ work only on numbers
-* Recipe: Binary operators \*, /, %, -, <<, >>, >>>, &, ^ and | work only on numeric types
-* Recipe: Binary + operator supports implicit casts only for numbers and strings
-
## Recipe: `delete` operator is not supported
**Rule `arkts-no-delete`**
@@ -1999,8 +1900,8 @@ delete p.y
// and assign null to mark value absence:
class Point {
- x: number | null
- y: number | null
+ x: number | null = 0
+ y: number | null = 0
}
let p = new Point()
@@ -2023,8 +1924,8 @@ p.y = null
**Severity: error**
-ArkTS supports `typeof` operator only in the expression context. Specifying
-type notations using `typeof` is not supported.
+ArkTS supports `typeof` operator only in the expression context. Using
+`typeof` to specify type notations is not supported.
**TypeScript**
@@ -2059,77 +1960,19 @@ let s2: string
* Recipe: Dynamic property declaration is not supported
* Recipe: Usage of standard library is restricted
-## Recipe: Binary operators `*`, `/`, `%`, `-`, `<<`, `>>`, `>>>`, `&`, `^` and `|` work only on numeric types
-
-**Rule `arkts-no-polymorphic-binops`**
-
-**Severity: error**
-
-ArkTS allows applying binary operators `*`, `/`, `%`, `-`, `<<`,
-`>>`, `>>>`, `&`, `^` and `|` only to values of numeric types.
-Implicit casts from other types to numeric types are prohibited and cause
-compile-time errors.
-
-**TypeScript**
-
-```typescript
-let a = (5 & 5) // 5
-let b = (5.5 & 5.5) // 5, not 5.5
-let c = (5 | 5) // 5
-let d = (5.5 | 5.5) // 5, not 5.5
-
-enum Direction {
- Up = -1,
- Down
-}
-let e = Direction.Up >> 1 // -1
-let f = Direction.Up >>> 1 // 2147483647
-
-let g = ("10" as any) << 1 // 20
-let h = ("str" as any) << 1 // 0
-
-let i = 10 * 5
-let j = 10 / 5
-let k = 10 % 5
-let l = 10 - 5
-```
-
-**ArkTS**
-
-```typescript
-let a = (5 & 5) // 5
-let b = (5.5 & 5.5) // Compile-time error
-let c = (5 | 5) // 5
-let d = (5.5 | 5.5) // Compile-time error
-
-enum Direction {
- Up,
- Down
-}
-
-let e = Direction.Up >> 1 // 0
-let f = Direction.Up >>> 1 // 0
-
-let i = 10 * 5
-let j = 10 / 5
-let k = 10 % 5
-let l = 10 - 5
-```
-
-**See also**
-
-* Recipe: Unary operators +, - and ~ work only on numbers
-* Recipe: Unary + cannot be used for casting to number
-* Recipe: Binary + operator supports implicit casts only for numbers and strings
-
-## Recipe: Binary `+` operator supports implicit casts only for numbers and strings
+## Recipe: Binary `+` operator supports implicit casts only for numbers, enums and strings
**Rule `arkts-no-polymorphic-plus`**
**Severity: error**
-ArkTS supports implicit casts for `+` only for strings and numbers.
-Elsewhere, any form of an explicit cast to string is required.
+If one of the operands of the binary `+` operator is of the string type
+(including enum string constant), then the other operand can be of any type,
+and its value is implicitly converted to string.
+Otherwise, ArkTS supports implicit casts with `+` only for numbers and
+numeric enum constants.
+ArkTS, like TypeScript, does not support the operator `+` for the booleans.
+Elsewhere, any form of an explicit cast is required.
**TypeScript**
@@ -2145,6 +1988,10 @@ let e = "Hello, " + "world!" // "Hello, world!"
let f = "string" + true // "stringtrue"
let g = (new Object()) + "string" // "[object Object]string"
+
+let i = true + true // JS: 2, TS: compile-time error
+let j = true + 2 // JS: 3, TS: compile-time error
+let k = E.E1 + true // JS: 1, TS: compile-time error
```
**ArkTS**
@@ -2161,13 +2008,16 @@ let e = "Hello, " + "world!" // "Hello, world!"
let f = "string" + true // "stringtrue"
let g = (new Object()).toString() + "string"
+
+
+let i = true + true // compile-time error
+let j = true + 2 // compile-time error
+let k = E.E1 + true // compile-time error
```
**See also**
* Recipe: Unary operators +, - and ~ work only on numbers
-* Recipe: Unary + cannot be used for casting to number
-* Recipe: Binary operators \*, /, %, -, <<, >>, >>>, &, ^ and | work only on numeric types
## Recipe: `instanceof` operator is partially supported
@@ -2175,40 +2025,38 @@ let g = (new Object()).toString() + "string"
**Severity: error**
-In TypeScript, the left-hand side of an `instanceof` expression must be of type
-`any`, an object type or a type parameter, otherwise the result is `false`.
-In ArkTS, the left-hand side expression may be of any reference type, otherwise
-a compile-time error occurs. In addition, the left operand in ArkTS cannot be
-a type.
+In TypeScript, the left-hand side of an `instanceof` expression must be of the type
+`any`, an object type or a type parameter; the result is `false` otherwise.
+In ArkTS, the left-hand side expression may be of any reference type;
+a compile-time error occurs otherwise. In addition, the left operand in ArkTS
+cannot be a type.
**TypeScript**
```typescript
-class X {}
+class X {
+ // ...
+}
let a = (new X()) instanceof Object // true
-let b = (new X()) instanceof X // true
-// left operand is a type:
-let c = X instanceof Object // true
-let d = X instanceof X // false
+let b = (new X()) instanceof X // true
-// left operand is not of type any
-let e = (5.0 as Number) instanceof Number // false
+let c = X instanceof Object // true, left operand is a type
+let d = X instanceof X // false, left operand is a type
```
**ArkTS**
```typescript
-class X {}
+class X {
+ // ...
+}
let a = (new X()) instanceof Object // true
-let b = (new X()) instanceof X // true
-// left operand is a type:
-let c = X instanceof Object // Compile-time error
-let d = X instanceof X // Compile-time error
+let b = (new X()) instanceof X // true
-// left operand may be of any reference type, like number
-let e = (5.0 as Number) instanceof Number // true
+let c = X instanceof Object // Compile-time error, left operand is a type
+let d = X instanceof X // Compile-time error, left operand is a type
```
## Recipe: `in` operator is not supported
@@ -2217,9 +2065,9 @@ let e = (5.0 as Number) instanceof Number // true
**Severity: error**
-ArkTS does not support the `in` operator. However, this operator makes
-little sense since the object layout is known at compile time and cannot
-be modified at runtime. Use `instanceof` as a work-around if you still need
+ArkTS does not support the operator `in`. However, this operator makes
+little sense since the object layout is known at compile time, and cannot
+be modified at runtime. Use `instanceof` as a workaround if you still need
to check whether certain class members exist.
**TypeScript**
@@ -2261,8 +2109,8 @@ let b = p instanceof Person // true, and "name" is guaranteed to be present
**Severity: error**
-ArkTS does not support destructuring assignment. Other idioms (e.g.,
-using a temporary variable, where applicable) can be used for replacement.
+ArkTS does not support destructuring assignment. Use other idioms (e.g.,
+a temporary variable, where applicable) for replacement.
**TypeScript**
@@ -2285,11 +2133,11 @@ let tmp = one
one = two
two = tmp
-let data: Number[] = [1,2,3,4]
+let data: Number[] = [1, 2, 3, 4]
let head = data[0]
-let tail = new Number[data.length - 1]
+let tail: Number[] = []
for (let i = 1; i < data.length; ++i) {
- tail[i - 1] = data[i]
+ tail.push(data[i])
}
```
@@ -2378,9 +2226,9 @@ let y = zp.y
**Severity: error**
-Currently, ArkTS does not support inference of implied types. Use explicit
-type notation instead. Use `Object[]` if you need containers that hold
-data of mixed types.
+Currently, ArkTS does not support inference of implied types.
+Use explicit type notation instead.
+Use `Object[]` if you need containers that hold data of mixed types.
**TypeScript**
@@ -2407,9 +2255,8 @@ let c1 = arr[2]
**Severity: error**
-In TypeScript catch clause variable type annotation must be `any` or `unknown`
-if specified. As ArkTS does not support these types, a type annotation should
-be omitted.
+In TypeScript, catch clause variable type annotation must be `any` or `unknown`
+if specified. As ArkTS does not support these types, omit type annotations.
**TypeScript**
@@ -2417,7 +2264,9 @@ be omitted.
try {
// some code
}
-catch (a: unknown) {}
+catch (a: unknown) {
+ // handle error
+}
```
**ArkTS**
@@ -2426,7 +2275,9 @@ catch (a: unknown) {}
try {
// some code
}
-catch (a) {}
+catch (a) {
+ // handle error
+}
```
**See also**
@@ -2441,8 +2292,8 @@ catch (a) {}
ArkTS does not support the iteration over object contents by the
`for .. in` loop. For objects, iteration over properties at runtime is
-considered redundant because object layout is known at compile time and cannot
-change at runtime. For arrays, you can iterate with the regular `for` loop.
+considered redundant because object layout is known at compile time, and
+cannot change at runtime. For arrays, iterate with the regular `for` loop.
**TypeScript**
@@ -2469,7 +2320,7 @@ for (let i = 0; i < a.length; ++i) {
## Recipe: Iterable interfaces are not supported
-**Rule `arkts-noiterable`**
+**Rule `arkts-no-iterable`**
**Severity: error**
@@ -2505,7 +2356,7 @@ for (let s of a) {
```typescript
let a: Set<number> = new Set([1, 2, 3])
-let numbers = a.values()
+let numbers = Array.from(a.values())
for (let n of numbers) {
console.log(n)
}
@@ -2523,7 +2374,7 @@ for (let n of numbers) {
**Severity: error**
ArkTS does not support mapped types. Use other language idioms and regular
-classes to achieve the same behaviour.
+classes to achieve that same behaviour.
**TypeScript**
@@ -2558,7 +2409,23 @@ class CFlags {
**Severity: error**
ArkTS does not support the `with` statement. Use other language idioms
-(including fully qualified names of functions) to achieve the same behaviour.
+(including fully qualified names of functions) to achieve that same behaviour.
+
+**TypeScript**
+
+```typescript
+with (Math) { // Compile-time error, but JavaScript code still emitted
+ let r: number = 42
+ console.log("Area: ", PI * r * r)
+}
+```
+
+**ArkTS**
+
+```typescript
+let r: number = 42
+console.log("Area: ", Math.PI * r * r)
+```
## Recipe: Values computed at runtime are not supported in `case` statements
@@ -2688,6 +2555,7 @@ explicitly.
**TypeScript**
```typescript
+// Compile-time error with noImplicitAny
function f(x: number) {
if (x <= 0) {
return x
@@ -2695,6 +2563,7 @@ function f(x: number) {
return g(x)
}
+// Compile-time error with noImplicitAny
function g(x: number) {
return f(x - 1)
}
@@ -2718,8 +2587,8 @@ function f(x: number) : number {
return g(x)
}
-// Explicit return type is required:
-function g(x: number) : number {
+// Return type may be omitted, it is inferred from f's explicit type:
+function g(x: number) {
return f(x - 1)
}
@@ -2738,8 +2607,8 @@ console.log(doOperation(2, 3))
**Severity: error**
-ArkTS requires that parameters must be passed directly to the function, and
-local names must be assigned manually.
+ArkTS requires parameters to be passed directly to the function, and
+local names to be assigned manually.
**TypeScript**
@@ -2824,7 +2693,7 @@ ArkTS does not support the usage of `this` inside stand-alone functions.
```typescript
function foo(i: number) {
- this.count = i
+ this.count = i // Compile-time error only with noImplicitThis
}
class A {
@@ -2983,7 +2852,7 @@ function main(): void {
**Severity: error**
ArkTS has no keyof operator because the object layout is defined
-at compile time and cannot be changed at runtime. Object fields can only be
+at compile time, and cannot be changed at runtime. Object fields can only be
accessed directly.
**TypeScript**
@@ -3021,7 +2890,6 @@ function getPropertyValue(obj: Point, key: string): number {
return obj.y
}
throw new Error() // No such property
- return 0
}
function main(): void {
@@ -3038,7 +2906,7 @@ function main(): void {
**Severity: error**
The only supported scenario for the spread operator is to spread an array into
-the rest parameter. Otherwise manually “unpack†data from arrays and objects,
+the rest parameter. Otherwise, manually “unpack†data from arrays and objects,
where necessary.
**TypeScript**
@@ -3097,15 +2965,15 @@ console.log(p3d.x, p3d.y, p3d.z)
## Recipe: Interface declarations (extends same property)
-**Rule `arkts-no-extend-same-property`**
+**Rule `arkts-no-extend-same-prop`**
**Severity: error**
-In TypeScript, an interface that extends two other interfaces with the same method,
+In TypeScript, an interface that extends two other interfaces with the same method
must declare that method with a combined result type. It is not allowed in
ArkTS because ArkTS does not allow an interface to contain two methods with
signatures that are not distinguishable, e.g., two methods that have the same
-parameter lists, but different return types.
+parameter lists but different return types.
**TypeScript**
@@ -3198,8 +3066,8 @@ class C implements Mover, Shaker {
**Severity: error**
-ArkTS does not support merging declratations. All definitions of classes,
-interfaces and so on must be kept compact in the code base.
+ArkTS does not support merging declratations. Keep all definitions of classes,
+interfaces and so on compact in the codebase.
**TypeScript**
@@ -3270,11 +3138,13 @@ interface SelectableControl extends Control {
**Severity: error**
-ArkTS requires that object layout is determined in compile-time and cannot
-be changed at runtime. There for no runtime property-based checks are supported.
-If you need to do a type cast, use `as` operator and use desired properties
-and methods. If some property doesn’t exist then an attempt to reference it
-will result in a compile-time error.
+ArkTS requires that object layout is determined at compile time, and cannot
+be changed at runtime. Therefore, property-based runtime checks are not
+supported.
+If you need to do a type cast, use the operator `as` with desired properties
+and methods.
+If some property does not exist, then an attempt to refer to it causes a
+compile-time error.
**TypeScript**
@@ -3385,10 +3255,10 @@ const person = createPerson(Impersonizer, "John", 30)
**Severity: error**
-ArkTS does not support dynamic property declaration. All object properties must
-be declared immediately in the class. While it can be replaced with an array
-of objects, it is still better to adhere to the static language paradigm and
-declare fields, their names and types explicitly.
+ArkTS does not support dynamic property declaration. Declare all object
+properties immediately in the class. While replacement for an array of
+objects is possible, it is still better to adhere to the static language
+paradigm, and declare fields, their names and types explicitly.
**TypeScript**
@@ -3403,7 +3273,7 @@ const person: Person = {
name: "John",
age: 30,
email: "john@example.com",
- phone: 1234567890,
+ phoneNumber: 1234567890,
}
```
@@ -3414,13 +3284,13 @@ class Person {
name: string
age: number
email: string
- phone: number
+ phoneNumber: number
- constructor(name: string, age: number, email: string, phone: number) {
+ constructor(name: string, age: number, email: string, phoneNumber: number) {
this.name = name
this.age = age
this.email = email
- this.phone = phone
+ this.phoneNumber = phoneNumber
}
}
@@ -3448,7 +3318,7 @@ function main(): void {
ArkTS does not support initializing members of enumerations with expressions
that are evaluated during program runtime. Besides, all explicitly set
-initializers must be of the same time.
+initializers must be of the same type.
**TypeScript**
@@ -3494,8 +3364,8 @@ enum E2 {
**Severity: error**
-ArkTS does not support merging declratations for `enum`.
-The declaration of each `enum` must be kept compact in the code base.
+ArkTS does not support merging declratations for `enum`. Keep the
+declaration of each `enum` compact in the codebase.
**TypeScript**
@@ -3555,26 +3425,6 @@ namespace MyNamespace {
MyNamespace.x = 2
```
-## Recipe: Scripts and modules
-
-**Rule `arkts-no-scripts`**
-
-**Severity: error**
-
-In general, scripts and modules in ArkTS are very close to TypeScript.
-Differences are described in separate recipes.
-
-**See also**
-
-* Recipe: Special import type declarations are not supported
-* Recipe: Importing a module for side-effects only is not supported
-* Recipe: import default as ... is not supported
-* Recipe: require is not supported
-* Recipe: Renaming in export declarations is not supported
-* Recipe: Export list declaration is not supported
-* Recipe: Re-exporting is not supported
-* Recipe: export = ... assignment is not supported
-
## Recipe: Non-declaration statements in namespaces are not supported
**Rule `arkts-no-ns-statements`**
@@ -3621,23 +3471,23 @@ Use ordinary import instead.
```typescript
// Re-using the same import
-import { APIResponseType } from "./api"
+import { APIResponseType } from "api"
// Explicitly use import type
-import type { APIResponseType } from "./api"
+import type { APIResponseType } from "api"
```
**ArkTS**
```typescript
-import { APIResponseType } from "./api"
+import { APIResponseType } from "api"
```
**See also**
* Recipe: Importing a module for side-effects only is not supported
* Recipe: import default as ... is not supported
-* Recipe: require is not supported
+* Recipe: require and import assignment are not supported
## Recipe: Importing a module for side-effects only is not supported
@@ -3689,13 +3539,15 @@ import { default as d } from "mod"
import d from "mod"
```
-## Recipe: `require` is not supported
+## Recipe: `require` and `import` assignment are not supported
**Rule `arkts-no-require`**
**Severity: error**
-ArkTS does not support importing via `require`. Use `import` instead.
+ArkTS does not support importing via `require`.
+`import` assignments are not supported either.
+Use regular `import` instead.
**TypeScript**
@@ -3709,139 +3561,59 @@ import m = require("mod")
import * as m from "mod"
```
-## Recipe: Renaming in export declarations is not supported
-
-**Rule `arkts-no-export-renaming`**
-
-**Severity: error**
-
-ArkTS does not support renaming in export declarations. Similar effect
-can be achieved through setting an alias for the exported entity.
-
-**TypeScript**
-
-```typescript
-// file1.ts
-class MyClass {
- // ...
-}
-
-export { MyClass as RenamedClass }
-
-// file2.ts
-import { RenamedClass } from "./file1"
-
-function main(): void {
- const myObject = new RenamedClass()
- // ...
-}
-```
-
-**ArkTS**
-
-```typescript
-// module1
-class MyClass {
- // ...
-}
-
-export type RenamedClass = MyClass
-
-// module2
-import { RenamedClass } from "./module1"
-
-function main(): void {
- const myObject = new RenamedClass()
- // ...
-}
-```
-
**See also**
-* Recipe: Export list declaration is not supported
-* Recipe: Re-exporting is not supported
* Recipe: export = ... assignment is not supported
-## Recipe: Export list declaration is not supported
+## Recipe: Re-exporting is supported with restrictions
-**Rule `arkts-no-export-list-decl`**
+**Rule `arkts-limited-reexport`**
**Severity: error**
-ArkTS does not support syntax of export list declarations. All exported
-entities must be explicitly annotated with the `export` keyword.
-
-**TypeScript**
-
-```typescript
-export { x }
-export { x } from "mod"
-export { x, y as b, z as c }
-```
-
-**ArkTS**
-
-```typescript
-let x = 1
-class MyClass {}
-export let y = x, z: number = 2
-export RenamedClass = MyClass
-```
-
-**See also**
-
-* Recipe: Renaming in export declarations is not supported
-* Recipe: Re-exporting is not supported
-* Recipe: export = ... assignment is not supported
-
-## Recipe: Re-exporting is not supported
-
-**Rule `arkts-no-reexport`**
-
-**Severity: error**
-
-ArkTS does not support re-exporting. All desired entities must be
-imported explicitly from the modules that export them.
+ArkTS supports re-exporting syntax which covers most common cases of re-export:
+re-exporting imported entities and re-exporting which is combined with renaming.
+Other syntax flavors like `export * as ...` are not supported.
**TypeScript**
```typescript
// module1
-export class MyClass {
+export class Class1 {
+ // ...
+}
+export class Class2 {
// ...
}
// module2
-export { MyClass } from "module1"
+export * as utilities from "module1"
// consumer module
-import { MyClass } from "module2"
-
-const myInstance = new MyClass()
+import { utilities } from "module2"
```
**ArkTS**
```typescript
// module1
-export class MyClass {
- // ...
+export class Class1 {
+ // ...
+}
+export class C2 {
+ // ...
}
// module2
-// some stuff
+export { Class1 } from "module1"
+export { C2 as Class2 } from "module1"
// consumer module
-import { MyClass } from "module1"
-import * from "module2"
-
-const myInstance = new MyClass()
+import { Class1, Class2 } from "module2"
```
**See also**
-* Recipe: Renaming in export declarations is not supported
-* Recipe: Export list declaration is not supported
* Recipe: export = ... assignment is not supported
## Recipe: `export = ...` assignment is not supported
@@ -3887,30 +3659,47 @@ let p = Pt.origin
**See also**
-* Recipe: Renaming in export declarations is not supported
-* Recipe: Export list declaration is not supported
-* Recipe: Re-exporting is not supported
+* Recipe: require and import assignment are not supported
+* Recipe: Re-exporting is supported with restrictions
-## Recipe: Special export type declarations are not supported
+## Recipe: Special `export type` declarations are not supported
**Rule `arkts-no-special-exports`**
**Severity: error**
-ArkTS does not have a special notation for exporting types.
-Use ordinary export instead.
+ArkTS does not have a special notation for exporting types through
+`export type ...`. Use ordinary export instead.
**TypeScript**
```typescript
-class C {}
-export type { C }
+// Explicitly exported class:
+export class Class1 {
+ // ...
+}
+
+// Declared class later exported through export type ...
+class Class2 {
+ // ...
+}
+
+// This is not supported:
+export type { Class2 }
```
**ArkTS**
```typescript
-export class C {}
+// Explicitly exported class:
+export class Class1 {
+ // ...
+}
+
+// Explicitly exported class:
+export class Class2 {
+ // ...
+}
```
## Recipe: Ambient module declaration is not supported
@@ -3934,7 +3723,7 @@ declare module "someModule" {
```typescript
// Import what you need from the original module
-import { normalize } from "../someModule"
+import { normalize } from "someModule"
```
**See also**
@@ -3948,16 +3737,34 @@ import { normalize } from "../someModule"
**Severity: error**
-ArkTS does not supported wildcards in module names because in ArkTS, import
-is a compile-time, not a runtime feature. Use ordinary export syntax instead.
+ArkTS does not support wildcards in module names because in the language
+import is a compile-time, not a runtime feature.
+Use ordinary export syntax instead.
**TypeScript**
```typescript
+// Declaration:
declare module "*!text" {
const content: string
export default content
}
+
+// Consuming code:
+import fileContent from "some.txt!text"
+```
+
+**ArkTS**
+
+```typescript
+// Declaration:
+declare namespace N {
+ function foo(x: number): number
+}
+
+// Consuming code:
+import * from "module"
+console.log("N.foo called: ", N.foo(42))
```
**See also**
@@ -3972,10 +3779,10 @@ declare module "*!text" {
**Severity: error**
-ArkTS does not support universal module definitions (UMD) because in ArkTS
-there is no concept of “script†(as opposed to “moduleâ€). Besides, in ArkTS
-import is a compile-time, not a runtime feature. Use ordinary syntax for
-`export` and `import` instead.
+ArkTS does not support universal module definitions (UMD) because in the
+language there is no concept of “script†(as opposed to “moduleâ€).
+Besides, in ArkTS import is a compile-time, not a runtime feature.
+Use ordinary syntax for `export` and `import` instead.
**TypeScript**
@@ -3997,7 +3804,7 @@ namespace mathLib {
}
// in program
-import { mathLib } from "./math-lib"
+import { mathLib } from "math-lib"
mathLib.isPrime(2)
```
@@ -4011,19 +3818,19 @@ mathLib.isPrime(2)
**Severity: error**
-ArkTS does not allow to use `.js` extension in module identifiers because it
-has its own mechanisms for interoperating with JavaScript.
+ArkTS does not allow using `.js` extension in module identifiers because
+it has its own mechanisms for interoperating with JavaScript.
**TypeScript**
```typescript
-import { something } from "./module.js"
+import { something } from "module.js"
```
**ArkTS**
```typescript
-import { something } from "./module"
+import { something } from "module"
```
**See also**
@@ -4039,7 +3846,7 @@ import { something } from "./module"
ArkTS does not support `new.target` because there is no concept of runtime
prototype inheritance in the language. This feature is considered not applicable
-to the statically typing.
+to static typing.
**TypeScript**
@@ -4055,6 +3862,20 @@ class CustomError extends Error {
}
```
+**ArkTS**
+
+```typescript
+class CustomError extends Error {
+ constructor(message?: string) {
+ // Call parent's constructor, inheritance chain is static and
+ // cannot be modified in runtime
+ super(message)
+ console.log(this instanceof Error) // true
+ }
+}
+let ce = new CustomError()
+```
+
**See also**
* Recipe: Prototype assignment is not supported
@@ -4066,19 +3887,19 @@ class CustomError extends Error {
**Severity: error**
ArkTS does not support such “runtime†import expressions as `await import...`
-because in ArkTS import is a compile-time, not a runtime feature. Use regular
-import syntax instead.
+because in the language import is a compile-time, not a runtime feature.
+Use regular import syntax instead.
**TypeScript**
```typescript
-const zipUtil = await import("./utils/create-zip-file")
+const zipUtil = await import("utils/create-zip-file")
```
**ArkTS**
```typescript
-import { zipUtil } from "./utils/create-zip-file"
+import { zipUtil } from "utils/create-zip-file"
```
**See also**
@@ -4094,8 +3915,8 @@ import { zipUtil } from "./utils/create-zip-file"
**Severity: error**
ArkTS does not support definite assignment assertions `let v!: T` because
-they are considered an excessive compiler hint. Use declaration with
-initialization instead.
+they are considered an excessive compiler hint.
+Use declaration with initialization instead.
**TypeScript**
@@ -4129,17 +3950,18 @@ console.log("x = " + x)
**Severity: error**
-ArkTS does not support IIFEs as namespace declarations because in ArkTS,
-anonymous functions cannot serve as namespaces. Use regular syntax for
-namespaces instead.
+ArkTS does not support IIFEs as namespace declarations because anonymous
+functions in the language cannot serve as namespaces.
+Use regular syntax for namespaces instead.
**TypeScript**
```typescript
var C = (function() {
- function C(n) {
- this.p = n
+ function C(n: number) {
+ this.p = n // Compile-time error only with noImplicitThis
}
+ C.staticProperty = 0
return C
})()
C.staticProperty = 1
@@ -4161,13 +3983,14 @@ namespace C {
ArkTS does not support prototype assignment because there is no concept of
runtime prototype inheritance in the language. This feature is considered not
-applicable to the static typing.
+applicable to static typing. Mechanism of classes and / or interfaces must
+be used instead to statically “combine†methods to data together.
**TypeScript**
```typescript
-var C = function(p) {
- this.p = p
+var C = function(p: number) {
+ this.p = p // Compile-time error only with noImplicitThis
}
C.prototype = {
@@ -4176,8 +3999,22 @@ C.prototype = {
}
}
-C.prototype.q = function(r) {
- return this.p === r
+C.prototype.q = function(r: number) {
+ return this.p == r
+}
+```
+
+**ArkTS**
+
+```typescript
+class C {
+ p: number = 0
+ m() {
+ console.log(this.p)
+ }
+ q(r: number) {
+ return this.p == r
+ }
}
```
@@ -4211,7 +4048,7 @@ globalThis.abc = 200
export let abc : number = 0
// file2
-import * as M from "../file1"
+import * as M from "file1"
M.abc = 200
```
@@ -4221,15 +4058,18 @@ M.abc = 200
* Recipe: Declaring properties on functions is not supported
* Recipe: Usage of standard library is restricted
-## Recipe: Utility types are not supported
+## Recipe: Some of utility types are not supported
**Rule `arkts-no-utility-types`**
**Severity: error**
Currently ArkTS does not support utility types from TypeScript extensions to the
-standard library (`Omit`, `Partial`, `Readonly`, `Record`, `Pick`,
-etc.).
+standard library (`Omit`, `Pick`, etc.). Exceptions are: `Partial`,
+`Record`.
+
+For the type *Record<K, V>*, the type of an indexing expression *rec[index]* is
+of the type *V | undefined*.
**TypeScript**
@@ -4241,20 +4081,55 @@ type Person = {
}
type QuantumPerson = Omit<Person, "location">
+
+let persons : Record<string, Person> = {
+ "Alice": {
+ name: "Alice",
+ age: 32,
+ location: "Shanghai"
+ },
+ "Bob": {
+ name: "Bob",
+ age: 48,
+ location: "New York"
+ }
+}
+console.log(persons["Bob"].age)
+console.log(persons["Rob"].age) // Runtime exception
```
**ArkTS**
```typescript
class Person {
- name: string
- age: number
- location: string
+ name: string = ""
+ age: number = 0
+ location: string = ""
}
class QuantumPerson {
- name: string
- age: number
+ name: string = ""
+ age: number = 0
+}
+
+type OptionalPerson = Person | undefined
+let persons : Record<string, OptionalPerson> = {
+// Or:
+// let persons : Record<string, Person | undefined> = {
+ "Alice": {
+ name: "Alice",
+ age: 32,
+ location: "Shanghai"
+ },
+ "Bob": {
+ name: "Bob",
+ age: 48,
+ location: "New York"
+ }
+}
+console.log(persons["Bob"]!.age)
+if (persons["Rob"]) { // Explicit value check, no runtime exception
+ console.log(persons["Rob"].age)
}
```
@@ -4303,15 +4178,17 @@ class MyImage {
// ...
}
-function readImage(
+async function readImage(
path: string, callback: (err: Error, image: MyImage) => void
) : Promise<MyImage>
{
- // async implementation
+ // In real world, the implementation is more complex,
+ // involving real network / DB logic, etc.
+ return await new MyImage()
}
function readImageSync(path: string) : MyImage {
- // sync implementation
+ return new MyImage()
}
```
@@ -4325,12 +4202,12 @@ function readImageSync(path: string) : MyImage {
**Severity: error**
-ArkTS does not allow to use standard library functions `Function.apply`,
-`Function.bind`, `Function.call`. These APIs are needed in the standard
+ArkTS does not allow using standard library functions `Function.apply`,
+`Function.bind` and `Function.call`. These APIs are needed in the standard
library to explicitly set `this` parameter for the called function.
-In ArkTS semantics of `this` is restricted to the conventional OOP style,
-and usage of `this` in stand-alone functions is prohibited. Thus these
-functions are excessive.
+In ArkTS the semantics of `this` is restricted to the conventional OOP
+style, and the usage of `this` in stand-alone functions is prohibited.
+Thus these functions are excessive.
**TypeScript**
@@ -4382,7 +4259,7 @@ console.log(person1.fullName())
**Severity: error**
-Currently ArkTS supports `readonly` for properties, but not for parameters.
+Currently, ArkTS supports `readonly` for properties, but not for parameters.
**TypeScript**
@@ -4435,7 +4312,7 @@ let x : string = "hello"
let y : number[] = [10, 20]
class Label {
- text : string
+ text : string = ""
}
// Type 'Label':
@@ -4450,7 +4327,7 @@ let z : Label = {
**Severity: error**
-ArkTS does not support import assertions because in ArkTS, import is a
+ArkTS does not support import assertions because in the language import is a
compile-time, not a runtime feature. So asserting correctness of imported APIs
in runtime does not make sense for the statically typed language. Use ordinary
`import` syntax instead.
@@ -4458,14 +4335,14 @@ in runtime does not make sense for the statically typed language. Use ordinary
**TypeScript**
```typescript
-import { obj } from "./something.json" assert { type: "json" }
+import { obj } from "something.json" assert { type: "json" }
```
**ArkTS**
```typescript
// Correctness of importing T will be checked in compile-time:
-import { something } from "./module"
+import { something } from "module"
```
**See also**
@@ -4480,10 +4357,10 @@ import { something } from "./module"
**Severity: error**
-ArkTS does not allow usage of some APIs from the TypeScript/JavaScript standard library.
-The most part of the restricted APIs relates to manipulating objects in
-dynamic manner, which is not compatible with the static typing. Following APIs
-are prohibited from usage:
+ArkTS does not allow using some APIs from the TypeScript/JavaScript standard library.
+The most part of the restricted APIs relates to manipulating objects in a
+dynamic manner, which is not compatible with static typing. The usage of
+the following APIs is prohibited:
Properties and functions of the global object: `eval`,
`Infinity`, `NaN`, `isFinite`, `isNaN`, `parseFloat`, `parseInt`,
@@ -4526,3 +4403,161 @@ Properties and functions of the global object: `eval`,
* Recipe: Dynamic property declaration is not supported
* Recipe: globalThis is not supported
+## Recipe: Strict type checking is enforced
+
+**Rule `arkts-strict-typing`**
+
+**Severity: error**
+
+Type checker in ArkTS is not optional, the code must be explicitly and
+correctly types to be compiled and run. When porting from the standard TypeScript,
+turn on the following flags: `noImplicitReturns`, `strictFunctionTypes`,
+`strictNullChecks`, `strictPropertyInitialization`.
+
+**TypeScript**
+
+```typescript
+class C {
+ n: number // Compile-time error only with strictPropertyInitialization
+ s: string // Compile-time error only with strictPropertyInitialization
+}
+
+// Compile-time error only with noImplicitReturns
+function foo(s: string): string {
+ if (s != "") {
+ console.log(s)
+ return s
+ } else {
+ console.log(s)
+ }
+}
+
+let n: number = null // Compile-time error only with strictNullChecks
+```
+
+**ArkTS**
+
+```typescript
+class C {
+ n: number = 0
+ s: string = ""
+}
+
+function foo(s: string): string {
+ console.log(s)
+ return s
+}
+
+let n1: number | null = null
+let n2: number = 0
+```
+
+**See also**
+
+* Recipe: Use explicit types instead of any, unknown
+* Recipe: Switching off type checks with in-place comments is not allowed
+
+## Recipe: Switching off type checks with in-place comments is not allowed
+
+**Rule `arkts-strict-typing-required`**
+
+**Severity: error**
+
+Type checker in ArkTS is not optional, the code must be explicitly and
+correctly typed to be compiled and run. “Suppressing†type checker in-place
+with special comments is not allowed. In particular, `@ts-ignore` and
+`@ts-nocheck` annotations are not supported.
+
+**TypeScript**
+
+```typescript
+// @ts-nocheck
+// ...
+// Some code with switched off type checker
+// ...
+
+let s1: string = null // No error, type checker suppressed
+
+// @ts-ignore
+let s2: string = null // No error, type checker suppressed
+```
+
+**ArkTS**
+
+```typescript
+let s1: string | null = null // No error, properly types
+let s2: string = null // Compile-time error
+```
+
+**See also**
+
+* Recipe: Use explicit types instead of any, unknown
+* Recipe: Strict type checking is enforced
+
+## Recipe: No dependencies on TypeScript code are currently allowed
+
+**Rule `arkts-no-ts-deps`**
+
+**Severity: error**
+
+Currently, the codebase implemented in the standard TypeScript language must not
+depend on ArkTS through importing the ArkTS codebase. Imports in reverse
+direction are supported.
+
+**TypeScript**
+
+```typescript
+// app.ets
+export class C {
+ // ...
+}
+
+// lib.ts
+import { C } from "app"
+```
+
+**ArkTS**
+
+```typescript
+// lib1.ets
+export class C {
+ // ...
+}
+
+// lib2.ets
+import { C } from "lib1"
+```
+
+## Recipe: No decorators except ArkUI decorators are currently allowed
+
+**Rule `arkts-no-decorators-except-arkui`**
+
+**Severity: error**
+
+Currently, only ArkUI decorators are allowed in the ArkTS.
+Any other decorator will cause a compile-time error.
+
+**TypeScript**
+
+```typescript
+function classDecorator(x: any, y: any): void {
+ //
+}
+
+@classDecorator
+class BugReport {
+}
+```
+
+**ArkTS**
+
+```typescript
+function classDecorator(x: any, y: any): void {
+ //
+}
+
+@classDecorator // compile-time error: unsupported decorator
+class BugReport {
+}
+```
+
diff --git a/zh-cn/application-dev/quick-start/introduction-to-arkts.md b/zh-cn/application-dev/quick-start/introduction-to-arkts.md
index 8f0b3a85b76d86b307646009684c9336ad28c0c3..15b4b5443a51d72c4c41e3a46449435608a54e7a 100644
--- a/zh-cn/application-dev/quick-start/introduction-to-arkts.md
+++ b/zh-cn/application-dev/quick-start/introduction-to-arkts.md
@@ -766,7 +766,7 @@ class Point {
x: number = 0
y: number = 0
}
-let p: Point = {42 ,42}
+let p: Point = {x: 42, y: 42}
```
### å—段
@@ -868,11 +868,11 @@ class Rectangle {
}
```
-实例方法需è¦åœ¨ç±»çš„实例上调用：
+必须通过类的实例调用实例方法：
```typescript
-let r = new Rectangle(10, 10)
-console.log(square.calculateArea()) // output: 100
+let square = new Rectangle(10, 10)
+console.log(square.calculateArea()) // 输出：100
```
#### é™æ€æ–¹æ³•
@@ -883,7 +883,7 @@ console.log(square.calculateArea()) // output: 100
所有实例都å¯ä»¥è®¿é—®é™æ€æ–¹æ³•ã€‚
-è¦è°ƒç”¨é™æ€æ–¹æ³•ï¼Œéœ€è¦ä½¿ç”¨ç±»å：
+必须通过类å调用é™æ€æ–¹æ³•ï¼š
```typescript
class Cl {
@@ -1309,7 +1309,7 @@ class Stack<Element> {
public pop(): Element {
// ...
}
- public push(e: Element) {
+ public push(e: Element):void {
// ...
}
}
@@ -1402,7 +1402,7 @@ foo<number>()
## 空安全
-默认情况下，ArkTSä¸çš„所有类型都是ä¸å¯ä¸ºç©ºçš„ï¼Œå› æ¤ç±»åž‹çš„值ä¸èƒ½ä¸ºç©ºã€‚这类似于TypeScriptçš„ä¸¥æ ¼ç©ºå€¼æ£€æŸ¥æ¨¡å¼ï¼ˆ`strictNullChecks`ï¼‰ï¼Œä½†è§„åˆ™æ›´ä¸¥æ ¼ï¼Œè€Œä¸”ArkTSä¸æ²¡æœ‰`undefined`类型。
+默认情况下，ArkTSä¸çš„所有类型都是ä¸å¯ä¸ºç©ºçš„ï¼Œå› æ¤ç±»åž‹çš„值ä¸èƒ½ä¸ºç©ºã€‚这类似于TypeScriptçš„ä¸¥æ ¼ç©ºå€¼æ£€æŸ¥æ¨¡å¼ï¼ˆ`strictNullChecks`ï¼‰ï¼Œä½†è§„åˆ™æ›´ä¸¥æ ¼ã€‚
在下é¢çš„示例ä¸ï¼Œæ‰€æœ‰è¡Œéƒ½ä¼šå¯¼è‡´ç¼–译时错误：
@@ -1454,28 +1454,47 @@ class Person {
### å¯é€‰é“¾
-å¯é€‰é“¾è¿ç®—符`?.` å¯ä»¥åœ¨ç¼–写代ç æ—¶é‡åˆ°æ±‚值为null的表达å¼å°±åœæ¢è¿è¡Œã€‚
+在访问对象属性时，如果该属性是`undefined`或者`null`，å¯é€‰é“¾è¿ç®—符会返回`undefined`。
```typescript
class Person {
- // ...
- spouse: Person | null = null
- nick: string | null = null
- getSpouseNick(): string | null {
+ nick : string | null = null
+ spouse ?: Person
+
+ setSpouse(spouse: Person) : void {
+ this.spouse = spouse
+ }
+
+ getSpouseNick(): string | null | undefined {
return this.spouse?.nick
}
+
+ constructor(nick: string) {
+ this.nick = nick
+ this.spouse = undefined
+ }
}
```
-**说明**：`getSpouseNick`的返回类型必须为`string | null`ï¼Œå› ä¸ºè¯¥æ–¹æ³•å¯èƒ½è¿”回null。
+**说明**：`getSpouseNick`的返回类型必须为`string | null | undefined`ï¼Œå› ä¸ºè¯¥æ–¹æ³•å¯èƒ½è¿”回`null`或者`undefined`。
-å¯é€‰é“¾å¯ä»¥æ˜¯ä»»ä½•é•¿åº¦çš„，å¯åŒ…å«ä»»æ„æ•°é‡çš„ `?.` è¿ç®—符。
+å¯é€‰é“¾å¯ä»¥ä»»æ„长，å¯ä»¥åŒ…å«ä»»æ„æ•°é‡çš„`?.`è¿ç®—符。
-在以下示例ä¸ï¼Œå¦‚æžœæŸäººæœ‰é…å¶ï¼Œä¸”é…å¶æœ‰æ˜µç§°ï¼Œåˆ™è¾“出是该人的é…å¶æ˜µç§°ã€‚å¦åˆ™ï¼Œè¾“出为空：
+在以下示例ä¸ï¼Œå¦‚果一个`Person`的实例有ä¸ä¸ºç©ºçš„`spouse`属性，且`spouse`有ä¸ä¸ºç©ºçš„`nickname`属性，则输出`spouse.nick`。å¦åˆ™ï¼Œè¾“出`undefined`：
```typescript
-let p: Person = ...
-console.log(p?.spouse?.nick)
+class Person {
+ nick : string | null = null
+ spouse ?: Person
+
+ constructor(nick: string) {
+ this.nick = nick
+ this.spouse = undefined
+ }
+}
+
+let p: Person = new Person("Alice")
+console.log(p.spouse?.nick) // 打å°undefined
```
## 模å—
diff --git a/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md b/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md
index 0d4553fa5cd806134a393ca02af5e895a864e760..936d48a0e7aab7592af9b28a32c8acbaebd5f009 100644
--- a/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md
+++ b/zh-cn/application-dev/quick-start/typescript-to-arkts-migration-guide.md
@@ -3,7 +3,7 @@
本文通过æ供简æ´çš„约æŸæŒ‡å¯¼å¦‚ä½•å°†æ ‡å‡†çš„TypeScript代ç é‡æž„为ArkTS代ç 。尽管ArkTS是基于TypeScript设计的，但出于性能考虑，一些TypeScript的特性被é™åˆ¶äº†ã€‚å› æ¤ï¼Œåœ¨ArkTSä¸ï¼Œæ‰€æœ‰çš„TypeScript特性被分æˆä¸‰ç±»ã€‚
1. **完全支æŒçš„特性**：原始代ç æ— éœ€ä»»ä½•ä¿®æ”¹ã€‚æ ¹æ®æµ‹è¯•ï¼Œå¯¹äºŽå·²éµå¾ªæœ€ä½³TypeScript实践的项目，代ç 库ä¸90%到97%的内容å¯ä»¥ä¿æŒåŽŸå°ä¸åŠ¨ã€‚
-2. **部分支æŒçš„特性**：需å°è§„模的代ç é‡æž„。例如，必须使用关键å—`let`代替`var` æ¥å£°æ˜Žå˜é‡ã€‚注æ„ï¼Œæ ¹æ®æœ¬æ–‡æ供的约æŸè¿›è¡Œä»£ç é‡æž„åŽï¼Œæ‚¨çš„代ç ä»ä¸ºæœ‰æ•ˆçš„TypeScript代ç 。
+2. **部分支æŒçš„特性**：需å°è§„模的代ç é‡æž„。例如，必须使用关键å—`let`代替`var`æ¥å£°æ˜Žå˜é‡ã€‚注æ„ï¼Œæ ¹æ®æœ¬æ–‡æ供的约æŸè¿›è¡Œä»£ç é‡æž„åŽï¼Œæ‚¨çš„代ç ä»ä¸ºæœ‰æ•ˆçš„TypeScript代ç 。
3. **ä¸æ”¯æŒçš„特性**：需大规模的代ç é‡æž„。例如，ä¸æ”¯æŒ`any`类型，所有使用`any`的代ç 都需è¦å¼•å…¥æ˜¾å¼ç±»åž‹ã€‚
本文将é€ä¸€ä»‹ç»æ‰€æœ‰éƒ¨åˆ†æ”¯æŒå’Œæ‰€æœ‰ä¸æ”¯æŒçš„特性，并æ供代ç é‡æž„的建议。对于没有æ到的特性，则说明ArkTS完全支æŒã€‚
@@ -80,7 +80,7 @@ if (!res.succeeded()) {
}
```
-`any`类型在TypeScriptä¸å¹¶ä¸å¸¸è§ï¼Œåªæœ‰å¤§çº¦1%çš„TypeScript代ç 库使用。一些代ç 检查工具（例如ESLint）也制定一系列规则æ¥ç¦æ¢ä½¿ç”¨`any`ã€‚å› æ¤ï¼Œè™½ç„¶ç¦æ¢`any` 将导致代ç é‡æž„，但é‡æž„é‡å¾ˆå°ï¼Œæœ‰åŠ©äºŽæ•´ä½“性能æå‡ï¼Œå› æ¤è¿™ä¸ªçº¦æŸæ˜¯éžå¸¸æœ‰ä»·å€¼çš„。
+`any`类型在TypeScriptä¸å¹¶ä¸å¸¸è§ï¼Œåªæœ‰å¤§çº¦1%çš„TypeScript代ç 库使用。一些代ç 检查工具（例如ESLint）也制定一系列规则æ¥ç¦æ¢ä½¿ç”¨`any`ã€‚å› æ¤ï¼Œè™½ç„¶ç¦æ¢`any`将导致代ç é‡æž„，但é‡æž„é‡å¾ˆå°ï¼Œæœ‰åŠ©äºŽæ•´ä½“性能æå‡ï¼Œå› æ¤è¿™ä¸ªçº¦æŸæ˜¯éžå¸¸æœ‰ä»·å€¼çš„。
### ç¦æ¢åœ¨è¿è¡Œæ—¶å˜æ›´å¯¹è±¡å¸ƒå±€
@@ -137,7 +137,7 @@ let p6 = new Point(6.0, 6.0)
console.log("Distance between p5 and p6: " + distance(p5, p6))
```
-ä¸å¯é¢„测的对象布局修改会影å“代ç çš„å¯è¯»æ€§ä»¥åŠè¿è¡Œæ—¶æ€§èƒ½ã€‚从开å‘者的角度æ¥è¯´ï¼Œåœ¨æŸå¤„定义类，然åŽåˆåœ¨å…¶ä»–地方修改实际的对象布局，很容易引起困惑乃至引入错误。æ¤å¤–，这点还需è¦é¢å¤–çš„è¿è¡Œæ—¶æ”¯æŒï¼Œå¢žåŠ 了执行开销。这一点与é™æ€ç±»åž‹çš„约æŸä¹Ÿå†²çªï¼šæ—¢ç„¶å·²å†³å®šä½¿ç”¨æ˜¾å¼ç±»åž‹ï¼Œä¸ºä»€ä¹ˆè¿˜éœ€è¦æ·»åŠ æˆ–åˆ é™¤å±žæ€§å‘¢ï¼Ÿ
+修改对象布局会影å“代ç çš„å¯è¯»æ€§ä»¥åŠè¿è¡Œæ—¶æ€§èƒ½ã€‚从开å‘者的角度æ¥è¯´ï¼Œåœ¨æŸå¤„定义类，然åŽåˆåœ¨å…¶ä»–地方修改实际的对象布局，很容易引起困惑乃至引入错误。æ¤å¤–，这点还需è¦é¢å¤–çš„è¿è¡Œæ—¶æ”¯æŒï¼Œå¢žåŠ 了执行开销。这一点与é™æ€ç±»åž‹çš„约æŸä¹Ÿå†²çªï¼šæ—¢ç„¶å·²å†³å®šä½¿ç”¨æ˜¾å¼ç±»åž‹ï¼Œä¸ºä»€ä¹ˆè¿˜éœ€è¦æ·»åŠ æˆ–åˆ é™¤å±žæ€§å‘¢ï¼Ÿ
当å‰ï¼Œåªæœ‰å°‘数项目å…许在è¿è¡Œæ—¶å˜æ›´å¯¹è±¡å¸ƒå±€ï¼Œä¸€äº›å¸¸ç”¨çš„代ç æ£€æŸ¥å·¥å…·ä¹Ÿå¢žåŠ äº†ç›¸åº”çš„é™åˆ¶è§„则。这个约æŸåªä¼šå¯¼è‡´å°‘é‡ä»£ç é‡æž„，但对性能æå‡ä¼šæœ‰ç§¯æžçš„å½±å“。
@@ -214,13 +214,13 @@ structural typing是å¦æœ‰åŠ©äºŽç”Ÿæˆæ¸…æ™°ã€æ˜“ç†è§£çš„代ç ，关于这一
## 约æŸè¯´æ˜Ž
-### 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+### 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
**规则：**`arkts-identifiers-as-prop-names`
**级别：错误**
-ArkTSä¸æ”¯æŒå±žæ€§å称为数å—或å—符串的对象。通过属性åè®¿é—®ç±»çš„å±žæ€§ï¼Œé€šè¿‡æ•°å€¼ç´¢å¼•è®¿é—®æ•°ç»„å…ƒç´ ã€‚
+在ArkTSä¸ï¼Œå¯¹è±¡çš„属性åä¸èƒ½ä¸ºæ•°å—或å—符串。通过属性åè®¿é—®ç±»çš„å±žæ€§ï¼Œé€šè¿‡æ•°å€¼ç´¢å¼•è®¿é—®æ•°ç»„å…ƒç´ ã€‚
**TypeScript**
@@ -235,9 +235,9 @@ console.log(x[2])
```typescript
class X {
- public name: number
+ public name: number = 0
}
-let x = {name: 1}
+let x: X = {name: 1}
console.log(x.name)
let y = [1, 2, 3]
@@ -269,7 +269,7 @@ console.log(z.get(2))
**级别：错误**
-TypeScriptä¸çš„`Symbol()` API用于在è¿è¡Œæ—¶ç”Ÿæˆå”¯ä¸€çš„属性å称。由于该API的常è§ä½¿ç”¨åœºæ™¯åœ¨é™æ€ç±»åž‹è¯è¨€ä¸æ²¡æœ‰æ„ä¹‰ï¼Œå› æ¤ï¼ŒArkTSä¸æ”¯æŒ`Symbol()` API。在ArkTSä¸ï¼Œå¯¹è±¡å¸ƒå±€åœ¨ç¼–译时就确定了，且ä¸èƒ½åœ¨è¿è¡Œæ—¶è¢«æ›´æ”¹ã€‚
+TypeScriptä¸çš„`Symbol()`API用于在è¿è¡Œæ—¶ç”Ÿæˆå”¯ä¸€çš„属性å称。由于该API的常è§ä½¿ç”¨åœºæ™¯åœ¨é™æ€ç±»åž‹è¯è¨€ä¸æ²¡æœ‰æ„ä¹‰ï¼Œå› æ¤ï¼ŒArkTSä¸æ”¯æŒ`Symbol()`API。在ArkTSä¸ï¼Œå¯¹è±¡å¸ƒå±€åœ¨ç¼–译时就确定了，且ä¸èƒ½åœ¨è¿è¡Œæ—¶è¢«æ›´æ”¹ã€‚
**TypeScript**
@@ -284,7 +284,7 @@ let o = {
```typescript
class SomeClass {
- public someProperty : string
+ public someProperty : string = ""
}
let o = new SomeClass()
```
@@ -300,13 +300,13 @@ let o = new SomeClass()
* ä¸æ”¯æŒå£°æ˜ŽåŠ¨æ€å±žæ€§
* é™åˆ¶ä½¿ç”¨æ ‡å‡†åº“
-### ä¸æ”¯æŒå¸¦â€œ#â€ç¬¦å·çš„ç§æœ‰ä¿®é¥°ç¬¦
+### ä¸æ”¯æŒä»¥`#`开头的ç§æœ‰å—段
**规则：**`arkts-no-private-identifiers`
**级别：错误**
-ArkTSä¸æ”¯æŒä»¥`#`符å·å¼€å¤´çš„ç§æœ‰ä¿®é¥°ç¬¦ã€‚改用 `private`关键å—。
+ArkTSä¸æ”¯æŒä½¿ç”¨`#`符å·å¼€å¤´å£°æ˜Žçš„ç§æœ‰å—段。改用`private`关键å—。
**TypeScript**
@@ -330,7 +330,7 @@ class C {
**级别：错误**
-类型ã€å‘½å空间ç‰çš„命å必须唯一，且能够与å˜é‡åç‰å…¶ä»–å称区分开æ¥ã€‚
+类型ã€å‘½å空间ç‰çš„命å必须唯一，且能够与其他å称（例如：å˜é‡å）区分开æ¥ã€‚
**TypeScript**
@@ -401,57 +401,39 @@ scoped_var = 5
scoped_let = 5 //编译时错误
```
-### 使用具体的类型而éž`any`ã€`undefined`或`unknown`
+### 使用具体的类型而éž`any`或`unknown`
-**规则：**`arkts-no-any-undefined-unknown`
+**规则：**`arkts-no-any-unknown`
**级别：错误**
-ArkTSä¸æ”¯æŒ`any`ã€`undefined`å’Œ`unknown`类型。显å¼æŒ‡å®šå…·ä½“类型。
+ArkTSä¸æ”¯æŒ`any`å’Œ`unknown`类型。显å¼æŒ‡å®šå…·ä½“类型。
**TypeScript**
```typescript
-var x
-console.log(x) // undefined
+let value1 : any
+value1 = true
+value1 = 42
-var y: any
-console.log(y) // undefined
+let value2 : unknown
+value2 = true
+value2 = 42
```
**ArkTS**
```typescript
-// 所有å˜é‡éƒ½åº”显å¼æŒ‡å®šå…¶å…·ä½“类型：
-let x: Object = {}
-console.log(x) // {}
+let value_b: boolean = true // 或者 let value_b = true
+let value_n: number = 42 // 或者 let value_n = 42
+let value_o1: Object = true
+let value_o2: Object = 42
```
**相关约æŸ**
* 使用Object[]而éžtuple
-### `bigint`ä¸æ˜¯å†…置类型，ä¸æ”¯æŒå¸¦åŽç¼€`n`çš„æ•°å—å—é¢é‡
-
-**规则：**`arkts-no-n-suffix`
-
-**级别：错误**
-
-在ArkTSä¸ï¼Œ`bigint`æ˜¯æ ‡å‡†åº“çš„ä¸€éƒ¨åˆ†ï¼Œè€Œéžä¸€ç§å†…置类型。ä¸æ”¯æŒå¸¦åŽç¼€`n`çš„æ•°å—å—é¢é‡ã€‚使用`BigInt`工厂函数生æˆ`bigint`类型的值。
-
-**TypeScript**
-
-```typescript
-let a: bigint = 1n
-```
-
-**ArkTS**
-
-```typescript
-let a = BigInt(1)
-let b: bigint = BigInt(2)
-```
-
### 使用`Object[]`而éžtuple
**规则：**`arkts-no-tuples`
@@ -476,7 +458,7 @@ let n = t[0]
let s = t[1]
```
-### 使用`class` 而éžå…·æœ‰call signature的类型
+### 使用`class`而éžå…·æœ‰call signature的类型
**规则：**`arkts-no-call-signatures`
@@ -519,15 +501,15 @@ doSomething(new DescribableFunction())
**相关约æŸ**
-* 使用class而éžå…·æœ‰æž„é€ å‡½æ•°ç¾å的类型
+* 使用class而éžå…·æœ‰æž„é€ ç¾å的类型
-### 使用`class`而éžå…·æœ‰æž„é€ å‡½æ•°ç¾å的类型
+### 使用`class`而éžå…·æœ‰æž„é€ ç¾å的类型
**规则：**`arkts-no-ctor-signatures-type`
**级别：错误**
-ArkTSä¸æ”¯æŒå¯¹è±¡ç±»åž‹ä¸çš„æž„é€ å‡½æ•°ç¾å。改用类。
+ArkTSä¸æ”¯æŒå¯¹è±¡ç±»åž‹ä¸çš„æž„é€ ç¾å。改用类。
**TypeScript**
@@ -626,7 +608,7 @@ const secondItem = myArray[1]
```typescript
class X {
- public f: string[]
+ public f: string[] = []
}
let myArray: X = new X()
@@ -673,13 +655,13 @@ interface Contact {
interface Employee extends Identity, Contact {}
```
-### ä¸æ”¯æŒè¿”回`this`类型
+### ä¸æ”¯æŒ`this`类型
-**规则：**`arkts-no-this-as-return-type`
+**规则：**`arkts-no-typing-with-this`
**级别：错误**
-ArkTSä¸æ”¯æŒè¿”回`this`类型。改用显å¼å…·ä½“类型。
+ArkTSä¸æ”¯æŒ`this`类型。改用显å¼å…·ä½“类型。
**TypeScript**
@@ -687,6 +669,14 @@ ArkTSä¸æ”¯æŒè¿”回`this`类型。改用显å¼å…·ä½“类型。
interface ListItem {
getHead(): this
}
+
+class C {
+ n: number = 0
+
+ m(c: this) {
+ console.log(c)
+ }
+}
```
**ArkTS**
@@ -695,6 +685,14 @@ interface ListItem {
interface ListItem {
getHead(): ListItem
}
+
+class C {
+ n: number = 0
+
+ m(c: C) {
+ console.log(c)
+ }
+}
```
### ä¸æ”¯æŒæ¡ä»¶ç±»åž‹
@@ -726,42 +724,6 @@ type X2<T> = Object
type YI<Item, T extends Array<Item>> = Item
```
-### å¯é€‰å‚æ•°ä¸èƒ½ä½¿ç”¨primitive type
-
-**规则：**`arkts-no-opt-params`
-
-**级别：错误**
-
-ArkTSä¸ï¼Œå¯é€‰å‚数的类型ä¸èƒ½ä¸ºprimitive type。å¯ä»¥ä½¿ç”¨é»˜è®¤å‚数或引用类型。对于引用类型，å¯é€‰å‚数缺çœå€¼ä¸º`null`。
-
-**TypeScript**
-
-```typescript
-// x为å¯é€‰å‚数：
-function f(x?: number) {
- console.log(x) // 打å°undefined或æŸä¸ªæ•°å—
-}
-
-// x为带默认值的必选å‚数：
-function g(x: number = 1) {
- console.log(x)
-}
-```
-
-**ArkTS**
-
-```typescript
-// 使用引用类型（缺çœå€¼ä¸ºnull）：
-function f(x?: Number) {
- console.log(x) // 打å°null或æŸä¸ªæ•°å—
-}
-
-// 使用带默认值的必选å‚数：
-function g(x: number = 1) {
- console.log(x)
-}
-```
-
### ä¸æ”¯æŒåœ¨`constructor`ä¸å£°æ˜Žå—段
**规则：**`arkts-no-ctor-prop-decls`
@@ -810,13 +772,13 @@ class Person {
}
```
-### 接å£ä¸ä¸æ”¯æŒæž„é€ å‡½æ•°ç¾å
+### 接å£ä¸ä¸æ”¯æŒæž„é€ ç¾å
**规则：**`arkts-no-ctor-signatures-iface`
**级别：错误**
-ArkTSä¸æ”¯æŒæŽ¥å£ä¸çš„æž„é€ å‡½æ•°ç¾å。改用方法。
+ArkTSä¸æ”¯æŒåœ¨æŽ¥å£ä¸ä½¿ç”¨æž„é€ ç¾å。改用函数或者方法。
**TypeScript**
@@ -844,7 +806,7 @@ function fn(i: I) {
**相关约æŸ**
-* 使用class而éžå…·æœ‰æž„é€ å‡½æ•°ç¾å的类型
+* 使用class而éžå…·æœ‰æž„é€ ç¾å的类型
### ä¸æ”¯æŒç´¢å¼•è®¿é—®ç±»åž‹
@@ -874,7 +836,7 @@ type N = number
**级别：错误**
-ArkTSä¸æ”¯æŒé’ˆå¯¹ç±»å—段的索引访问。改用点æ“作符。
+ArkTSä¸æ”¯æŒé€šè¿‡ç´¢å¼•è®¿é—®å¯¹è±¡çš„å—段。改用点æ“作符。
**TypeScript**
@@ -1044,7 +1006,7 @@ interface Z {
foo: number
}
-// X实现了接å£Z，显示化定义了Xå’ŒY之间的关系。
+// X实现了接å£Z，显å¼åŒ–定义了Xå’ŒY之间的关系。
class X implements Z {
public foo: number
@@ -1053,7 +1015,7 @@ class X implements Z {
}
}
-// Y实现了接å£Z，显示化定义了Xå’ŒY之间的关系。
+// Y实现了接å£Z，显å¼åŒ–定义了Xå’ŒY之间的关系。
class Y implements Z {
public foo: number
@@ -1078,60 +1040,13 @@ x = y // ok，两者类型相åŒ
* å类型/父类型ä¸æ”¯æŒstructural typing
* 类型推æ–ä¸æ”¯æŒstructural typing
-### å¯é€‰å±žæ€§çš„的类型ä¸èƒ½ä¸ºprimitive type
-
-**规则：**`arkts-no-opt-props`
-
-**级别：错误**
-
-ArkTSä¸ï¼Œå¯é€‰å±žæ€§çš„类型ä¸èƒ½ä¸ºprimitive type。使用默认值或引用类型。对于引用类型，å¯é€‰å±žæ€§ç¼ºçœå€¼ä¸º`null`。该规则åŒæ ·é€‚用于类和接å£ã€‚
-
-**TypeScript**
-
-```typescript
-class CompilerOptions {
- strict?: boolean
- sourcePath?: string
- targetPath?: string
-}
-
-let options: CompilerOptions = {
- strict: true,
- sourcePath: "./src"
-}
-
-if (options.targetPath == undefined) {
- // 一些代ç
-}
-```
-
-**ArkTS**
-
-```typescript
-class CompilerOptions {
- strict: boolean = false
- sourcePath: string = ""
- targetPath?: string
-}
-
-let options: CompilerOptions = {
- strict: true,
- sourcePath: "./src"
- // targetPath的值为null
-}
-
-if (options.targetPath == null) {
- // 一些代ç
-}
-```
-
-### 显å¼æ ‡æ³¨æ³›åž‹å‡½æ•°ç±»åž‹å®žå‚，除éžå¯ä»¥æŽ¨æ–出类型实å‚
+### 显å¼æ ‡æ³¨æ³›åž‹å‡½æ•°ç±»åž‹å®žå‚，除éžå¯ä»¥ä»Žå‚æ•°ä¸æŽ¨æ–出类型实å‚
**规则：**`arkts-no-inferred-generic-params`
**级别：错误**
-如果å¯ä»¥ä»Žä¼ 递给泛型函数的å‚æ•°ä¸æŽ¨æ–出具体类型，ArkTSå…许çœç•¥æ³›åž‹ç±»åž‹å®žå‚。å¦åˆ™ï¼Œä¼šå‘生编译时错误。ç¦æ¢ä»…基于函数返回类型推æ–泛型类型å‚数。
+如果å¯ä»¥ä»Žä¼ 递给泛型函数的å‚æ•°ä¸æŽ¨æ–出具体类型，ArkTSå…许çœç•¥æ³›åž‹ç±»åž‹å®žå‚。å¦åˆ™ï¼Œçœç•¥æ³›åž‹ç±»åž‹å®žå‚会å‘生编译时错误。ç¦æ¢ä»…基于泛型函数返回类型推æ–泛型类型å‚数。
**TypeScript**
@@ -1146,7 +1061,7 @@ let y = choose("10", 20) // 编译时错误
function greet<T>(): T {
return "Hello" as T
}
-let z = greet() // x的类型被推æ–为“unknownâ€
+let z = greet() // T的类型被推æ–为“unknownâ€
```
**ArkTS**
@@ -1277,17 +1192,17 @@ let regex: RegExp = /bc*d/
let regex: RegExp = new RegExp("/bc*d/")
```
-### 对象å—é¢é‡å¿…须对应显å¼å£°æ˜Žçš„类或接å£
+### 显å¼æ ‡æ³¨å¯¹è±¡å—é¢é‡çš„类型
**规则：**`arkts-no-untyped-obj-literals`
**级别：错误**
-如果编译器å¯ä»¥æŽ¨æ–对象å—é¢é‡å¯¹åº”于哪些类或接å£ï¼Œåˆ™å¯ä»¥ä½¿ç”¨å¯¹è±¡å—é¢é‡ã€‚å¦åˆ™ï¼Œå°†å‘生编译时错误。具体æ¥è¯´ï¼Œåœ¨ä»¥ä¸‹ä¸Šä¸‹æ–‡ä¸ä¸æ”¯æŒä½¿ç”¨å—é¢é‡åˆå§‹åŒ–类和接å£ï¼š
+显å¼æ ‡æ³¨å¯¹è±¡å—é¢é‡çš„类型，除éžç¼–译器å¯ä»¥æ ¹æ®ä¸Šä¸‹æ–‡æŽ¨æ–出å—é¢é‡çš„类型是æŸäº›ç±»æˆ–者接å£ã€‚å¦åˆ™ï¼Œå°†å‘生编译时错误。具体æ¥è¯´ï¼Œåœ¨ä»¥ä¸‹ä¸Šä¸‹æ–‡ä¸ä¸æ”¯æŒä½¿ç”¨å—é¢é‡åˆå§‹åŒ–类和接å£ï¼š
* åˆå§‹åŒ–具有`any`ã€`Object`或`object`类型的任何对象
* åˆå§‹åŒ–带有方法的类或接å£
-* åˆå§‹åŒ–有自定义且有å‚æ•°çš„æž„é€ å‡½æ•°çš„ç±»
+* åˆå§‹åŒ–包å«è‡ªå®šä¹‰å«å‚æ•°çš„æž„é€ å‡½æ•°çš„ç±»
* åˆå§‹åŒ–带`readonly`å—段的类
**TypeScript**
@@ -1334,7 +1249,7 @@ function id_x_y(o: Point): Point {
return o
}
-// structural typing用于推æ–p为Point
+// å› ä¸ºTS支æŒstructural typing，编译器å¯ä»¥æŽ¨æ–p的类型为Point
let p = {x: 5, y: 10}
id_x_y(p)
@@ -1401,7 +1316,7 @@ function id_x_y(o: Point): Point {
let p: Point = {x: 5, y: 10}
id_x_y(p)
-// id_x_y预计接å—Point类型，å—é¢é‡åˆå§‹åŒ–生æˆä¸€ä¸ªPoint的新实例
+// id_x_y接å—Point类型，å—é¢é‡åˆå§‹åŒ–生æˆä¸€ä¸ªPoint的新实例
id_x_y({x: 5, y: 10})
```
@@ -1416,7 +1331,7 @@ id_x_y({x: 5, y: 10})
**级别：错误**
-ArkTSä¸æ”¯æŒä½¿ç”¨å¯¹è±¡å—é¢é‡å£°æ˜Žç±»åž‹ã€‚需显å¼å£°æ˜Žç±»å’ŒæŽ¥å£ã€‚
+ArkTSä¸æ”¯æŒä½¿ç”¨å¯¹è±¡å—é¢é‡å£°æ˜Žç±»åž‹ï¼Œå¯ä»¥ä½¿ç”¨ç±»æˆ–者接å£å£°æ˜Žç±»åž‹ã€‚
**TypeScript**
@@ -1433,8 +1348,8 @@ type S = Set<{x: number, y: number}>
```typescript
class O {
- x: number
- y: number
+ x: number = 0
+ y: number = 0
}
let o: O = {x: 2, y: 3}
@@ -1453,7 +1368,7 @@ type S = Set<O>
**级别：错误**
-本质上，ArkTS将数组å—é¢é‡çš„类型推æ–为数组内容的è”åˆç±»åž‹ã€‚如果其ä¸ä»»ä½•ä¸€ä¸ªå…ƒç´ çš„ç±»åž‹æ— æ³•æ ¹æ®ä¸Šä¸‹æ–‡æŽ¨å¯¼å‡ºæ¥ï¼ˆä¾‹å¦‚，未类型化的对象å—é¢é‡ï¼‰ï¼Œåˆ™ä¼šå‘生编译时错误。
+本质上，ArkTS将数组å—é¢é‡çš„类型推æ–ä¸ºæ•°ç»„æ‰€æœ‰å…ƒç´ çš„è”åˆç±»åž‹ã€‚如果其ä¸ä»»ä½•ä¸€ä¸ªå…ƒç´ çš„ç±»åž‹æ— æ³•æ ¹æ®ä¸Šä¸‹æ–‡æŽ¨å¯¼å‡ºæ¥ï¼ˆä¾‹å¦‚ï¼Œæ— ç±»åž‹çš„å¯¹è±¡å—é¢é‡ï¼‰ï¼Œåˆ™ä¼šå‘生编译时错误。
**TypeScript**
@@ -1474,11 +1389,10 @@ let a2: C[] = [{n: 1, s: "1"}, {n: 2, s : "2"}] // a2的类型为“C[]â€
```
**相关约æŸ**
-
* 对象å—é¢é‡å¿…须对应æŸäº›æ˜¾å¼å£°æ˜Žçš„类或接å£
* 对象å—é¢é‡ä¸èƒ½ç”¨äºŽç±»åž‹å£°æ˜Ž
-### Lambda函数的å‚数类型必须显å¼åŒ–
+### 显å¼æ ‡æ³¨Lambda函数的å‚数类型
**规则：**`arkts-explicit-param-types-in-lambdas`
@@ -1489,7 +1403,8 @@ let a2: C[] = [{n: 1, s: "1"}, {n: 2, s : "2"}] // a2的类型为“C[]â€
**TypeScript**
```typescript
-let f = (s) => { // éšå¼å®šä¹‰ç±»åž‹ä¸ºany
+// åªæœ‰åœ¨å¼€å¯noImplicitAny选项时会产生编译时错误
+let f = (s /* type any is assumed */) => {
console.log(s)
}
```
@@ -1497,7 +1412,7 @@ let f = (s) => { // éšå¼å®šä¹‰ç±»åž‹ä¸ºany
**ArkTS**
```typescript
-// lambda函数的å‚数类型必须显å¼åŒ–
+// 显å¼æ ‡æ³¨Lambda函数的å‚数类型
let f = (s: string) => {
console.log(s)
}
@@ -1566,11 +1481,11 @@ ArkTSä¸æ”¯æŒä½¿ç”¨ç±»è¡¨è¾¾å¼ã€‚必须显å¼å£°æ˜Žä¸€ä¸ªç±»ã€‚
```typescript
const Rectangle = class {
constructor(height: number, width: number) {
- this.heigth = height
+ this.height = height
this.width = width
}
- heigth
+ height
width
}
@@ -1582,11 +1497,11 @@ const rectangle = new Rectangle(0.0, 0.0)
```typescript
class Rectangle {
constructor(height: number, width: number) {
- this.heigth = height
+ this.height = height
this.width = width
}
- heigth: number
+ height: number
width: number
}
@@ -1617,7 +1532,7 @@ class C1 implements C {
```typescript
interface C {
- foo()
+ foo(): void
}
class C1 implements C {
@@ -1640,7 +1555,7 @@ let person = {name: "Bob", isEmployee: true}
let n = person["name"]
let e = person["isEmployee"]
-let s = person["office"] // undefined
+let s = person["office"] // åªæœ‰åœ¨å¼€å¯noImplicitAny选项时会产生编译时错误
```
**ArkTS**
@@ -1664,7 +1579,7 @@ let s = person.office // 编译时错误
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* ä¸æ”¯æŒdeleteè¿ç®—符
* ä»…å…许在表达å¼ä¸ä½¿ç”¨typeofè¿ç®—符
@@ -1681,6 +1596,8 @@ let s = person.office // 编译时错误
在ArkTSä¸ï¼Œ`as`关键å—是类型转æ¢çš„唯一è¯æ³•ã€‚错误的类型转æ¢ä¼šå¯¼è‡´ç¼–译时错误或者è¿è¡Œæ—¶æŠ›å‡º`ClassCastException`异常。ä¸æ”¯æŒä½¿ç”¨`<type>`è¯æ³•è¿›è¡Œç±»åž‹è½¬æ¢ã€‚
+当需è¦å°†`primitive`类型（如`number`或`boolean`）转æ¢æˆå¼•ç”¨ç±»åž‹æ—¶ï¼Œè¯·ä½¿ç”¨`new`表达å¼ã€‚
+
**TypeScript**
```typescript
@@ -1699,6 +1616,12 @@ let c2 = createShape() as Circle
// 如果转æ¢é”™è¯¯ï¼Œä¸ä¼šäº§ç”Ÿç¼–译时或è¿è¡Œæ—¶æŠ¥é”™
let c3 = createShape() as Square
console.log(c3.y) // undefined
+
+// 在TSä¸ï¼Œç”±äºŽ`as`关键å—ä¸ä¼šåœ¨è¿è¡Œæ—¶ç”Ÿæ•ˆï¼Œæ‰€ä»¥`instanceof`çš„å·¦æ“作数ä¸ä¼šåœ¨è¿è¡Œæ—¶è¢«è£…ç®±æˆå¼•ç”¨ç±»åž‹
+let e1 = (5.0 as Number) instanceof Number // false
+
+// 创建Number对象，获得预期结果：
+let e2 = (new Number(5.0)) instanceof Number // true
```
**ArkTS**
@@ -1716,6 +1639,9 @@ let c2 = createShape() as Circle
// è¿è¡Œæ—¶æŠ›å‡ºClassCastException异常：
let c3 = createShape() as Square
+
+// 创建Number对象，获得预期结果：
+let e2 = (new Number(5.0)) instanceof Number // true
```
### ä¸æ”¯æŒJSX表达å¼
@@ -1732,48 +1658,19 @@ let c3 = createShape() as Square
**级别：错误**
-ArkTSä»…å…许一元è¿ç®—符用于数值类型，å¦åˆ™ä¼šå‘生编译时错误。与TypeScriptä¸åŒï¼ŒArkTSä¸æ”¯æŒéšå¼å°†å—符串转æ¢æˆæ•°å€¼ï¼Œå¿…须进行显示转æ¢ã€‚
+ArkTSä»…å…许一元è¿ç®—符用于数值类型，å¦åˆ™ä¼šå‘生编译时错误。与TypeScriptä¸åŒï¼ŒArkTSä¸æ”¯æŒéšå¼å°†å—符串转æ¢æˆæ•°å€¼ï¼Œå¿…须进行显å¼è½¬æ¢ã€‚
**TypeScript**
```typescript
-let a = +5 // 5为number
-let b = +"5" // 5为number
-let c = -5 // -5为number
-let d = -"5" // -5为number
-let e = ~5 // -6为number
-let f = ~"5" // -6为number
-let g = +"string" // NaN为number
-```
-
-**ArkTS**
-
-```typescript
-let a = +5 // 5为number
-let b = +"5" // 编译时错误
-let c = -5 // -5为number
-let d = -"5" // 编译时错误
-let e = ~5 // -6为number
-let f = ~"5" // 编译时错误
-let g = +"string" // 编译时错误
-```
-
-**相关约æŸ**
-
-* 二元è¿ç®—符\*ã€/ã€%ã€-ã€<<ã€>>ã€>>>ã€&ã€^ å’Œ|仅适用于数值类型
-* 二元è¿ç®—符+仅支æŒæ•°å—å’Œå—符串的éšå¼è½¬æ¢
+let a = +5 // 5（number类型）
+let b = +"5" // 5（number类型）
+let c = -5 // -5（number类型）
+let d = -"5" // -5（number类型）
+let e = ~5 // -6（number类型）
+let f = ~"5" // -6（number类型）
+let g = +"string" // NaN（number类型）
-### 一元è¿ç®—符`+`ä¸èƒ½å°†ä»»ä½•ç±»åž‹è½¬æ¢ä¸ºæ•°å€¼ç±»åž‹
-
-**规则：**`arkts-no-unary-plus-cast`
-
-**级别：错误**
-
-ArkTSä¸æ”¯æŒä½¿ç”¨ä¸€å…ƒè¿ç®—符`+`将任何类型转æ¢ä¸ºæ•°å€¼ç±»åž‹ï¼Œè¯¥è¿ç®—符åªèƒ½ç”¨äºŽæ•°å€¼ç±»åž‹ã€‚
-
-**TypeScript**
-
-```typescript
function returnTen(): string {
return "-10"
}
@@ -1782,13 +1679,21 @@ function returnString(): string {
return "string"
}
-let a = +returnTen() // -10为数值
-let b = +returnString() // NaN
+let x = +returnTen() // -10（number类型）
+let y = +returnString() // NaN
```
**ArkTS**
```typescript
+let a = +5 // 5（number类型）
+let b = +"5" // 编译时错误
+let c = -5 // -5（number类型）
+let d = -"5" // 编译时错误
+let e = ~5 // -6（number类型）
+let f = ~"5" // 编译时错误
+let g = +"string" // 编译时错误
+
function returnTen(): string {
return "-10"
}
@@ -1797,16 +1702,10 @@ function returnString(): string {
return "string"
}
-let a = +returnTen() // 编译时错误
-let b = +returnString() // 编译时错误
+let x = +returnTen() // 编译时错误
+let y = +returnString() // 编译时错误
```
-**相关约æŸ**
-
-* 一元è¿ç®—符+ã€-å’Œ~仅适用于数值类型
-* 二元è¿ç®—符\*ã€/ã€%ã€-ã€<<ã€>>ã€>>>ã€&ã€^ å’Œ|仅适用于数值类型
-* 二元è¿ç®—符+仅支æŒæ•°å—å’Œå—符串的éšå¼è½¬æ¢
-
### ä¸æ”¯æŒ`delete`è¿ç®—符
**规则：**`arkts-no-delete`
@@ -1832,8 +1731,8 @@ delete p.y
```typescript
// å¯ä»¥å£°æ˜Žä¸€ä¸ªå¯ç©ºç±»åž‹å¹¶ä½¿ç”¨null作为缺çœå€¼
class Point {
- x: number | null
- y: number | null
+ x: number | null = 0
+ y: number | null = 0
}
let p = new Point()
@@ -1842,7 +1741,7 @@ p.y = null
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* 访问未定义的属性将导致编译时错误
* ä»…å…许在表达å¼ä¸ä½¿ç”¨typeofè¿ç®—符
@@ -1882,7 +1781,7 @@ let s2: string
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* 访问未定义的属性将导致编译时错误
* ä¸æ”¯æŒdeleteè¿ç®—符
@@ -1891,73 +1790,14 @@ let s2: string
* ä¸æ”¯æŒå£°æ˜ŽåŠ¨æ€å±žæ€§
* é™åˆ¶ä½¿ç”¨æ ‡å‡†åº“
-### 二元è¿ç®—符`*`ã€`/`ã€`%`ã€`-`ã€`<<`ã€`>>`ã€`>>>`ã€`&`ã€`^`å’Œ`|`仅适用于数值类型
-
-**规则：**`arkts-no-polymorphic-binops`
-
-**级别：错误**
-
-在ArkTSä¸ï¼ŒäºŒå…ƒè¿ç®—符`*`ã€`/`ã€`%`ã€`-`，`<<`ã€`>>`ã€`>>>`ã€`&`ã€`^`å’Œ`|`ä»…å¯ç”¨äºŽæ•°å€¼ç±»åž‹ã€‚ä¸æ”¯æŒå°†å…¶ä»–类型éšå¼è½¬æ¢ä¸ºæ•°å€¼ç±»åž‹ï¼Œå¦åˆ™ä¼šå¯¼è‡´ç¼–译时错误。
-
-**TypeScript**
-
-```typescript
-let a = (5 & 5) // 5
-let b = (5.5 & 5.5) // 5，éž5.5
-let c = (5 | 5) // 5
-let d = (5.5 | 5.5) // 5，éž5.5
-
-enum Direction {
- Up = -1,
- Down
-}
-let e = Direction.Up >> 1 // -1
-let f = Direction.Up >>> 1 // 2147483647
-
-let g = ("10" as any) << 1 // 20
-let h = ("str" as any) << 1 // 0
-
-let i = 10 * 5
-let j = 10 / 5
-let k = 10 % 5
-let l = 10 - 5
-```
-
-**ArkTS**
-
-```typescript
-let a = (5 & 5) // 5
-let b = (5.5 & 5.5) // 编译时错误
-let c = (5 | 5) // 5
-let d = (5.5 | 5.5) // 编译时错误
-
-enum Direction {
- Up,
- Down
-}
-
-let e = Direction.Up >> 1 // 0
-let f = Direction.Up >>> 1 // 0
-
-let i = 10 * 5
-let j = 10 / 5
-let k = 10 % 5
-let l = 10 - 5
-```
-
-**相关约æŸ**
-
-* 一元è¿ç®—符+ã€-å’Œ~仅适用于数值类型
-* 一元è¿ç®—符`+`ä¸èƒ½å°†ä»»ä½•ç±»åž‹è½¬æ¢ä¸ºæ•°å€¼ç±»åž‹
-* 二元è¿ç®—符+仅支æŒæ•°å—å’Œå—符串的éšå¼è½¬æ¢
-
-### 二元è¿ç®—符+仅支æŒæ•°å—å’Œå—符串的éšå¼è½¬æ¢
+### 二元è¿ç®—符`+`仅支æŒæ•°å—å’Œå—符串的éšå¼è½¬æ¢
**规则：**`arkts-no-polymorphic-plus`
**级别：错误**
-ArkTS支æŒä½¿ç”¨`+`对å—符串和数å—进行éšå¼è½¬æ¢ã€‚其他情形下，都需è¦æ˜¾å¼è½¬æ¢ä¸ºå—符串。
+如果二元è¿ç®—符`+`的一个æ“作数是`string`类型（包括enumä¸çš„`string`），那么å¦ä¸€ä¸ªæ“作数å¯ä»¥æ˜¯ä»»æ„的类型，在è¿ç®—时它的值被éšå¼è½¬æ¢æˆ`string`。在其他情况下，ArkTSåªæ”¯æŒ`number`å’Œenumä¸çš„`number`çš„éšå¼è½¬æ¢ã€‚
+æ£å¦‚TypeScriptä¸€æ ·ï¼ŒArkTSä¸æ”¯æŒä¸¤ä¸ª`boolean`ç±»åž‹çš„å€¼ç›¸åŠ ã€‚å…¶ä»–æƒ…å½¢ä¸‹ï¼Œéƒ½éœ€è¦æ˜¾å¼è½¬æ¢ä¸ºå—符串。
**TypeScript**
@@ -1973,6 +1813,10 @@ let e = "Hello, " + "world!" // "Hello, world!"
let f = "string" + true // "stringtrue"
let g = (new Object()) + "string" // "[object Object]string"
+
+let i = true + true // JS: 2, TS: 编译时错误
+let j = true + 2 // JS: 3, TS: 编译时错误
+let k = E.E1 + true // JS: 1, TS: 编译时错误
```
**ArkTS**
@@ -1989,13 +1833,15 @@ let e = "Hello, " + "world!" // "Hello, world!"
let f = "string" + true // "stringtrue"
let g = (new Object()).toString() + "string"
+
+let i = true + true // 编译时错误
+let j = true + 2 // 编译时错误
+let k = E.E1 + true // 编译时错误
```
**相关约æŸ**
* 一元è¿ç®—符+ã€-å’Œ~仅适用于数值类型
-* 一元è¿ç®—符`+`ä¸èƒ½å°†ä»»ä½•ç±»åž‹è½¬æ¢ä¸ºæ•°å€¼ç±»åž‹
-* 二元è¿ç®—符\*ã€/ã€%ã€-ã€<<ã€>>ã€>>>ã€&ã€^ å’Œ|仅适用于数值类型
### 部分支æŒ`instanceof`è¿ç®—符
@@ -2008,31 +1854,27 @@ let g = (new Object()).toString() + "string"
**TypeScript**
```typescript
-class X {}
+class X {
+ // ...
+}
let a = (new X()) instanceof Object // true
-let b = (new X()) instanceof X // true
-// å·¦æ“作数是类型
-let c = X instanceof Object // true
-let d = X instanceof X // false
-
-// å·¦æ“作数的类型ä¸æ˜¯any类型
-let e = (5.0 as Number) instanceof Number // false
+let b = (new X()) instanceof X // true
+let c = X instanceof Object // true, å·¦æ“作数是一个类型
+let d = X instanceof X // false, å·¦æ“作数是一个类型
```
**ArkTS**
```typescript
-class X {}
+class X {
+ // ...
+}
let a = (new X()) instanceof Object // true
-let b = (new X()) instanceof X // true
-// å·¦æ“作数是类型
-let c = X instanceof Object // 编译时错误
-let d = X instanceof X // 编译时错误
-
-// å·¦æ“作数å¯ä»¥ä¸ºä»»ä½•å¼•ç”¨ç±»åž‹ï¼Œå¦‚Number
-let e = (5.0 as Number) instanceof Number // true
+let b = (new X()) instanceof X // true
+let c = X instanceof Object // 编译时错误, å·¦æ“作数是一个类型
+let d = X instanceof X // 编译时错误, å·¦æ“作数是一个类型
```
### ä¸æ”¯æŒ`in`è¿ç®—符
@@ -2067,7 +1909,7 @@ let b = p instanceof Person // true，且属性name一定å˜åœ¨
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* 访问未定义的属性将导致编译时错误
* ä¸æ”¯æŒdeleteè¿ç®—符
@@ -2105,11 +1947,11 @@ let tmp = one
one = two
two = tmp
-let data: Number[] = [1,2,3,4]
+let data: Number[] = [1, 2, 3, 4]
let head = data[0]
-let tail = new Array(data.length - 1)
+let tail: Number[] = []
for (let i = 1; i < data.length; ++i) {
- tail[i - 1] = data[i]
+ tail.push(data[i])
}
```
@@ -2221,7 +2063,7 @@ let c1 = arr[2]
**级别：错误**
-在TypeScriptçš„catchè¯å¥ä¸ï¼Œåªèƒ½æ ‡æ³¨ç±»åž‹ä¸º`any`或`unknown`。由于ArkTSä¸æ”¯æŒè¿™äº›ç±»åž‹ï¼Œåº”çœç•¥ç±»åž‹æ³¨é‡Šã€‚
+在TypeScriptçš„catchè¯å¥ä¸ï¼Œåªèƒ½æ ‡æ³¨`any`或`unknown`类型。由于ArkTSä¸æ”¯æŒè¿™äº›ç±»åž‹ï¼Œåº”çœç•¥ç±»åž‹æ ‡æ³¨ã€‚
**TypeScript**
@@ -2229,7 +2071,9 @@ let c1 = arr[2]
try {
// 一些代ç
}
-catch (a: unknown) {}
+catch (a: unknown) {
+ // 处ç†å¼‚常
+}
```
**ArkTS**
@@ -2238,7 +2082,9 @@ catch (a: unknown) {}
try {
// 一些代ç
}
-catch (a) {}
+catch (a) {
+ // 处ç†å¼‚常
+}
```
**相关约æŸ**
@@ -2278,11 +2124,11 @@ for (let i = 0; i < a.length; ++i) {
### ä¸æ”¯æŒå¯è¿ä»£æŽ¥å£
-**规则：**`arkts-noiterable`
+**规则：**`arkts-no-iterable`
**级别：错误**
-ArkTSä¸æ”¯æŒ`Symbol` APIã€`Symbol.iterator`和最终å¯è¿ä»£çš„接å£ã€‚è¯·ä½¿ç”¨æ•°ç»„å’Œæ ‡å‡†åº“ä¸çš„容器。
+ArkTSä¸æ”¯æŒ`Symbol`APIã€`Symbol.iterator`和最终å¯è¿ä»£çš„接å£ã€‚è¯·ä½¿ç”¨æ•°ç»„å’Œæ ‡å‡†åº“ä¸çš„容器。
**相关约æŸ**
@@ -2311,7 +2157,7 @@ for (let s of a) {
```typescript
let a: Set<number> = new Set([1, 2, 3])
-let numbers = a.values()
+let numbers = Array.from(a.values())
for (let n of numbers) {
console.log(n)
}
@@ -2364,6 +2210,22 @@ class CFlags {
ArkTSä¸æ”¯æŒ`with`è¯å¥ã€‚使用其他è¯æ³•æ¥è¡¨ç¤ºç›¸åŒçš„è¯ä¹‰ã€‚
+**TypeScript**
+
+```typescript
+with (Math) { // 编译时错误, 但是ä»èƒ½ç”ŸæˆJavaScript代ç
+ let r: number = 42
+ console.log("Area: ", PI * r * r)
+}
+```
+
+**ArkTS**
+
+```typescript
+let r: number = 42
+console.log("Area: ", Math.PI * r * r)
+```
+
### `case`è¯å¥ä»…支æŒç¼–译期值
**规则：**`arkts-no-computed-case`
@@ -2417,7 +2279,7 @@ switch (x) {
**级别：错误**
-ArkTS支æŒ`switch`è¯å¥ä¸ä½¿ç”¨`number`, `Number`, `string`, `String` 或者`enum`类型的值。其他情况下请使用`if`è¯å¥ã€‚
+ArkTS支æŒ`switch`è¯å¥ä¸ä½¿ç”¨`number`, `Number`, `string`, `String`或者`enum`类型的值。其他情况下请使用`if`è¯å¥ã€‚
**TypeScript**
@@ -2483,6 +2345,7 @@ ArkTS在部分场景ä¸æ”¯æŒå¯¹å‡½æ•°è¿”回类型进行推æ–。当`return`è¯
**TypeScript**
```typescript
+// åªæœ‰åœ¨å¼€å¯noImplicitAny选项时会产生编译时错误
function f(x: number) {
if (x <= 0) {
return x
@@ -2490,6 +2353,7 @@ function f(x: number) {
return g(x)
}
+// åªæœ‰åœ¨å¼€å¯noImplicitAny选项时会产生编译时错误
function g(x: number) {
return f(x - 1)
}
@@ -2513,7 +2377,7 @@ function f(x: number) : number {
return g(x)
}
-// éœ€æ ‡æ³¨è¿”å›žç±»åž‹ï¼š
+// å¯ä»¥çœç•¥è¿”回类型，返回类型å¯ä»¥ä»Žfçš„ç±»åž‹æ ‡æ³¨æŽ¨å¯¼å¾—åˆ°
function g(x: number) : number {
return f(x - 1)
}
@@ -2617,7 +2481,7 @@ ArkTSä¸æ”¯æŒåœ¨å‡½æ•°ä¸ä½¿ç”¨`this`。åªèƒ½åœ¨æ–¹æ³•ä¸ä½¿ç”¨`this`。
```typescript
function foo(i: number) {
- this.count = i
+ this.count = i // åªæœ‰åœ¨å¼€å¯noImplicitThis选项时会产生编译时错误
}
class A {
@@ -2884,7 +2748,7 @@ console.log(p3d.x, p3d.y, p3d.z)
### 接å£ä¸èƒ½ç»§æ‰¿å…·æœ‰ç›¸åŒå±žæ€§çš„两个接å£
-**规则：**`arkts-no-extend-same-property`
+**规则：**`arkts-no-extend-same-prop`
**级别：错误**
@@ -3051,7 +2915,7 @@ interface SelectableControl extends Control {
**级别：错误**
-ArkTSä¸ï¼Œå¯¹è±¡å¸ƒå±€åœ¨ç¼–译时就确定了，且ä¸èƒ½åœ¨è¿è¡Œæ—¶è¢«æ›´æ”¹ã€‚ç¦æ¢è¿è¡Œæ—¶æ£€æŸ¥å¯¹è±¡å±žæ€§ã€‚使用`as`è¿ç®—符进行类型转æ¢ä»¥è¯»å–相应的属性和方法。读å–对象ä¸ä¸å˜åœ¨çš„属性将导致编译时错误。
+ArkTSä¸ï¼Œå¯¹è±¡å¸ƒå±€åœ¨ç¼–译时就确定了，且ä¸èƒ½åœ¨è¿è¡Œæ—¶è¢«æ›´æ”¹ã€‚ç¦æ¢è¿è¡Œæ—¶æ£€æŸ¥å¯¹è±¡å±žæ€§ã€‚使用`as`è¿ç®—符进行类型转æ¢ä»¥è®¿é—®ç›¸åº”的属性和方法。访问对象ä¸ä¸å˜åœ¨çš„属性将导致编译时错误。
**TypeScript**
@@ -3096,7 +2960,7 @@ function main(): void {
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* 访问未定义的属性将导致编译时错误
* ä¸æ”¯æŒdeleteè¿ç®—符
@@ -3203,7 +3067,7 @@ function main(): void {
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* 访问未定义的属性将导致编译时错误
* ä¸æ”¯æŒdeleteè¿ç®—符
@@ -3323,25 +3187,6 @@ namespace MyNamespace {
MyNamespace.x = 2
```
-### 脚本和模å—
-
-**规则：**`arkts-no-scripts`
-
-**级别：错误**
-
-通常æ¥è¯´ï¼ŒArkTSä¸çš„脚本和模å—与TypeScriptéžå¸¸æŽ¥è¿‘。它们的差异在å¦å¤–的约æŸä¸æ述。
-
-**相关约æŸ**
-
-* ä¸æ”¯æŒimport type
-* ä¸æ”¯æŒä»…为副作用而导入一个模å—
-* ä¸æ”¯æŒimport default as ...
-* ä¸æ”¯æŒrequire
-* ä¸æ”¯æŒé‡å‘½å导出
-* ä¸æ”¯æŒå¯¼å‡ºåˆ—表
-* ä¸æ”¯æŒé‡å¯¼å‡º
-* ä¸æ”¯æŒé€šè¿‡export = ...
-
### ä¸æ”¯æŒå‘½å空间ä¸çš„éžå£°æ˜Žè¯å¥
**规则：**`arkts-no-ns-statements`
@@ -3386,23 +3231,23 @@ ArkTSä¸æ”¯æŒ`import type`。改为`import`。
```typescript
// 通用导入è¯æ³•
-import { APIResponseType } from "./api"
+import { APIResponseType } from "api"
// 导入类型
-import type { APIResponseType } from "./api"
+import type { APIResponseType } from "api"
```
**ArkTS**
```typescript
-import { APIResponseType } from "./api"
+import { APIResponseType } from "api"
```
**相关约æŸ**
* ä¸æ”¯æŒä»…为副作用而导入一个模å—
* ä¸æ”¯æŒimport default as ...
-* ä¸æ”¯æŒrequire
+* ä¸æ”¯æŒrequireå’Œimport赋值表达å¼
### ä¸æ”¯æŒä»…为副作用而导入一个模å—
@@ -3437,7 +3282,7 @@ import * from "path/to/module"
**级别：错误**
-ArkTSä¸æ”¯æŒ`import default as ...` è¯æ³•ã€‚使用显å¼çš„`import ... from ...` è¯æ³•ã€‚
+ArkTSä¸æ”¯æŒ`import default as ...`è¯æ³•ã€‚使用显å¼çš„`import ... from ...`è¯æ³•ã€‚
**TypeScript**
@@ -3451,13 +3296,13 @@ import { default as d } from "mod"
import d from "mod"
```
-### ä¸æ”¯æŒ`require`
+### ä¸æ”¯æŒ`require`å’Œ`import`赋值表达å¼
**规则：**`arkts-no-require`
**级别：错误**
-ArkTSä¸æ”¯æŒé€šè¿‡`require`导入。改用`import`。
+ArkTSä¸æ”¯æŒé€šè¿‡`require`导入，也ä¸æ”¯æŒ`import`赋值表达å¼ã€‚改用`import`。
**TypeScript**
@@ -3471,110 +3316,34 @@ import m = require("mod")
import * as m from "mod"
```
-### ä¸æ”¯æŒé‡å‘½å导出
-
-**规则：**`arkts-no-export-renaming`
-
-**级别：错误**
-
-ArkTSä¸æ”¯æŒé‡å‘½å导出。å¯ä»¥é‡‡ç”¨è®¾ç½®åˆ«åçš„æ–¹å¼ã€‚
-
-**TypeScript**
-
-```typescript
-// file1.ts
-class MyClass {
- // ...
-}
-
-export { MyClass as RenamedClass }
-
-// file2.ts
-import { RenamedClass } from "./file1"
-
-function main(): void {
- const myObject = new RenamedClass()
- // ...
-}
-```
-
-**ArkTS**
-
-```typescript
-// module1
-class MyClass {
- // ...
-}
-
-export type RenamedClass = MyClass
-
-// module2
-import { RenamedClass } from "./module1"
-
-function main(): void {
- const myObject = new RenamedClass()
- // ...
-}
-```
-
**相关约æŸ**
-* ä¸æ”¯æŒå¯¼å‡ºåˆ—表
-* ä¸æ”¯æŒé‡å¯¼å‡º
-* ä¸æ”¯æŒé€šè¿‡export = ...
+* ä¸æ”¯æŒexport = ...è¯æ³•
-### ä¸æ”¯æŒå¯¼å‡ºåˆ—表
+### 部分支æŒé‡å¯¼å‡º
-**规则：**`arkts-no-export-list-decl`
+**规则：**`arkts-limited-reexport`
**级别：错误**
-ArkTSä¸æ”¯æŒå¯¼å‡ºåˆ—表的è¯æ³•ã€‚使用`export`关键å—显å¼å¯¼å‡ºæ¯ä¸ªå€¼ã€‚
-
-**TypeScript**
-
-```typescript
-export { x }
-export { x } from "mod"
-export { x, y as b, z as c }
-```
-
-**ArkTS**
-
-```typescript
-let x = 1
-class MyClass {}
-export let y = x, z: number = 2
-export type RenamedClass = MyClass
-```
-
-**相关约æŸ**
-
-* ä¸æ”¯æŒé‡å‘½å导出
-* ä¸æ”¯æŒé‡å¯¼å‡º
-* ä¸æ”¯æŒé€šè¿‡export = ...
-
-### ä¸æ”¯æŒé‡å¯¼å‡º
-
-**规则：**`arkts-no-reexport`
-
-**级别：错误**
-
-ArkTSä¸æ”¯æŒé‡å¯¼å‡ºã€‚从导出模å—显å¼å¯¼å…¥ã€‚
+ArkTS支æŒå¤§å¤šæ•°åœºæ™¯ä¸‹çš„é‡å¯¼å‡ºï¼Œæ¯”如命å导出和é‡å‘½å导出，é‡å¯¼å‡ºimport的。ä¸æ”¯æŒ`export * as ...`。
**TypeScript**
```typescript
// module1
-export class MyClass {
+export class Class1 {
+ // ...
+}
+export class Class2 {
// ...
}
// module2
-export { MyClass } from "module1"
+export * as utilities from "module1"
// consumer模å—
-import { MyClass } from "module2"
+import { utilities } from "module2"
const myInstance = new MyClass()
```
@@ -3583,27 +3352,28 @@ const myInstance = new MyClass()
```typescript
// module1
-export class MyClass {
- // ...
+export class Class1 {
+ // ...
+}
+export class Class2 {
+ // ...
}
// module2
-// some stuff
+export { Class1 } from "module1"
+export { C2 as Class2 } from "module1"
// consumer模å—
-import { MyClass } from "module1"
-import * from "module2"
+import { Class1, Class2 } from "module2"
const myInstance = new MyClass()
```
**相关约æŸ**
-* ä¸æ”¯æŒé‡å‘½å导出
-* ä¸æ”¯æŒå¯¼å‡ºåˆ—表
-* ä¸æ”¯æŒé€šè¿‡export = ...
+* ä¸æ”¯æŒexport = ...è¯æ³•
-### ä¸æ”¯æŒé€šè¿‡`export = ...`
+### ä¸æ”¯æŒ`export = ...`è¯æ³•
**规则：**`arkts-no-export-assignment`
@@ -3645,9 +3415,8 @@ let p = Pt.origin
**相关约æŸ**
-* ä¸æ”¯æŒé‡å‘½å导出
-* ä¸æ”¯æŒå¯¼å‡ºåˆ—表
-* ä¸æ”¯æŒé‡å¯¼å‡º
+* ä¸æ”¯æŒrequireå’Œimport赋值表达å¼
+* 部分支æŒé‡å¯¼å‡º
### ä¸æ”¯æŒ`export type`
**规则：**`arkts-no-special-exports`
@@ -3659,14 +3428,32 @@ ArkTSä¸æ”¯æŒ`export type`。改用`export`。
**TypeScript**
```typescript
-class C {}
-export type { C }
+// 显å¼å¯¼å‡ºclass：
+export class Class1 {
+ // ...
+}
+
+// 声明一个类，之åŽé€šè¿‡`export type`导出
+class Class2 {
+ // ...
+}
+
+// ä¸æ”¯æŒ
+export type { Class2 }
```
**ArkTS**
```typescript
-export class C {}
+// 显å¼å¯¼å‡ºclass：
+export class Class1 {
+ // ...
+}
+
+// 显å¼å¯¼å‡ºclass：
+export class Class2 {
+ // ...
+}
```
### ä¸æ”¯æŒambient module声明
@@ -3689,7 +3476,7 @@ declare module "someModule" {
```typescript
// 从原始模å—ä¸å¯¼å…¥éœ€è¦çš„内容
-import { normalize } from "../someModule"
+import { normalize } from "someModule"
```
**相关约æŸ**
@@ -3708,10 +3495,25 @@ import { normalize } from "../someModule"
**TypeScript**
```typescript
+// 声明
declare module "*!text" {
const content: string
export default content
}
+
+import fileContent from "some.txt!text"
+```
+
+**ArkTS**
+
+```typescript
+// 声明
+declare namespace N {
+ function foo(x: number): number
+}
+
+import * from "module"
+console.log("N.foo called: ", N.foo(42))
```
**相关约æŸ**
@@ -3748,7 +3550,7 @@ namespace mathLib {
}
// 程åºä¸
-import { mathLib } from "./math-lib"
+import { mathLib } from "math-lib"
mathLib.isPrime(2)
```
@@ -3767,13 +3569,13 @@ ArkTSä¸å…许在模å—æ ‡è¯†ç¬¦ä¸ä½¿ç”¨`.js`扩展åï¼Œå› ä¸ºArkTS本身有
**TypeScript**
```typescript
-import { something } from "./module.js"
+import { something } from "module.js"
```
**ArkTS**
```typescript
-import { something } from "./module"
+import { something } from "module"
```
**相关约æŸ**
@@ -3803,6 +3605,19 @@ class CustomError extends Error {
}
```
+**ArkTS**
+
+```typescript
+class CustomError extends Error {
+ constructor(message?: string) {
+ // è°ƒç”¨çˆ¶ç±»æž„é€ å‡½æ•°ï¼Œç»§æ‰¿é“¾æ˜¯é™æ€çš„，且ä¸èƒ½åœ¨è¿è¡Œæ—¶è¢«æ”¹å˜
+ super(message)
+ console.log(this instanceof Error) // true
+ }
+}
+let ce = new CustomError()
+```
+
**相关约æŸ**
* ä¸æ”¯æŒåœ¨åŽŸåž‹ä¸Šèµ‹å€¼
@@ -3818,13 +3633,13 @@ class CustomError extends Error {
**TypeScript**
```typescript
-const zipUtil = await import("./utils/create-zip-file")
+const zipUtil = await import("utils/create-zip-file")
```
**ArkTS**
```typescript
-import { zipUtil } from "./utils/create-zip-file"
+import { zipUtil } from "utils/create-zip-file"
```
**相关约æŸ**
@@ -3867,7 +3682,7 @@ let x: number = initialize()
console.log("x = " + x)
```
-### ä¸æ”¯æŒIIFE作为命å空间的声明
+### ä¸æ”¯æŒIIFE（立å³è°ƒç”¨å‡½æ•°è¡¨è¾¾å¼ï¼‰ä½œä¸ºå‘½å空间的声明
**规则：**`arkts-no-iife`
@@ -3879,9 +3694,10 @@ console.log("x = " + x)
```typescript
var C = (function() {
- function C(n) {
- this.p = n
+ function C(n: number) {
+ this.p = n // åªæœ‰åœ¨å¼€å¯noImplicitThis选项时会产生编译时错误
}
+ C.staticProperty = 0
return C
})()
C.staticProperty = 1
@@ -3907,7 +3723,7 @@ ArkTSæ²¡æœ‰åŽŸåž‹çš„æ¦‚å¿µï¼Œå› æ¤ä¸æ”¯æŒåœ¨åŽŸåž‹ä¸Šèµ‹å€¼ã€‚æ¤ç‰¹æ€§ä¸ç¬¦
```typescript
var C = function(p) {
- this.p = p
+ this.p = p // åªæœ‰åœ¨å¼€å¯noImplicitThis选项时会产生编译时错误
}
C.prototype = {
@@ -3916,8 +3732,22 @@ C.prototype = {
}
}
-C.prototype.q = function(r) {
- return this.p === r
+C.prototype.q = function(r: number) {
+ return this.p == r
+}
+```
+
+**ArkTS**
+
+```typescript
+class C {
+ p: number = 0
+ m() {
+ console.log(this.p)
+ }
+ q(r: number) {
+ return this.p == r
+ }
}
```
@@ -3939,7 +3769,7 @@ C.prototype.q = function(r) {
// 全局文件ä¸
var abc = 100
-// 从上é¢å¼•ç”¨'abc'。
+// 从上é¢å¼•ç”¨'abc'
globalThis.abc = 200
```
@@ -3950,7 +3780,7 @@ globalThis.abc = 200
export let abc : number = 0
// file2
-import * as M from "../file1"
+import * as M from "file1"
M.abc = 200
```
@@ -3960,13 +3790,16 @@ M.abc = 200
* ä¸æ”¯æŒå£°æ˜Žå‡½æ•°çš„属性
* æ ‡å‡†åº“ä½¿ç”¨é™åˆ¶
-### ä¸æ”¯æŒutility类型
+### ä¸æ”¯æŒä¸€äº›utility类型
**规则：**`arkts-no-utility-types`
**级别：错误**
-当å‰ArkTSä¸æ”¯æŒä»ŽTypeScriptæ‰©å±•åˆ°æ ‡å‡†åº“çš„utility类型（例如`Omit`ã€`Partial`ã€`Readonly`ã€`Record`ã€`Pick`ç‰)。
+当å‰ArkTSä¸æ”¯æŒä»ŽTypeScriptæ‰©å±•åˆ°æ ‡å‡†åº“çš„utility类型（例如`Omit`ã€`Pick`ç‰ï¼‰ã€‚支æŒ`Partial`å’Œ`Record`。
+
+对于*Record<K, V>*类型，表达å¼*rec[index]*的类型是*V | undefined*。
+对于`Record`类型，键-值ä¸çš„值的类型必须是å¯é€‰ç±»åž‹æˆ–者包å«`undefined`çš„è”åˆç±»åž‹ã€‚
**TypeScript**
@@ -3978,20 +3811,55 @@ type Person = {
}
type QuantumPerson = Omit<Person, "location">
+
+let persons : Record<string, Person> = {
+ "Alice": {
+ name: "Alice",
+ age: 32,
+ location: "Shanghai"
+ },
+ "Bob": {
+ name: "Bob",
+ age: 48,
+ location: "New York"
+ }
+}
+console.log(persons["Bob"].age)
+console.log(persons["Rob"].age) // è¿è¡Œæ—¶å¼‚常
```
**ArkTS**
```typescript
class Person {
- name: string
- age: number
- location: string
+ name: string = ""
+ age: number = 0
+ location: string = ""
}
class QuantumPerson {
- name: string
- age: number
+ name: string = ""
+ age: number = 0
+}
+
+type OptionalPerson = Person | undefined
+let persons : Record<string, OptionalPerson> = {
+// 或者
+// let persons : Record<string, Person | undefined> = {
+ "Alice": {
+ name: "Alice",
+ age: 32,
+ location: "Shanghai"
+ },
+ "Bob": {
+ name: "Bob",
+ age: 48,
+ location: "New York"
+ }
+}
+console.log(persons["Bob"]!.age)
+if (persons["Rob"]) { // 值检查，ä¸ä¼šè¿è¡Œæ—¶æŠ›å¼‚常
+ console.log(persons["Rob"].age)
}
```
@@ -4038,15 +3906,15 @@ class MyImage {
// ...
}
-function readImage(
+async function readImage(
path: string, callback: (err: Error, image: MyImage) => void
) : Promise<MyImage>
{
- // 异æ¥å®žçŽ°
+ return await new MyImage()
}
function readImageSync(path: string) : MyImage {
- // åŒæ¥å®žçŽ°
+ return new MyImage()
}
```
@@ -4165,7 +4033,7 @@ let x : string = "hello"
let y : number[] = [10, 20]
class Label {
- text : string
+ text : string = ""
}
// 'Label'类型
@@ -4185,14 +4053,14 @@ let z : Label = {
**TypeScript**
```typescript
-import { obj } from "./something.json" assert { type: "json" }
+import { obj } from "something.json" assert { type: "json" }
```
**ArkTS**
```typescript
// 编译时将检查导入Tçš„æ£ç¡®æ€§
-import { something } from "./module"
+import { something } from "module"
```
**相关约æŸ**
@@ -4241,7 +4109,7 @@ ArkTSä¸å…许使用TypeScript或JavaScriptæ ‡å‡†åº“ä¸çš„æŸäº›æŽ¥å£ã€‚大部
**相关约æŸ**
-* 仅支æŒå±žæ€§åç§°ä¸ºæ ‡è¯†ç¬¦çš„å¯¹è±¡
+* 对象的属性å必须是åˆæ³•çš„æ ‡è¯†ç¬¦
* ä¸æ”¯æŒSymbol() API
* 访问未定义的属性将导致编译时错误
* ä»…å…许在表达å¼ä¸ä½¿ç”¨typeofè¿ç®—符
@@ -4249,3 +4117,153 @@ ArkTSä¸å…许使用TypeScript或JavaScriptæ ‡å‡†åº“ä¸çš„æŸäº›æŽ¥å£ã€‚大部
* ç¦æ¢è¿è¡Œæ—¶æ£€æŸ¥å¯¹è±¡å±žæ€§
* ä¸æ”¯æŒå£°æ˜ŽåŠ¨æ€å±žæ€§
* ä¸æ”¯æŒglobalThis
+
+### 强制开å¯ä¸¥æ ¼ç±»åž‹æ£€æŸ¥
+
+**规则 `arkts-strict-typing`**
+
+**级别：错误**
+
+在ArkTSä¸ï¼Œä»¥ä¸‹TypeScriptçš„ä¸¥æ ¼ç±»åž‹æ£€æŸ¥é€‰é¡¹å¿…é¡»æ‰“å¼€ï¼š`noImplicitReturns`,
+`strictFunctionTypes`, `strictNullChecks`, `strictPropertyInitialization`。
+
+**TypeScript**
+
+```typescript
+class C {
+ n: number // åªæœ‰åœ¨å¼€å¯strictPropertyInitialization选项时会产生编译时错误
+ s: string // åªæœ‰åœ¨å¼€å¯strictPropertyInitialization选项时会产生编译时错误
+}
+
+// åªæœ‰åœ¨å¼€å¯noImplicitReturns选项时会产生编译时错误
+function foo(s: string): string {
+ if (s != "") {
+ console.log(s)
+ return s
+ } else {
+ console.log(s)
+ }
+}
+
+let n: number = null // åªæœ‰åœ¨å¼€å¯strictNullChecks选项时会产生编译时错误
+```
+
+**ArkTS**
+
+```typescript
+class C {
+ n: number = 0
+ s: string = ""
+}
+
+function foo(s: string): string {
+ console.log(s)
+ return s
+}
+
+let n1: number | null = null
+let n2: number = 0
+```
+
+**相关约æŸ**
+
+* 使用具体的类型而éžany或unknown
+* ä¸å…许通过注释关é—类型检查
+
+### ä¸å…许通过注释关é—类型检查
+
+**规则 `arkts-strict-typing-required`**
+
+**级别：错误**
+
+在ArkTSä¸ï¼Œç±»åž‹æ£€æŸ¥ä¸æ˜¯å¯é€‰é¡¹ã€‚ä¸å…许通过注释关é—类型检查，ä¸æ”¯æŒä½¿ç”¨`@ts-ignore`å’Œ`@ts-nocheck`。
+
+**TypeScript**
+
+```typescript
+// @ts-nocheck
+// ...
+// å…³é—了类型检查åŽçš„代ç
+// ...
+
+let s1: string = null // 没有报错
+
+// @ts-ignore
+let s2: string = null // 没有报错
+```
+
+**ArkTS**
+
+```typescript
+let s1: string | null = null // 没有报错，åˆé€‚的类型
+let s2: string = null // 编译时报错
+```
+
+**相关约æŸ**
+
+* 使用具体的类型而éžany或unknown
+* 强制开å¯ä¸¥æ ¼ç±»åž‹æ£€æŸ¥
+
+### å…许ArkTS代ç 导入TS代ç , ä¸å…许TS代ç 导入ArkTS代ç
+
+**规则 `arkts-no-ts-deps`**
+
+**级别：错误**
+
+ArkTSä¸çš„代ç å¯ä»¥å¯¼å…¥æ¥è‡ªæ ‡å‡†TypeScript的代ç ï¼Œè€Œæ ‡å‡†TypeScript的代ç ä¸èƒ½å¯¼å…¥æ¥è‡ªArkTSä¸çš„代ç 。
+
+**TypeScript**
+
+```typescript
+// app.ets
+export class C {
+ // ...
+}
+
+// lib.ts
+import { C } from "app"
+```
+
+**ArkTS**
+
+```typescript
+// lib1.ets
+export class C {
+ // ...
+}
+
+// lib2.ets
+import { C } from "lib1"
+```
+
+### 除了ArkUIä¸çš„装饰器，ä¸å…许使用其他装饰器
+
+**规则 `arkts-no-decorators-except-arkui`**
+
+**级别：错误**
+
+现在，ArkTSä¸åªæ”¯æŒArkUIä¸çš„è£…é¥°å™¨ã€‚ä½¿ç”¨å…¶ä»–è£…é¥°å™¨ä¼šé€ æˆç¼–译时错误。
+
+**TypeScript**
+
+```typescript
+function classDecorator(x: number, y: number): void {
+ //
+}
+
+@classDecorator
+class BugReport {
+}
+```
+
+**ArkTS**
+
+```typescript
+function classDecorator(x: number, y: number): void {
+ //
+}
+
+@classDecorator // 编译时错误
+class BugReport {
+}
+```