TypeScript¶
var identifier: Type = value;
let identifier: Type = value;
const IDENTIFIER: Type = value;
var identifier: any = value;
var v1: number = 1;
let binary: number = 0b101;
let octal: number = 0o5;
let decimal: number = 5;
let hex: number = 0x5;
let v1: string = 'ilnurgi';
let v1: boolean = false;
let v1: symbol = Symbol('ilnurgi');
let v: null = null;
let v: undefind = undefind;
let k: int = 1;
let v: typeof k = 2;
function identifier(param1: Type, param2: Type): ReturnedType {}
function identifier <T, U>(): ReturnedType {}
function func(): void {}
<T, U>( param: Type, param: Type ): Type => value
class A(){}
class B(){}
class C(){}
function move(animal: A | B | C): void {
animal.method_a() // ERROR
animal.method_b() // ERROR
animal.method_c() // ERROR
animal.method_abc() // Ok
}
function start(port: 80 | 42) {}
function animate(name: "easy-in" | "easy-out") {}
var animalAll: (A | B | C)[] = [new A(), new B(), new C()]
// tuple
let lion: [string, number] = [1, 'Simba']
function identifier(p1: T1, p2: T2): T3;
function identifier(p1: T4, p2: T5): T6;
function identifier(p1: T, p2: T): T {
return 'value';
}
function f( ..rest: [number, string, boolean]): void {}
// function f( ..rest: [number, string?, boolean]): void {}
// string? - ? - необязательный
let f2: Function = f;
let tuple: [ number, string, boolean ] = [ 5, '', true ];
let array = [ 5, '', true ];
f( 5 ); // Error
f( 5, '' ); // Error
f( 5, '', true ); // Ok
f( ...tuple ); // Ok
f( tuple[0], tuple[1], tuple[2] ); // Ok
f(...array); // Error
f( array[0], array[1], array[2] );
// Error,
// все элементы массива принадлежат к типу string | number | boolean,
// в то время как первый элемент кортежа принадлежит к типу number
class Identifier {
constructor(p1: T1, p2: T2);
constructor(p1: T3, p2: T4);
constructor(p1: T, p2: T) {}
identifier(p1: T1, p2: T2): T3
identifier(p1: T4, p2: T5): T6;
identifier(p1: T, p2: T): T {
return 'value';
}
}
class Identifier<T> {
static staticField: Type = value; // member
static get staticProperty(): Type { // member
return value;
}
static set staticProperty(value: Type) { // member
}
static staticMethod <T, U>(param: Type, param: Type): Type { } // member
[indexSignature: Type]: Type; // member
[computedProp]: Type = value; // member
field: Type = value; // member
get property(): Type { // member
return value;
}
set property(value: Type) { // member
}
constructor(param0: Type, param1: Type){}
method <T, U>(param: Type, param: Type): Type { } // member
}
enum Fruits {
Apple, // 0
Pear, // 1
}
Fruits[Fruits.Apple]
// Apple
// такие энамы инлайнятся значениями сразу в код
const enum Fruits {
Apple = 2,
Pear = 4,
}
interface IAnimal {
nicknameL string;
execute(command: string): void;
}
class Bird implements IAnimal, IAnimal2 {
nicknameL string;
execute(command: string): void;
}
class Eagle extends Bird implements IFlyable {}
interface IAnimal3 extends IAnimal, IAnimal2 {}
interface IAnimal3 extends Animal {}