interface ClassA{
    name:string;
    age:number
}
interface ClassB{
    name:string;
    phone:number;
}

type Class = ClassA & ClassB
let info:Class = {
    name:'zhagsan',
    age:18,
    phone:1573875555
}

interface X{
	q:number,
	w:string
}
interface Y{
	q:boolean,
	r:string,
}
type XY = X&Y

interface A {
    inner: D;
}
interface B {
    inner: E;
}
interface C {
    inner: F;
}

interface D {
    d: boolean;
}
interface E {
    e: string;
}
interface F {
    f: number;
}

type ABC = A & B & C;
let abc: ABC = {
    inner: {
        d: false,
        e: 'className',
        f: 5
    }
};

let a:string|number|boolean;
a = 's';
a = 1;
a= false;

interface X{
	q:number,
	w:string,
	r:string
}
interface Y{
	q:number
	r:string,
}
type XY = X | Y
let value:XY = {
    q:1,
    r:'r'
}

interface X{
	x:()=>string;
	y:()=>Number;
}
interface Y{
	x:()=>string;
}
type XY = X|Y;
function func1():XY{
//此處不進(jìn)行類型斷言為XY在編輯器中會(huì)報(bào)類型錯(cuò)誤
  return {} as XY

}
let testFunc = func1();
testFunc.x();
testFunc.y(); //Error：類型“XY”上不存在屬性“y”，類型“Y”上不存在屬性“y”。

if('x' in testFunc) testFunc.x()

type A = 'a' | string;  //string類型
type B = false | boolean; //bolean 類型
type C = 1 | number; //number類型

enum Class{
   A,
   B
 }
type C = Class.A | Class;//Class類型

interface A{
   name:string
}
interface B{
   name:string | number
   [property:string]:any
}
type AB = A|B