function Greeter(greeting) {
  	this.greeting = greeting;
}
  
Greeter.prototype.greet = function() {
  	return "Hello, " + this.greeting;
}
  
// 我们本来想传入一个字符串, 但 "不小心" 传入了一个对象. 
// 它会输出 "Hello, [object Object]" 而不是 "Hello, world", 并且不会提示错误.
var greeter = new Greeter({message: "world"});  
  
var button = document.createElement('button');
  	
  button.textContent = "Say Hello";

button.onclick = function() {
  	  alert(greeter.greet());    	
  };
  
document.body.appendChild(button);

  
topic.subscribe = function ():void{
      callbacks.add.apply(topic, arguments);
      if (this.logger) {
          try {
          	this.logger.log("topic with id: " + topicName + " received message: " + JSON.stringify(arguments).substring(0, 80));
          } catch (e) {
          	this.logger.log("topic with id: " + topicName + " received message: " + arguments[0].toString().substring(0, 80));
          }
      }
  };

  // 可选参数, 可以有多个, 但必须在末尾.
  // 也可以显示声明返回值类型.
  function optional(a: string, b?: boolean): Date {
  	return b ? new Date() : null; // null 可以匹配任何类型.
  }
  
 
  // 除了可选参数, 还有可变数目的参数.
  // 参照编译结果可知, TypeScript 会生成一小段逻辑, 将后面的参数放到一个数组里.
  function params(a = 0, ...args: any[]) {
  	// 当在下方被调用时, args 是一个值为 ['abc', 'def', 456] 的数组.
  }

	class MyClass {
	    foo() {
	        setTimeout(() => {
	            // 这里的 this 会保留上一个作用域中 this 的值.
	            // 所以它是 MyClass 的实例.
	            this.bar();
	        }, 0);
	        
	        // 类型标记类似于普通函数.
	        // 当然向这里, TypeScript 可以推断出该函数返回值类型是 number, 无需明确注明.
	        // 不过我个人习惯进行标注.
	        var fn = (): number => {
	            return 0;
	        };
	        
	        // 还可以写得更短,
	        // 并且 TypeScript 允许重复声明变量, 只是如果出现了这种情况, 要求变量的类型必须完全相同.
	        var fn = () => 0;
	        
	        // 另一个例子.
	        var timer = setTimeout(() => clearTimeout(timer), 1000);
	
	        // 如果函数只有一个参数, 可以省略括号 (如果有类型标注, 则必须加上).
	        window.onload = event => {
	            console.log(event);
	            this.bar();
	        };
	
	        // 参照编译结果了解更多.
	    }
	    
	    bar() {
	        console.log('banana');
	    }
	}

  	class Module implements IModule {
		// 属性, 与变量相似, 只是不需要 var.
		modulePath: string;
	   	name: string;
	  	protected controllerTypes: Array<typeof Controller>;

		// 构造函数是可选的, 与普通函数的类型标注相似, 除了没有返回值类型.
		// 除此之外, 可以添加 public/private 关键字, 以此在声明参数的同时声明一个同名属性.
		// 当然, 该属性的值会被初始化为构造函数被调用时参数的值.
		constructor(public app: DhiApp) {
			this.app = app;
		}

		initialize(): void {
		}

		CreateController(view: View): IController {
			for (let val of this.controllerTypes) {
				if (view.controllerName == typeof val) {
					return new val(this, view);
       			}
			}
			return null;
    	}

    	PublishTopic(topicName: string, ...args: any[]): void {
        	this.app.Topic(topicName).publish(args);
      	};
    }

    class Demo extends Generic.Module {
		moduleName: string;
		constructor(app: Generic.DhiApp, element: HTMLElement) {
		//初始化必须，继承父类的方法	        
			super(app);
	        this.moduleName = 'Demo';
	   	}
	
  	    initialize() {
  			//可选继承父类的方法
  	        super.initialize();
  	        this.app.Topic('Demo.render').subscribe(() => this.render());
  	        this.render();
  	    }
	
  	    render() {
  	        $('body').html('ddd');
  	        var url = this.app.request.buildPath('Controller', 'Section', {});
  	        console.log(url);
  	        $('body').html(url);
  	    }
    }

  // 熟悉 C# 的同学可能就轻车熟路了, 或者熟悉其他语言中泛型的同学应该变通一下也很好理解.
  // 和函数参数一样, 可以有两个三个很多个~

  class Greeter<T> {
    	greeting: T;
    	constructor(message: T) {
    		this.greeting = message;
	    }
	    greet() {
	    	return this.greeting;
	   	}
  }

  // 这里指定了上方的 T 类型为 string, 那么对应的构造函数参数 message, 属性 greeting
  // 的类型都应该为 string.

  var greeter = new Greeter<string>("Hello, world");

  module Generic {
      // 模块 Topic.
      export class Topic implements ITopic {
          topicName: string;
          constructor(topicName: string) {
              this.topicName = topicName
          };
          publish(args?: Object): void { };
          subscribe(func: Function): void { };
          unsubscribe(func: Function): any { };
      }
  }
  
  var topicName:string = "Test"

  var topic: Topic = topicName && this.topics[topicName];

  topic = new Generic.Topic(topicName);

	
	export interface ITopic {
		publish(args?: Object): void;
		subscribe(func: Function): void;
		unsubscribe(func: Function): any;
	}
	
	export class Topic implements ITopic {
		topicName: string;
		constructor(topicName: string) {
			this.topicName = topicName
		};
		publish(args?: Object): void { };
		subscribe(func: Function): void { };
		unsubscribe(func: Function): any { };
    }
	
	// 表示一个函数.
	interface IHandler {
	    (event: Event): void;
	    // 重载与上面的类似.
	}
	
	var c: IHandler = event => {
	    // 同上, 编译器会知道 event 的类型为 Event.
	    return;
	};

	declare interface IApp { }

	declare class DhiApp implements IApp { }

  
  /// <reference path="path-to-your-ts-file" />
  	
  /// <reference path="typings/dhiapp/extensions.d.ts" />