export const aa=function():void{
const arr:Array<any>=[1,2,3]
console.log(arr[0])
}
export const asy=async function():Promise<any>{
function Show():Promise<any>{
return new Promise((resolve,rejects)=>{
resolve({
user:"liu",
pass:"123"
})
})
}
return await Show()
}
let bo:boolean=false
let un:undefined=undefined
let nu:null=null
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 Tas{
str:string,
arr:number[],
cd:object,
get(this:Tas):()=>lk
}
let asa:Tas={
str:'123',
arr:[1,2,3],
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;
}
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'
}
;
let gg:number=E.a;
console.log(E[gg])
let at:symbol=Symbol('123')
let gt:object={
[at]:12
}
Processed:
0.010, SQL:
9
