let sjfName: string = "sunjianfeng";

// array 可以包含不同類型的數(shù)據(jù)?
let arr: Array<number> = [1, 3, 4];
enum Color {
      Red = 1,
      Green,
      Blue,
}
let sjfColor: Color = Color.Blue;

// 類型診斷不是類型轉(zhuǎn)換蚂且，不進行數(shù)據(jù)的檢查和解構，只在編譯階段起作用
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
// 或者
let strLength2: number = (someValue as string).length;

// var 聲明的變量是函數(shù)作用域，只要在函數(shù)內(nèi)聲明就會在函數(shù)內(nèi)的任何地方訪問到
// 使用let 替代var
// const 與let 有相同的作用域驮吱，只是一旦賦值就不能改變

// 解構數(shù)組
let input = [1, 2];
let [first, second] = input;
// 對象解構
let o = { a: "foo", b: 12 };
//let {a,b} = o;

// 支持...  但是必須是對象中的屬性名茧妒。... 后的參數(shù)名可以任意
let { a, ...passthrough } = o;

// 屬性重命名
let { a: newname1, b: newName2 } = o;
// 默認值
function f({ a, b = 0 } = { a: "", b: 0 }) {

}
//展開
let defaults = { food: "spicy", price: "$$", ambiance: "noisy" };
let search = { ...defaults, food: "rich" };
// 對象的展開會 丟失方法&& 只能展開自身可枚舉的屬性
// 可選屬性
interface SquareConfig {
      color?: string;
      readonly x: number;

}

//接口函數(shù)
interface SearchFunc {
      (source: string, subString: string): boolean;
}
let mySearchF: SearchFunc;
mySearchF = function (s: string, s2: string) {
      return true;
}
interface StringArray {
      [index: number]: string;
}

let myArray: StringArray;

myArray = ["Bob", "Fred"];

let myStr: string = myArray[0];

interface ClockInterface {
      currentTime: Date;
}

class TenClock implements ClockInterface {
      currentTime: Date;
      constructor(h: number, m: number) {

      }

}
//一個接口可以繼承多個接口 interface Shape extends XX, XC,XS { }

// 一個對象可以同時作為函數(shù)和對象使用
interface Counter {
      (start: number): string;
      interval: number;
      reset(): void;
}

function getCounter(): Counter {
      let counter = <Counter>function (start: number) {

      };
      counter.interval = 123;
      counter.reset = function () {

      };
      return counter;
}

let ccounter = getCounter();
ccounter(10);
ccounter.interval = 5.0;

// 訪問控制
// 默認是public

// 靜態(tài)成員 static
// 抽象類和抽象方法
abstract class Department {
      name: string;
      constructor(name: string) {
            this.name = name;
      }
      printName(): void {
            console.log("Department name: " + this.name);
      }
      abstract printMethod():void;
}
/*
class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter: Greeter;
greeter = new Greeter("world");
console.log(greeter.greet());
// 轉(zhuǎn)換為js

let Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();

let greeter;
greeter = new Greeter("world");
console.log(greeter.greet());

*/