let bo:boolean=false
let un:undefined=undefined
let str:string='sa'
let num:number=12
let ar:Array<number>=[1,2]
let a:number[]=[12,21]
let text:string=`${str}`
let y:[string,number]
y=['12',12]
y[0]
y[1]=123
enum Color{red=1,green=2,blue=3}
let c:Color=Color.red
let na:string=Color[2]
let as:any=[1,'12'];
(function():void{
})();
(function():number{
return 1
})()
let obj:object=[1,2]
let ob:object=function(){}
interface deep{
name:string,
age:number,
job?:string
}
function admin(a:deep):object{
return a
}
admin({name:'123',age:12})
interface no{
readonly who:string
}
let p:no={who:'12'}
let r:number[]=[1,23,3]
let g:ReadonlyArray<number>=r
interface fn{
read(a:number):number
}
class Xa implements fn{
read(a:number):number{
return a
}
}
interface a{
str:string
}
interface Ta extends a{
num:number
}
let v=<Ta>{
}
v.str='12';
let n:Ta={str:'12',num:12};
class rr{
constructor(){
}
};
class Str extends rr{
static a:string='12';
constructor(){
super()
}
getName(a:string):string{
return a
}
but():void{
console.log(Str.a)
}
}
abstract class An{
abstract sp():void
};
function l(...q:number[]):void{
console.log(q[0])
}
l(1,2)
interface lk{
str:string,
arr:number[]
}
interface Par{
child:string
}
interface Tas extends Par{
str:string,
arr:number[],
cd:object,
get(this:Tas):()=>lk,
child:string
}
let asa:Tas={
str:'123',
arr:[1,2,3],
child:"123",
cd:{
},
get:function(this:Tas){
return ()=>{
return {str:this.str,arr:[123]}
}
}
}
interface len{
length:number
}
function lei<T extends len>(arg:T):T{
return arg;
}//T为任意类型变量 len为约束 不再是任意类型 需要符合条件
// 因为number不包含长度length属性
lei({length:12,value:'12'})
function Pro<T>(obj:T,key){
return obj[key]
}
let x={a:1}
Pro(x,"a")
class Las<T>{
s:T
}
let my=new Las<number>();
enum E{
a=12,
b='as',
c='fs',
d='a'
}//运行时JavaScript的对象 默认自增 或者自己初始化
;
let gg:number=E.a;
console.log(E[gg])
//兼容 赋值 如果两个对象存在至少一个相同属性可以赋值
//函数比较只要形参类型有一个相同 少的比多的 就会正确 而多比少则报错 因为多出来的参数找不到类型
let at:symbol=Symbol('123')
let gt:object={
[at]:12
}
2021-1-16更新学习
function fu(this:Window) {
console.log(this)
}
class Ass {
namea?:number
back:object=():void=>{}
readonly name: string = '12'
static age: number = 12
constructor (namea:number) {
}
}
Ass.age // 静态属性
const per = new Ass(12)
per.name // 只读
Gem.a // 枚举 把可能的情况列举出来
let as:number
let asa:unknown
asa = 123
asa = asa as number
let aaa:number = Gem.a
let j: {name:string} & {age:number}
j={
name:'12',
age:21
}
type myNum = 1|2
let sasa:myNum
sasa=2
type myString = string // 类型别名 可以简单数据类型 可以引用对象数据类型
interfance My {name:string}
// 接口与别名在限制对象属性一致 但接口可以限制class
type obj = {
name:string
}
let aaa:obj = {
name:'123'
}
let bbb:obj = {
name: '123'
}
let sa:myString = '21'
let h:[number,number]
h=[1,2]
aa(12,'12')
let a: object = [{a:1}]
enum Color {red=1,green,blue}
let d:Color = Color.red
interface obj{
a:1
}
function c(arg:obj | string):void{
}
