## ts 新增类型

```js
any :任意类型
void :没有类型
never:不存在类型
unknow:未知类型

tule:
void 配合 undefined
unknow 可以写任意类型 配合 类型推导使用 typeof instanceof
tuple: 元组固定类型长度
enum:枚举
interface:接口
class
泛型
```


## never
```js
1.函数永远不会返回
如果一个函数要么抛异常，要么进入死循环，那它的返回值类型就是 never：
function throwError(message: string): never {
  throw new Error(message); // 永远不会正常返回
}

function infiniteLoop(): never {
  while (true) {} // 死循环
}

2.用在类型推断中（类型保护兜底）
never 常用来确保类型分支被穷尽处理（exhaustive check）：

type Shape = 'circle' | 'square' | 'triangle';

function getArea(shape: Shape) {
  switch (shape) {
    case 'circle':
      return '圆';
    case 'square':
      return '方';
    case 'triangle':
      return '三角';
    default:
      // 如果上面漏了某个类型，这里 shape 会是 never
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}
```
## tuple

```js
const t :[string,number] = ['11',123]
```
## enum
```js
enum Direction {
  Up,    // 0
  Down,  // 1
  Left,  // 2
  Right  // 3
}

let dir: Direction = Direction.Up;
console.log(dir); // 0


enum Direction {
  Up = 1,
  Down,   // 2
  Left,   // 3
  Right   // 4
}

enum Direction {
  Up = 1,
  Down,
  Left,
  Right
}

console.log(Direction.Up);    // 1
console.log(Direction[1]);    // "Up"
```
## interface

```js
interface Person {
  name: string;
  age: number;
}

let p1: Person = {
  name: "Tom",
  age: 20
};

interface Person {
  name: string;
  age?: number; // 可选
}

let p2: Person = { name: "Jerry" }; // ✅ age 可省略

interface Point {
  readonly x: number;
  readonly y: number;
}

let pt: Point = { x: 10, y: 20 };
pt.x = 30; // ❌ 无法修改

interface A { a: number }
interface B { b: number }
interface C extends A, B { c: number }


定义函数类型

interface Add {
  (x: number, y: number): number;
}

const add: Add = (a, b) => a + b;


接口合并（独有特性）
接口同名时会自动合并：

interface User {
  name: string;
}
interface User {
  age: number;
}

let u: User = { name: "Tom", age: 20 };


索引签名
interface StringArray {
    [index:number]:string;
    
}

let arr: StringArray = ["a", "b", "c"];

绕开多余的属性检查
1.类型断言
interface BaseParams {
    t1:string;
   2.索引签名
   [prop:string]:any;
}
const getType = (p:BaseParams):string=>{
return `${p.t1}` 
}

getType({
t1:'1'
} as BaseParams)

3.类型兼容
let p = {
t1,t2
}
getType({p})

接口定义方法
interface Base { 
  (n:number):string
}
const find: Base = (n) => {
  return n.toString();
}


```
## class

```js
多继承，单实现
接口继承类，类实现接口
class A {
  c = 1;
  constructor(c?: string) {}
}
let adcsd = new A();
console.log("print ~ adcsd:1", adcsd);
class B extends A {
  d = 2;
  constructor(d?: string) {
    super();
  }
}
interface D {
  a: string;
  b: string;
}
class C implements D {
  constructor(public a: string, public b: string) {}
}

let c = new C("1", "2");
console.log("print ~ c:", c);
```
## 泛型

```js
const test = <T>(t1: T): T => {
  return t1;
};
console.log("print ~ test:", typeof test<string | number>("1"));
```

ts使用

## 容器操作
```js
# 查看运行中的容器
docker ps

# 查看所有容器（包括停止的）
docker ps -a

# 启动容器
docker start <容器ID/容器名>


# 停止容器
docker stop <容器ID/容器名>

# 重启容器
docker restart <容器ID/容器名>

# 删除容器
docker rm <容器ID/容器名>

# 强制删除运行中的容器
docker rm -f <容器ID/容器名>

# 进入运行中的容器（交互模式）
docker exec -it <容器ID/容器名> /bin/bash

# 查看容器日志
docker logs -f <容器ID/容器名>

```
## 镜像操作
```
# 查看本地镜像
docker images

# 搜索镜像
docker search <镜像名>

# 拉取镜像
docker pull <镜像名>:<版本号>
# 例子
docker pull nginx:latest

# 删除镜像
docker rmi <镜像ID>


# 强制删除镜像
docker rmi -f <镜像ID>

# 根据Dockerfile构建镜像
docker build -t <镜像名>:<版本号> .

# 给镜像打标签
docker tag <镜像ID> <新镜像名>:<版本号>
```

## 容器运行

