元组是固定长度固定类型的数组，有利于数据判断，逻辑处理
声明一个元组的时候一定要指明类型，不指定类型它就是一个普通数组
bug：使用.push可以无限的追加元素

元祖：固定长度、类型、类型顺序的数组类型；

push可以突破元祖类型限制

const person1 = [1, 'name']  // --- 不是元祖，是联合类型，仅限制类型；长度及类型顺序无限制

Array 数组类型

tuple 元组类型

Array数组

数组中可以存放任意类型的数据，JS中数组的宽容度非常大，TS也很好的继承了这一点

let list: number[] = [1,2,3,4]

let list2: Array<number> = [1,2,3,4]

let list3 = [1,2,3,4]

let list4 = [1, "add"]

let list5: any[] = [1, "dss", true]

tuple元祖：固定长度，固定类型的数组

let person1: [number, string] = [1, "jack"]

tuple元祖bug：person1.push(3) 不报错，不满足固定长度的定义

声明元祖一定要指明类型，不指明类型就是普通的array

1、tuple元组类型定义

固定长度，固定类型的array

2、元组的bug：

*使用push可以突破元组界限，无限添加元素

*使用一个元组时一定要指明类型，没有指明的话就是一个普通数组

tuple 元祖，固定长度，固定位置类型的数组；

有个bug：可以push追加元素；

数组

[] 中括号创建数组

数组中存放任意类型的数据，可以是不同类型的

tuple元组类型

固定长度及类型的数组。

1. 声明元组的时候一定要指明数据类型。只有制定了类型才算是元组，否则是普通的Array

2. 元组目前是有Bug的，push方法可以越界push

   

快点快点快点快点打开空调开快点

元组：固定长度，固定类型的特殊数组，用push会突破长度限制，但需要在约定类型内

let person = [1, 'abc']:这种不属于元组，是属于联合类型数组

let person：(number, string)[] = ['abc', 1, true]

Array

数组中可以存放任意类型的数据，混合各种数据

let list1: number[] = [1, 2, 3, 4]; // 标准写法

let list2: Array<number> = [1, 2, 3, 4]; // 泛型写法

let list3 = [1, 2, 3, 4]; // 最简单的写法

// 混合类型数据 联合类型

let list4 = [1,'ddd'];  // (number | string)[];

let list5: any[] = [1, 'dss', true]; // any[];

tuple（读音： Tiu破，踏破） 元组类型

 固定长度，且每个元素类型固定，特殊数组

let person1:[number, string] = [1, 'zengfan'];

存在bug 使用数组方法也是可以操作的 比如person1.push() 生命元组时一定要指定类型

let list1: number[] = [1, 2, 3, 4, 5]; // number数组类型

let list2: Array<number> = [1, 2, 3, 4, 5]; // 泛型

let list3= [1, 2, 3, 4, 5];

let list4 = [1, "dd"];

let list5: any[] = [1, "dss", true];  // any数组类型

// tuple  固定长度、固定类型的array

let person1: [number, string] = [1, "hhh"]; // 元组(特殊数组，固定长度，固定类型)

let array: Array<number> = [1,2,3] // 泛型

let array: any[] = [1,2,3,'ddd',true] // any数组类型

let array: number[] = [1,2,3] // number数组类型

let person1: [number, string] = [1,'ddd'] // 元组(特殊数组，固定长度，固定类型)

array数组

let 变量:类型[]

let 变量:Array<类型>  范型

根据上下文关系

any 泛指任何类型

let 变量:any[]

tuple元祖类型:固定类型固定长度的数组

let 变量:[类型1,类型2]

注:1 元祖类型有个bug,直接给未存在索引赋值会报错,直接push不会

    2 声明一个元祖时必须指定类型,不然就是一个数组

元组即给一个数组设置固定的长度和每个下标值的固定类型，否则这不是元组，是union类型，系统会根据初始内容分配类型，不是固定长度固定类型

let person1:[number,string] = [1,"alex"] 固定长度 固定类型的数组

person1[0] = "ddd"

person1[1] = 111

person1[2] = 111

元祖 目前来说还有bug

person1[2] = 3  报错

person1.push(3) 不报错  

let list1:number[] = [1,2,3,4]

let list2:Array<number> = [1,2,3,4]

let list3 = [1,2,3,4]

let list4 = [1,"ddd"]

let list5:any[] = [1,"dss",true]

// 数组 array

let list1: number[]=[1,2,3,4];

let list2: Array<number>=[1,2,3,4];

let list3 = [1,2,3,4];

let list4: any[]=[1,"dss",true];

// tuple 元组 ： 是特殊的数组 是固定长度，固定类型。

//  bug : 可以[].push()  一定指定类型

list person1:[number,string]=[1,"aaaa"]

let  list1 : number[]=[1,2,3,4]

let list2 :Array<number>=[1,2,4,5]

数组 array

let list1: number[] = [1,2,3,4]

let list2: Array<number> = [1,2,3,4]

let list3 = [1,2,3,4]

let list4 = [1,'aa']

let list5: any[] = [1,'aa',true]

元组 tuple（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

let person1: [number, string] = [1, 'lulingkun']

元组是一个特殊的数组，是固定长度固定类型的数组

元组bug：person1[2] = 3; 报错，但 person1.push(3) 不报错可以通过编译

let person2 = [1, 'lulingkun']; 这不是元组类型，而是union array，联合类型数组，本质上就是数组，既没有固定长度也没有固定类型，是混合number和string的类型

1. 声明数据的三种方式：

   

   这三种声明方式都表示数值类型

2. 可以用以下两种方式声明数组元素的类型

   

   第一种表示数组里面只能存放number和string类型的元素

   第二种any表示可以存放任意一种类型

3. 元组为固定类型固定长度的数组

   

   上图中第一个类型必须为数值类型，第二个类型必须为字符类型，否则会报错。

使用元祖的注意事项：

• 目前尚有bug，慎用

  

  图中元祖只能是2个元素不能有3个元素然后没有报错

• 使用元祖必须指明类型，否则它就是普通数组

  
  

text

元祖(Tupple)就是固定长度、固定类型的数组,使用时要注意两点
1、元祖的bug: 可以使用push更改数组长度,idea不报错,编译也不报错
2、声明元祖时,一定要指定数据类型

元组就是固定类型，固定长度的数组。

元组的bug：person.push(3)

str:number=1

str:boalean=true

str:string="true"

let list:number[] = [1,2,3,4]

let list:Array<number> =[1,2,3,4]

let list:any[] = [1,'true',true]