const varName[: type] [= value];
// e.g.
const myName: string = "Alice";
const fruit = "apple";
const myAge number;
const whatever: any;

const num = 12
// output: number
console.log(typeof num);

function printId(id: number | string) {
  console.log("Your ID is: " + id);
}

printId(101);  // OK
printId("202");  // OK
printId({ myID: 22342 });
// Error!!!
// Argument of type '{ myID: number; }' 
// is not assignable to parameter of type 'string | number'.

function printTextOrNumberOrBool(
  textOrNumberOrBool:
    | string
    | number
    | boolean
) {
  console.log(textOrNumberOrBool);
}

function printId(id: number | string) {
  console.log(id.toUpperCase());
  // Property 'toUpperCase' does not exist on type 'string | number'.
  // Property 'toUpperCase' does not exist on type 'number'.
}

function printId(id: number | string) {
  if (typeof id === "string") {
    // In this branch, id is of type 'string'
    console.log(id.toUpperCase());
  } else {
    // Here, id is of type 'number'
    console.log(id);
  }
}

enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}

enum Direction {
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT",
}

if(boolean_expression){
    // 在布尔表达式 boolean_expression 为 true 执行
}

const num:number = 5
if (num > 0) { 
   console.log("数字是正数") 
}

if(boolean_expression){
   // 在布尔表达式 boolean_expression 为 true 执行
}else{
   // 在布尔表达式 boolean_expression 为 false 执行
}

const num:number = 12; 
if (num % 2==0) { 
    console.log("偶数"); 
} else {
    console.log("奇数"); 
}

if(boolean_expression 1) {
    // 在布尔表达式 boolean_expression 1 为 true 执行
} else if( boolean_expression 2) {
    // 在布尔表达式 boolean_expression 2 为 true 执行
} else if( boolean_expression 3) {
    // 在布尔表达式 boolean_expression 3 为 true 执行
} else {
    // 布尔表达式的条件都为 false 时执行
}

const num:number = 2 
if(num > 0) { 
    console.log(num+" 是正数") 
} else if(num < 0) { 
    console.log(num+" 是负数") 
} else { 
    console.log(num+" 不是正数也不是负数") 
}

switch(expression){
    case constant-expression  :
       statement(s);
       break; /* 可选的 */
    case constant-expression  :
       statement(s);
       break; /* 可选的 */
  
    /* 您可以有任意数量的 case 语句 */
    default : /* 可选的 */
       statement(s);
}

const grade:string = "A"; 
switch(grade) { 
    case "A": { 
        console.log("优"); 
        break; 
    } 
    case "B": { 
        console.log("良"); 
        break; 
    } 
    case "C": {
        console.log("及格"); 
        break;    
    } 
    case "D": { 
        console.log("不及格"); 
        break; 
    }  
    default: { 
        console.log("非法输入"); 
        break;              
    } 
}

Test ? expr1 : expr2

for ( init; condition; increment ){
    statement(s);
}

const num:number = 5; 
let i:number; 
let factorial = 1; 
 
for(i = num;i>=1;i--) {
   factorial *= i;
}
console.log(factorial)
// output: 120

break;

let i:number = 1 
while(i<=10) { 
    if (i % 5 == 0) {   
        console.log ("在1~10之间第一个被5整除的数为: "+i) 
        break     // 找到一个后退出循环
    } 
    i++ 
}
// output: 在1~10之间第一个被5整除的数为: 5

continue;

let num:number = 0
let count:number = 0;

for(num=0;num<=20;num++) {
    if (num % 2==0) {
        continue
    }
    count++
}
console.log ("0~20之间的奇数个数为: "+count)
// output: 0~20之间的奇数个数为: 10

for (let val in list) { 
    statement(s);
}
// val 需要为 string 或 any 类型。

let j:any; 
const n:any = "a b c" 
 
for(j in n) {
    console.log(n[j])  
}
// output:
/* a
 *
 * b
 *
 * c
 */

let someArray = [1, "string", false];
 
for (let entry of someArray) {
    console.log(entry); // 1, "string", false
}

let list = [4, 5, 6];
list.forEach((val, idx, array) => {
    // val: 当前值
    // idx：当前index
    // array: Array
});

while(condition)
{
   statement(s);
}

let num:number = 5; 
let factorial:number = 1; 
 
while(num >=1) { 
    factorial = factorial * num; 
    num--; 
} 
console.log("5的阶乘为："+factorial);
// output: 5的阶乘为：120

do
{
   statement(s);
} while(condition);

let n:number = 10;
do { 
    console.log(n); 
    n--; 
} while(n>=0);
// output: 
/* 10
 * 9
 * 8
 * 7
 * 6
 * 5
 * 4
 * 3
 * 2
 * 1
 * 0
 */