```js
# 运行容器（后台运行）
docker run -d --name <容器名> <镜像名>

# 运行容器并映射端口
docker run -d -p 主机端口:容器端口 --name <容器名> <镜像名>

# 运行容器并挂载目录
docker run -d -v 主机目录:容器目录 --name <容器名> <镜像名>

# 运行容器并设置环境变量
docker run -d -e KEY=VALUE --name <容器名> <镜像名>

```
## 系统清理
```
# 删除所有已停止容器
docker container prune

# 删除所有未使用镜像
docker image prune

# 删除未使用的容器、镜像、网络等（危险）
docker system prune

# 删除未使用的容器、镜像、网络和卷（更危险）
docker system prune -a --volumes

```

## 网络 & 数据卷
```
# 查看网络
docker network ls

# 创建网络
docker network create <网络名>

# 查看卷
docker volume ls

# 创建卷
docker volume create <卷名>

# 删除卷
docker volume rm <卷名>

```

docker基本命令

## 柱状图

![image.png](/static/img/51071b1b97650b99b5a89d7eb10bd130.image.webp)


```
let xData = ['温度', '空气', '视觉'];
let yData = [27, 21, 21];
let barWidth = 30;
option = {
  grid: {
    top: '18%',
    left: '5%',
    bottom: '3%',
    right: '5%',
    containLabel: true,
  },
  tooltip: {
    show: true,
  },
  legend: {
    
    top: '1%',
    textStyle: {
      color: "#fff",
      fontSize: 12
    },
    itemWidth: 15,
    itemHeight: 15,
    selectedMode: false,
  },
  animation: false,
  xAxis: [{
    type: 'category',
    data: xData,
    axisTick: {
      show:false,
      alignWithLabel: true,
    },
    nameTextStyle: {
      color: '#82b0ec',
    },
    axisLine: {
      show: false,
      lineStyle: {
        color: '#82b0ec',
      },
    },
    axisLabel: {
      show:true,
      margin:20,
      textStyle: {
        color: '#fff',
      },
    },
  }, ],
  yAxis: [{
    show: true,
    min:0,
    max:100,
    // name:'单位：篇',
    nameTextStyle: {
      fontSize: 12,
      fontFamily: 'PingFang SC',
      color: '#fff'
    },
    type: 'value',
    axisLabel: {
      show:false,
      textStyle: {
        color: '#fff',
      },
    },
    splitLine: {
      show:false,
      lineStyle: {
        color: '#324979',
        type: 'dashed',
      }
    },
    axisLine: {
      show: false,
    },
  }, ],
  series: [{
      name: '',
      type: 'pictorialBar',
      symbolSize: [barWidth, 5],
      symbolOffset: ['0', -3], // 上部椭圆
      symbolPosition: 'end',
      z: 12,
      color: '#2185f0',
      data: yData,

    },
    {
  
      type: 'pictorialBar',
      symbolSize: [barWidth, 5],
      symbolOffset: [0, 3], // 下部椭圆
      // barWidth: "20",
      z: -10,
      color: '#228fe1',
      data: yData,
    },
      {

      type: 'pictorialBar',
      symbolSize: [barWidth, 5],
      symbolOffset: [0, 0], // 下部椭圆
      // barWidth: "20",
      z: -10,
      color: '#228fe1',
      data: [100,100,100],
       symbolPosition: 'end',
    },
    {
    
      type: 'bar',
           barCateGoryGap: 0,
      barWidth: barWidth,
   showBackground: true,
      backgroundStyle: {
        color: 'rgba(180, 180, 180, 0.2)',
         shadowOffsetY:100,
      },
    
      itemStyle: {
        normal: {
          color: new echarts.graphic.LinearGradient(0, 0, 0, 0.9, [{
              offset: 0,
              color: '#228fe1',
            },
            {
              offset: 1,
              color: '#228fe1',
            },
          ]),
          opacity: 0.8,
        },
      },
      data: yData,
    },
  ],
};
```
## 雷达图
![image.png](/static/img/edaf6b18f6cb80442086e0d5594c975a.image.webp)
```
 
 let x1 = [3.34, 3.34, 3.34, 3.34]
 let x1Name = '房间当天值'
 let x2 = [6.87, 6.87, 6.87, 6.87]
 let x2Name = '楼宇当日平均值'
 option = {
  backgroundColor: '#0a1627',
  title: {
    text: '20栋103房间/20号楼宇-当日均值',
    subtext: '(2025.2.24)',
    top: 20,
    left: 'center',
    textStyle: {
      color: '#ffffff',
      fontSize: 20
    },
    subtextStyle: {
      color: '#cccccc',
      fontSize: 14
    }
  },
  grid:{
    width:100,
    height:100,
    containLabel:true,
  },
 legend:[
    {
        orient:'vertical',
        icon: 'circle', //图例形状
        top:35,
        right:40,
        itemWidth: 10, // 图例标记的图形宽度。[ default: 25 ]
        itemHeight: 10, // 图例标记的图形高度。[ default: 14 ]
        itemGap: 15, // 图例每项之间的间隔。[ default: 10 ]横向布局时为水平间隔，纵向布局时为纵向间隔。
        borderColor: 'rgba(255,255,255,0.3)',
        borderWidth: 1,
        borderRadius:8,
       
        borderType:'dashed',
        padding: [12, 10, 12, 10],
        // padding: 10,
        textStyle: {
            fontSize: 10,
            color: '#FFF',
        },
    },
     {
     
        icon: 'circle', //图例形状
        top:348,
        left:180,
        itemWidth: 8, // 图例标记的图形宽度。[ default: 25 ]
        itemHeight: 8, // 图例标记的图形高度。[ default: 14 ]
        itemGap: 12, // 图例每项之间的间隔。[ default: 10 ]横向布局时为水平间隔，纵向布局时为纵向间隔。
        
        borderRadius:8,
        borderType:'dashed',
        padding: 12,
        // padding: 10,
        textStyle: {
            fontSize: 12,
            color: '#FFF',
        },
         // 自定义显示内容
    formatter: function (name) {
        // 你可以这里自定义，返回你想展示的文字
        // 比如原来叫 "房间当天值"，你可以改成 "房间当天值 3.34 kWh"
        if (name === '房间当天值') {
            return x1[1];
        } else if (name === '楼宇当日平均值') {
            return x2[1];
        } else {
            return 0; // 其他保持不变
        }
    }
    },
    
    ],
  radar: {
    radius: '45%',
    splitNumber: 7,
    axisName: {
      color: '#ffffff',
      fontSize: 12,
       backgroundColor:'red',
   lineHeight:20,
       borderRadius:5,
       padding: [5,10,5,10]
    },
    shape: 'circle',
    axisNameGap:30,

    splitLine: {
      lineStyle: {
        color: '#1c3a5d'
      }
    },
     axisLabel:{
       show:true,
       fontSize:10,
        align:'center',
        formatter:(data)=>{
          return Number(data).toFixed(0)
        },
     },
    splitArea: {
      areaStyle: {
        color: ['transparent']
      }
    },
    axisLine: {
      lineStyle: {
        color: '#1c3a5d'
      }
    },
    indicator: [
      { name: '日用电量峰值 (kWh)', max: 10 },
           { name: '工作时间    \n用电量 (kWh)', max: 10 },
                 { name: '休息时间用电量 (kWh)', max: 10 },

      { name: '日总用电量 (kWh)', max: 10 },
    ]
  },
  tooltip: {
    trigger: 'item'
  },
  series: [{
    type: 'radar',
    data: [
      {
        value: x1,
        name:x1Name,
        areaStyle: {
          opacity: 0.3
        },
        lineStyle: {
          color: '#56FEFE'
        },
        itemStyle: {
          color: '#56FEFE'
        }
         
      },
      {
        value: x2,
        name: x2Name,
        areaStyle: {
          opacity: 0.1
        },
        lineStyle: {
          color: '#FF0800'
        },
        itemStyle: {
          color: '#FF0800'
        }
      }
    ]
  }]
};
```
## 折现图 区域范围

