# 确保npm已安装
npm --version
6.9.0

# 安装
npm install -g typescript

# 查看版本
tsc --version
Version 3.7.4

# 编译
tsc demo.ts

exports class Demo{}

"use strict";
exports.__esModule = true;
var Demo = /** @class */ (function () {
    function Demo() {
    }
    return Demo;
}());
exports.Demo = Demo;

var name = `
first line
second line
`

function test(template, name, age){
}

var name = 'Tom',

var getAge = function(){
    return 18
}

test`my name is ${name} i'm ${age}`
//相当于 test(["my name is ", " i'm ", ""], name, age)

// 指定变量类型
var woname: string = "Tom";

var alias: any = '12';

var age: number = 12;

var man: boolean = true;

// 定义类中元素类型
class Person {
    name: string;
    age: number;
}

var person = new Person();
person.name = "Jack";
person.age = 23;
console.log(person);

// 指定函数参数和返回值类型
function test(name: string): void {

}

// 设置默认参数, 要声明到最后
function test2(name: string = 'default'): void {

}

// 设置可选参数,要声明明到必选参数之后
function test3(age?: number, name: string = 'default'): void {

}

test2('demo')
test3()

// 任意数量参数
function test4(...args) {
    args.forEach(arg => {
        console.log(arg);
    })
}

test4(1, 2, 3)

// 解包数组ts不支持
function test5(a, b, c) {
}

var args = [1, 2, 3]
test5(...args)

// generator函数，手工控制程序执行 ts不支持
// babeljs: https://www.babeljs.cn/repl
function* test6() {
    yield;
    console.log("log");
}
test6().next()

function* getStock(num: number) {
    let count = 0
    while (true) {
        yield Math.random()
        if (count > num) {
            break
        }
    }
}

console.log(getStock().next().value)

// 对象析构表达式, 可以取别名, 获取嵌套表达式内容,可以有多余的值
const { name1: name2, age1: { age2 } } = {
    name1: "Tom",
    age1: { age2: 23 },
}
console.log(name2, age2);

// 数组析构表达式，位置取
var [a, b, ...others] = [1, 2, 3, 4];
console.log(a, b, others);
// 1 2 [ 3, 4 ]

// 箭头函数匿名表达式, 消除this带来的问题
var sum = (arg1, arg2) => { arg1 + arg2 };

console.log([1, 2, 3, 4].filter(value => value % 2 == 0));
// [ 2, 4 ]

// forEach 循环
var list = [1, 2, 3];

list.forEach(value => {
    console.log(value);
});

// for-in循环打印下标
for (let index in list) {
    console.log(index);
}

// for-of循环打印值
for (let value of list) {
    console.log(value);
}

// 打印字符串
// for (let s of 'munber') {
//     console.log(s);
// }

// class是TS和核心
class Student {
    // 访问控制符，默认
    public name;

    // 外部不能访问，只能在内部访问
    private age;

    // 内部和子类访问，外部不能访问
    protected sex;

    // 构造函数，实例化时候被调用, 可以申明属性
    constructor(public school: string) {
        console.log("constructor");

    }

    eat() {
        console.log("eat");

    }
}

// 实例化
let s1 = new Student('school');
s1.name = 'Tom';
console.log(s1.school);

s1.eat();

class LittleStudent extends Student {
    // 子类自己的数据
    code: string;

    constructor(code: string) {
        // 必须要调用父类构造函数
        super('school');
        this.code = code;
        console.log("LittleStudent");

    }

    work() {
        // 调用父类的方法
        super.eat();
        this.eat();
    }
}

let ls1 = new LittleStudent('LittleStudent');
ls1.eat();
ls1.work();

// 泛型 只能放某个类型元素
let intList: Array<number> = [];
intList.push(1);
// intList.push('2'); 报错

// 接口 代码约定
interface IHuman {
    name: string;
    age: number;
}


class HumanImpl implements IHuman {
    // 实现接口的内容
    name: string;
    age: number;

    constructor(public config: IHuman) {

    }

}

new HumanImpl({ name: 't', age: 12 });

// 不对外暴露
var var0;

function func0() {

}

class Clazz0 {

}

// 对外暴露
export var var1;

export function func1() {

}

export class Clazz1 {

}

// 导入其他模块对外暴露的内容
import { var1, func1, Clazz1 } from './a';

console.log(var1);

func1()

new Clazz1()