// for 创建无限循环语法格式：
for(;;) { 
   statement(s);
}

// while 创建无限循环语法格式：
while(true) { 
   statement(s);
} 

// 定义
function function_name(param1 [:datatype], param2 [:datatype], ...):return_type { 
    statements;// 语句
    return value; 
}

//调用
function_name(param1, param2)

// 定义
function hello(
    firstName: string,    // 必须参数
    lastName? :string,    // 可选参数
    hello: string = "Hello",    // 默认参数
): string { 
    let msg: string;
    if (lastName) {
        return hello +"! " + firstName + " " + lastName;
    } else {
        return hello +"! " + firstName;
    }
}

// 调用 1
const msg = hello("Alice", "Hayes", "Hi")
console.log(msg)  // "Hi! Alice Hayes" 
// 调用 2
const msg = hello("Ben")
console.log(msg)  // "Hello! Ben" 

var res = function( [arguments] ) { ... }

const msg = function() { 
    return "hello world";  
} 
console.log(msg())
// output: hello world

const res = function(a:number,b:number) { 
    return a*b;  
}; 
console.log(res(12,2))
// output: 24

(function () { 
    var x = "Hello!!";   
    console.log(x)     
 })()
 // output: Hello!!

var res = new Function ([arg1[, arg2[, ...argN]],] functionBody)

const myFunction = new Function("a", "b", "return a * b"); 
const x = myFunction(4, 3); 
console.log(x);
// output: 12

function factorial(num: number): number {
    // 停止执行
    if (num <= 0) {
        return 1;
    } else {
        // 调用自身，开始递归
        return (num * factorial(num- 1));
    }
};
// 输出 720
console.log(factorial(6));

([param1, param2,…paramN]) => statement;

// 等价于：
function funcName([param1, param2,…paramN]) {
    return statement;
}

const foo = (x:number) => 10 + x;
// output: 110
console.log(foo(100))

const func = (x)=> { 
    if(typeof x=="number") { 
        console.log(x+" 是一个数字") 
    } else if(typeof x=="string") { 
        console.log(x+" 是一个字符串") 
    }  
} 
// output: 12 是一个数字
func(12) 
// output: Tom 是一个字符串
func("Tom")

// 1. 重载签名（可写多个）
function disp(s1:string):void; 
function disp(n1:number,s1:string):void; 
 
 // 2. 实现签名（必须兼容所有重载）
function disp(x:any,y?:any):void { 
    console.log(x); 
    console.log(y); 
} 

// 3. 调用
disp("abc") 
disp(1,"xyz");

/* output:
 *   abc
 *   undefined
 *   1
 *   xyz 
 */

// 定义
type User = {
  id: number;
  name: string;
  vip?: boolean;        // 可选属性
  readonly createdAt: Date; // 只读属性
};

// 使用
const u: User = { id: 1, name: 'Tom', createdAt: new Date() };

interface User {
  id: number;
  name: string;
}

// 可扩展
interface User {
  vip?: boolean;   // 同名 interface 会自动合并
}

// 可继承
interface VipUser extends User {
  level: number;
}

class User {
  id: number;
  name: string;
  vip = false;          // 带默认值

  constructor(id: number, name: string) {
    this.id = id;
    this.name = name;
  }

  greet() {             // 还能带方法
    console.log(`Hi, ${this.name}`);
  }
}

// The parameter's type annotation is an object type
function printCoord(pt: { x: number; y: number }) {
  console.log("The coordinate's x value is " + pt.x);
  console.log("The coordinate's y value is " + pt.y);
}
printCoord({ x: 3, y: 7 });

type Point = {
  x: number;
  y: number;
};
 
// Exactly the same as the earlier example
function printCoord(pt: Point) {
  console.log("The coordinate's x value is " + pt.x);
  console.log("The coordinate's y value is " + pt.y);
}
 
printCoord({ x: 100, y: 100 });

interface Point {
  x: number;
  y: number;
}
 
function printCoord(pt: Point) {
  console.log("The coordinate's x value is " + pt.x);
  console.log("The coordinate's y value is " + pt.y);
}
 
printCoord({ x: 100, y: 100 });

// Extending an interface
// 扩展接口
interface Animal {
  name: string;
}

interface Bear extends Animal {
  honey: boolean;
}

const bear = getBear();
bear.name;
bear.honey;

// Adding new fields to an existing interface
// 向现有接口添加新字段
interface Window {
  title: string;
}

interface Window {
  ts: TypeScriptAPI;
}

const src = 'const a = "Hello World"';
window.ts.transpileModule(src, {});