![image.png](/static/img/567120a0ac0217c61463d042efde6bf2.image.webp)
```
     markArea: {
                silent: true,
                itemStyle: {
                    color: 'rgba(0,255,255,0.15)',
                    borderWidth: 0,
                    borderColor: '#f6c343'
                },
                label: {
                    show: true,
                    color: '#00ffff',
                    fontSize: 14
                },
                data: [
                   
                    [
                        {
                            xAxis: '13:30',
                            yAxis: 4,
                            label: { formatter: '空调关闭压缩机、水箱释冷', position: 'inside' }
                        },
                        { xAxis: '15:00', yAxis: 2 }
                    ],
                 
                ]
            }
            ```

echart图表

## nest g（generate ）
```
简写	完整写法	说明	
co	controller	生成控制器	
s	service	生成服务类	
mo	module	生成模块	
cl	class	生成普通类	

in	interface	生成接口	
en	enum	生成枚举	
gu	guard	生成守卫	
mi	middleware	生成中间件	
pi	pipe	生成管道（Pipe）	
in	interceptor	生成拦截器	
de	decorator	生成装饰器	
fi	filter	生成异常过滤器	
res	resolver	生成 GraphQL resolver	
lib	library	生成库（在 monorepo 中）	
```
## option
```
参数	含义	
--flat	不生成目录，文件直接在当前目录下	
--spec	是否生成测试文件（默认为 true）	
--no-spec	不生成 .spec.ts 文件	
--path	指定生成文件的路径	
```